Next: Calling higher-order terms, Up: Higher-order [Contents]

To create a higher-order predicate or function term, you can use a lambda expression, or, if the predicate or function has only one mode and it is not a zero-arity function, you can just use its name. For example, if you have declared a predicate

:- pred sum(list(int), int). :- mode sum(in, out) is det.

the following unifications have the same effect:

X = (pred(List::in, Length::out) is det :- sum(List, Length)) Y = sum

In the above example,
the type of `X`

, and `Y`

is ‘`pred(list(int), int)`’,
which means a predicate of two arguments
of types `list(int)`

and `int`

respectively.

Similarly, given

:- func scalar_product(int, list(int)) = list(int). :- mode scalar_product(in, in) = out is det.

the following three unifications have the same effect:

X = (func(Num, List) = NewList :- NewList = scalar_product(Num, List)) Y = (func(Num::in, List::in) = (NewList::out) is det :- NewList = scalar_product(Num, List)) Z = scalar_product

In the above example,
the type of `X`

, `Y`

, and `Z`

is
‘`func(int, list(int)) = list(int)`’,
which means a function of two arguments,
whose types are `int`

and `list(int)`

,
with a return type of `int`

.
As with ‘`:- func`’ declarations,
if the modes and determinism of the function
are omitted in a higher-order function term,
then the modes default to `in`

for the arguments,
`out`

for the function result,
and the determinism defaults to `det`

.

The Melbourne Mercury implementation currently requires that you use an explicit lambda expression to specify which mode you want, if the predicate or function has more than one mode (but see below for an exception to this rule).

You can also create higher-order function terms of non-zero arity and higher-order predicate terms by “currying”, i.e. specifying the first few arguments to a predicate or function, but leaving the remaining arguments unspecified. For example, the unification

Sum123 = sum([1,2,3])

binds `Sum123`

to a higher-order predicate term of type ‘`pred(int)`’.
Similarly, the unification

Double = scalar_product(2)

binds `Double`

to a higher-order function term of type
‘`func(list(int)) = list(int)`’.

As a special case, currying of a multi-moded predicate or function is allowed
provided that the mode of the predicate or function
can be determined from the insts of the higher-order curried arguments.
For example, ‘`P = list.foldl(io.write)`’ is allowed
because the inst of ‘`io.write`’ matches
exactly one mode of ‘`list.foldl`’.

For higher-order predicate expressions that thread an accumulator pair, we have syntax that allows you to use DCG notation in the goal of the expression. For example,

Pred = (pred(Strings::in, Num::out, di, uo) is det --> io.write_string("The strings are: "), { list.length(Strings, Num) }, io.write_strings(Strings), io.nl )

is equivalent to

Pred = (pred(Strings::in, Num::out, IO0::di, IO::uo) is det :- io.write_string("The strings are: ", IO0, IO1), list.length(Strings, Num), io.write_strings(Strings, IO1, IO2), io.nl(IO2, IO) )

Higher-order function terms of zero arity
can only be created using an explicit lambda expression;
you have to use e.g. ‘`(func) = foo`’ rather than plain ‘`foo`’,
because the latter denotes the result of evaluating the function,
rather than the function itself.

Note that when constructing a higher-order term,
you cannot just use the name of a builtin language construct
such as ‘`=`’, ‘`\=`’, ‘`call`’, or ‘`apply`’,
and nor can such constructs be curried.
Instead, you must either use an explicit lambda expression,
or you must write a forwarding predicate or function.
For example, instead of

list.filter(\=(2), [1, 2, 3], List)

you must write either

list.filter((pred(X::in) is semidet :- X \= 2), [1, 2, 3], List)

or

list.filter(not_equal(2), [1, 2, 3], List)

where you have defined ‘`not_equal`’ using

:- pred not_equal(T::in, T::in) is semidet. not_equal(X, Y) :- X \= Y.

Another case when this arises is when want to curry a higher-order term.
Suppose, for example, that you have
a higher-order predicate term ‘`OldPred`’
of type ‘`pred(int, char, float)`’,
and you want to construct a new higher-order predicate term
‘`NewPred`’ of type ‘`pred(char, float)`’ from ‘`OldPred`’
by supplying a value for just the first argument.
The solution is the same:
use an explicit lambda expression or a forwarding predicate.
In either case, the body of the lambda expression or the forwarding predicate
must contain a higher-order call with all the arguments supplied.

Next: Calling higher-order terms, Up: Higher-order [Contents]