To achieve maximum levels of freedom and expressiveness, Luna allows calling methods on polymorphic arguments. Of course it's not always possible to infer what is the result type, so in this case we leave this unsolved until the real type is really needed. If you're familiar with the "duck typing" technique from dynamic languages, it's exactly the same in Luna, except when it's not really possible to call the function, you still get a compile-time error. Consider the following function:
def callSucc a: a.succ
What is its type? Since we haven't defined what is the type of
a, we are assigning it a type parameter
b. Now, what is the type of method
succ on a type
b? We can never know, as it depends on the implementation of a particular class that will be used. Hence, the type of
callSucc is simply
b -> b.succ. You can read it as "a function that takes an argument of type
b and returns whatever the method
succ of class
b returns". We can now write
callSucc 1, since the
succ method is defined for
callSucc "hello" will result in a compile error.
Type assumptions and the process of typechecking
Luna's typechecker stores some additional assumptions about type parameters, that need to be met by the types substituted for the variables. Those usually arise from manually typed functions and using methods on polymorphic values. Let's start with a simple example. The
+ operator is defined in Luna standard library as:
def + :: a -> a -> a def + x y = x.+ y
This definition allows us to write expressions like
5 + 7 or
"foo" + "bar", but will reject
"foo" + 5 (because arguments' types are different) or
Just 5 + Just 7 (because the
+ method is not defined for the
Maybe class). So what is really going on here?
First of all, the user-specified type indicates that both the arguments and the return type need to be of the same type.
Second, the use of the method
+ indicates that the type
a needs to have this method defined. Moreover, this method needs to take a single argument of type
a and return a result also of type
All this allows us to describe the type of function
+ :: a -> a -> a
a such that
a.+ = a -> a
All this is handled by the Luna compiler under the hood, so that you don't need to think about all the assumptions present.
Let's consider another example:
def foo x: x.succ + 1
What is the type of this function?
First of all, we can see that the result of
x.succ is added to an
Int, so (from the definition of
+ above) we know that
x.succ :: Int and that the result of this function is also an
Int. So the final type with the underlying assumptions is:
foo :: a -> Int
a such that
a.succ = Int
All those assumptions can grow with more complex, multiline functions. That's why Luna tracks them under the hood, revealing them only when some of them can't be satisfied.