Function types

Function types

This article builds on my earlier articles on algebraic data types in on Raku and their use in the practical example of list-based parser combinators.

In this article I want to look at function types in some detail, and show a way to create well typed functions in Raku. If you are not familiar with functional programming (or with Raku), I suggest you read my introduction “Cleaner code with functional programming”. If you are not familiar with algebraic data types, you might want to read the other two articles as well. For most of the article, I provide examples in Raku, Python, Rust and Haskell. There is also some C and even some Fortran.

Type signatures

A function’s type signature consists of the types of each of its arguments and the return type. In most typed languages, the type is part of the function signature.

For example in C

int sqsum(int,int);

int sqsum(int x, int y) {
    return x*x+y*y

or in Fortran

integer function sqsum(x,y)
    integer :: x,y
    sqsum = x*x+y*y
end function

or in Rust

fn sqsum((x, y): (i32, i32)) -> i32 { x*x+y*y }

let sqsum  = |x : i32, y: i32| -> i32 {x*x+y*y};

or in Raku

sub sqsum(Int, Int --> Int) {...}
sub sqsum(Int \x, Int \y --> Int) { x*x+y*y }

my &sqsum = sub (Int \x, Int \y --> Int) { x*x+y*y };

or in Python, using the typing module:

from typing import Callable

def sqsum_(x: int, y: int) -> int:  
    return x*x+y*y

sqsum : Callable[[int,int], int]  = lambda x,y : x*x+y*y

The type of a function of functions

But what happens if we want to provide a function argument that is itself a function, or return a function (so-called higher-order functions)?

This is possible in most languages, but what I am interested in is the type information: what is the type signature of such a function of functions?

C supports functions-of-functions indirectly through function pointers, by creating a function type through a typedef.

typedef int (*Fun)(int,int);

int ten_times (Fun f) {...};

Maybe surprisingly, venerable old Fortran does support passing functions and subroutines as arguments. Functions are typed by their return type; subroutines are not typed.

program fof 
    external :: sqsum
    call ten_times(sqsum)
end program fof

subroutine ten_times(f)
    integer :: f
    ! ...
end subroutine ten_times

In Rust you can provide the complete type of a function-as-argument:

fn ten_times<F>(f: F) where F: Fn(i32,i32) -> i32 {
// ...


In Python we can use Callable, which also allow for the complete type to be expressed.

from typing import Callable

def ten_times(f: Callable[[int, int],int]) -> None:
# ...

The same example in Raku becomes

sub ten_times (Sub \f:(Int,Int --> Int)) {


So we can also pass the complete type. An equivalent way to write this is using the & sigil which imposes the Callable type constraint:

sub ten_times (&f:(Int,Int --> Int)) {

The types can be nested too, e.g. ((Int, Int --> Int), (Int, Int --> Int) --> Int)) is a valid type signature.

Introducing the arrow

All of the above ways to express function type signatures are perfectly adequate in their respective languages. However, with the exception of Raku, they all share the problem that these function-of-function type signatures don’t compose very well: what if we want to write a function-of-function-of-function type? This is less far-fetched than it may seem. I would like to introduce a notation used in type theory. It is at the same time simple and powerful. If you are familiar with functional languages like Haskell, Idris or Agda, you already know it.

Instead of mixing the type with the function declaration, it is written separately. The name of the function is followed by a colon and the list types of the arguments and the return value. Each argument is separated by an arrow. The above example of a function of two integer arguments returning an integer would be:

sqsum : Int  Int  Int 

The function-of-a-function introduced above has as type:

ten_times : (Int  Int  Int)   Int

The parentheses group the type of the function that is the only argument of ten_times.

In this notation, the arrow can be interpreted as an operator which creates a function type from the two types that are its arguments. The important property of this operator is that it is right associative. What this means is that for example

f : t1  t2  t3  t4

is the same as

f : t1  t2  (t3  t4)

and as

f : t1  (t2  t3  t4)

and for completeness

f : t1  (t2  (t3  t4))

A detour into partial application

The above groupings imply that our function f can be interpreted in three ways, as a function of:

  • 3 arguments of types t1,t2,t3, returning a result of type t4;
  • 2 arguments of types t1,t2, returning a result of type t3 -> t4;
  • 1 argument of types t1, returning a result of type t2->t3->t4.

Let’s say we have values v1,v2,v3 for the arguments and v4 as the result:

v4 : t4
v4 = f v1 v2 v3

But suppose we only apply v1 and v2:

pf1 : t3 ⟶ t4
pf1 = f v1 v2

We get a new function pf1 which takes a single argument v3:

v4 = pf1 v3

And in the same way we can create pf2 and pf3:

pf2 : t2  t3 t4
pf2 = f v1

pf3 : t3  t4
pf3 = pf2 v2

v4 = pf3 v3

Because pf1, pf2 and pf3 are functions and the above is true for all values of v1, v2, v3 and v4, it follows that

pf3 == pf1

For completeness, we can also apply pf2 directly to two arguments:

v4 = pf2 v2 v3

This concept of creating a new function by not providing values for some of the arguments is called partial application, and many languages support it. Here are examples in Haskell, Raku, Python and Rust.


In case you are not familiar with Haskell, this is what you need to know: it is whitespace-sensitive like Python, but has a markedly different syntax. Because everything is a function, there is no keyword to mark a function. Because there is only lexical scope, there is no need for any special scope identifiers. Function arguments are separated by spaces. Lambda functions (anonymous functions) start with a \, chosen because it looks a bit like the Greek letter lambda, λ.

-- named function of 2 arguments
sqsum x y = x*x+y*y
-- lambda function bound to a named variable
sqsum = \x y -> x*x+y*y

The type of sqsum is

sqsum :: Int -> Int -> Int

(Haskell uses :: rather than : for the type signature)

In Haskell, partial application works exactly as in the examples above. So our function sqsum can be partially applied like this:

sqsum4 :: Int -> Int
sqsum4 = sqsum 4

We can apply sqsum4 to the remaining argument:

sqsum4 3 -- returns 25

This is very neat. But suppose you want to apply the second argument, rather than the first one? The Haskell Prelude library provides the function flip, which simply flips the arguments:

flip :: (a -> b -> c) -> b -> a -> c 
flip f = \x y -> f y x

That is fine as far as it goes, but let’s do a somewhat contrived example. Let’s say we have a function of four arguments:

g :: t1 -> t2 ->t3 ->t4 ->tr
g x1 x2 x3 x4 = x1*x3-x2*x4

and we want to apply the 1st and 4th argument but not the others, something like g v1 _ _ v4.

One way to do this is to create yet another function (of course!):

apply14 :: (t1 -> t2 -> t3 -> t4 -> tr) -> t1 -> t4 -> (t2 -> t3 -> tr)
apply14 f x1 x4 = \x2 x3 -> f x1 x2 x3 x4

And with this function we can partially apply the 1st and 4th argument of g:

g14 = apply14 g v1 v4

This example mainly serves to illustrate the power of the arrow-based function type notation: it lays out the type of apply14 clearly and concisely.


Raku provides the method assuming, which acts as a generalised version of our apply14:

my &g14 = &g.assuming( v1, *, *, v4);


The return type of assuming is a Callable. This is a role for objects which support calling them. Thus, g14 can be called as if it was a regular function.


Python’s functools provide the partial function:

from functools import partial
g14 = partial(g, x1=v1,x4=v4)


The return type of partial is a partial object, which has an attribute partial.func, a callable object or function. Calls to the partial object will be forwarded to func with new arguments and keywords, so you can say g14(v2,v3) instead of g14.func(v2,v3).


Rust provides the partial! macro via its partial_application crate. Its behaviour is very similar to our apply14: “partial!(some_fn => arg0, _, arg2, _) returns the closure |x1, x3| some_fn(arg0, x1, arg2, x3)”.

extern crate partial_application;

fn g(x1: i32, x2: i32, x3: i32, x4: i32) -> i32 {

fn main() {
    let v1=...;
    let v2=...;
    let v3=...;
    let v4=...;
    let g14 = partial!(g => v1, _, _, v4);


Back to the function types

Suppose we want a type like the one we defined in C using a typedef, which encapsulates the function type:

typedef int (*Fun)(int,int);

In Haskell, that would be

newtype Fun = Fun Int -> Int -> Int

and we can generalise this to be a generic function of two arguments by using type variables instead of concrete types:

newtype Fun2Args a = Fun2Args a -> a -> a

So how would we use this? Let’s create an instance

ft :: Fun2Args a
ft = Fun2Args (\x y -> x*x+y*y)

This is fine, but to apply the function we first must unwrap the type constructor:

((\(Fun2Args f) -> f) ft ) 3 4

That is not very handy. A better way is to use the record type syntax which gives us an accessor function:

newtype Fun2Args a = Fun2Args { unF :: a -> a -> a}
ft = Fun2Args (\x y -> x*x+y*y)
(unF ft) 3 4

Now I have applied this to integer, but the type of the function is Num a => a -> a -> a, so this works for any type in the Num typeclass.

Named function types for Raku

In Raku, we can follow a similar approach of wrapping a function signature in a type, and it is actually simpler than in Haskell. We create a parametric role which takes the function as a parameter, and has a method with the signature of the function:

role Fun2NumArgs[&b] {
    method unF( Numeric \x,  Numeric \y --> Numeric) {

my \ft = Fun2NumArgs[ ->\x,\y {x*x+y*y} ].new;

say ft.unF(3,4); 

But what is the benefit of doing this? Surely we could just have done

my &f =  -> Numeric \x, Numeric \y --> Numeric {x*x+y*y};

say f(3,4);

For this simple example, that would indeed be enough as we don’t have functions of functions. But what we gain is that we can now create a function with arguments of type Fun2NumArgs:

sub fof (Fun2NumArgs \f1,Fun2NumArgs \f2 --> Fun2NumArgs) {

In other words, we can now have explicitly typed function signatures in Raku. Recall that without this approach, the type of a function would be Code or any dependant in the Code type graph. With the role-based type, the function must have the type of the method unF. Furthermore, these function types can be nested. Let’s create another type, for a function with two arguments of any type:

role Fun2Args[&b] {
    method unF( Any \x, Any \y --> Any) {

We create two instances of Fun2NumArgs:

my \ft = Fun2NumArgs[ ->\x,\y {x*x+y*y} ].new;
my \ft2 = Fun2NumArgs[ ->\x,\y {x*y+y+x} ].new;

And a function of these two functions using Fun2Args:

my \fof2 = Fun2Args[ 
        sub (Fun2NumArgs \f1,Fun2NumArgs \f2 --> Fun2NumArgs) {
            # returns another function of 2 Numeric arguments

We can now call the returned function like this:

say fof2.unF(ft,ft2).unF(3,4);

Having to call the unF method is not optimal. A better way is to can make the object itself callable instead, by defining the submethod CALL-ME instead of the method unF:

role Fun2Args[&b] {
    submethod CALL-ME( \x,  \y --> Any) {

# And similar for Fun2NumArgs

In this way, we can do:

say fof2.(ft,ft2)(3,4);

This is almost what we want. But we can remove the . as well, by making fof2 of type Callable. We can indicate this with the & sigil. But with the current definition of Fun2Args, this will result in a type error because Fun2Args is not callable. However, Callable is a role so all we need to do is mix it in:

role Fun2ArgsC[&b] does Callable {
    submethod CALL-ME( \x,  \y --> Any) {

In this way we have created something very similar to a function object, but using a role rather than a class. And now we can write:

my &fof3 = Fun2ArgsC[ 
        sub (Fun2NumArgs \f1,Fun2NumArgs \f2 --> Fun2NumArgs) {

say fof3(ft,ft2)(3,4);

To summarize, we create a parametric callable role where the parameter is the function to be called, and the signature of the CALL-ME submethod provides the type constraint to that function. Passing a function with a different signature will give a type error.

I think this is a nice way to have some additional type safety in your functional Raku code.

Bonus Tracks