We have 2 functions
- identity just returns its first argument
- test accepts a Nat → Nat function and calls it
Why cannot we use identity as an argument for the test function?
I am getting “expression of type … cannot produce expected type” error.
2 Likes
I cant speak to the technical reason but you can get around it with another function
ignore test(func (n: Nat) = identity<Nat>(n));
https://m7sm4-2iaaa-aaaab-qabra-cai.ic0.app/?tag=1307026162
It is a good thing there is a way to get around it, yet still I hope we’d be able to do it the correct way one day
I think it works in the example you shared because we explicitly specify <Nat> parameter
On the other hand, if we don’t call the identity function (just pass it around, as in my example), there is no way to explicitly specify the parameter
Do you mean you want to be able to write:
ignore test(identity<Nat>);
?
Hopefully, It works even without <Nat>. But identity<Nat> would be a good workaround
I sympathize with this and it is definitely what users expect from ML-like languages (SML, OCaml, F#, Haskell).
Unfortunately, it might actually be problematic for the subtyping we use in Motoko, i.e. it is possible it makes subtyping undecidable. Would need to look at the literature to be sure.
1 Like
It is strange that inline function works here even without specifying parameter type and return type
ignore test(func(n) = identity(n)); (modified @Gekctek’s suggestion)
but we still can not pass a function with type parameters directly
Type instantiation is part of function call syntax in Motoko, it does not exist as a stand-alone thing – dually, you cannot introduce generic parameters without function parameters, and there are no generic types independent from functions. It behaves similar to most conventional languages rather than ML-style ones in that regard.
There are a few technical reasons for this, which have to do with compilation, side effects, and the lack of partial application in Motoko. FWIW, I don’t think subtyping poses a problem here, it primarily comes down to a form of currying (with runtime type passing, it literally is), but Motoko does not support that either.
@ZhenyaUsenko, this is no different from regular parameters, where you cannot pass a two-argument function f as test(f(3)), but have to write test(func(n) = f(3, n)) instead.