Common higher-order predicates

Author(s): Daniel Cabeza, Manuel Carro, Edison Mera, Jose F. Morales.

This library implements a few basic higher-order predicates for reducing and transforming lists.

Usage and interface

Documentation on exports

PREDICATEfoldl/4
The left fold family foldl/N is equivalent to:

foldl(P, [X11,...,X1n], [Xm1,...,Xmn], V0, V) :-
    P(X11, ..., Xm1, V0, V1),
    ...
    P(Xn,  ..., Xmn, Vn_1, Vn).

Usage:foldl(P,Xs,V0,V)

Reduces (fold) Xs from the left applying P and using V0-V as accumulator.

Meta-predicate with arguments: foldl(pred(3),?,?,?).

PREDICATEfoldl/5

Usage:foldl(P,Xs,Ys,V0,V)

Like foldl/4 but applied to successive tuples from Xs, Ys.

Meta-predicate with arguments: foldl(pred(4),?,?,?,?).

PREDICATEfoldl/6

Usage:foldl(P,Xs,Ys,Zs,V0,V)

Like foldl/4 but applied to successive tuples from Xs, Ys, Zs.

Meta-predicate with arguments: foldl(pred(5),?,?,?,?,?).

PREDICATEfoldl/7

Usage:foldl(P,Xs,Ys,Zs,Us,V0,V)

Like foldl/4 but applied to successive tuples from Xs, Ys, Zs, Us.

Meta-predicate with arguments: foldl(pred(6),?,?,?,?,?,?).

PREDICATEfoldl/8

Usage:foldl(P,Xs,Ys,Zs,Us,Ws,V0,V)

Like foldl/4 but applied to successive tuples from Xs, Ys, Zs, Us, Ws.

Meta-predicate with arguments: foldl(pred(7),?,?,?,?,?,?,?).

PREDICATEfoldr/4
The right fold family foldr/N is equivalent to:

foldr(P, [X11,...,X1n], [Xm1,...,Xmn], V0, V) :-
    P(Xn,  ..., Xmn, V0, V1),
    ...
    P(X11, ..., Xm1, Vn_1, V).

Note that foldr/N is not tail recursive. When P(...,?,?) is a valid calling mode, it would be possible to reorder the calls as in:

foldr_tail(P, [X11,...,X1n], [Xm1,...,Xmn], V0, V) :-
    P(X11, ..., Xm1, Vn_1, V),
    ...
    P(Xn,  ..., Xmn, V0, V1).

which is exactly like foldl/N but with fliped accumulator arguments. See foldl/N examples

Usage:foldr(F,Xs,V0,V)

Reduces (fold) Xs from the right applying P and using V0-V as accumulator.

Meta-predicate with arguments: foldr(pred(3),?,?,?).

PREDICATEminimum/3

Usage:minimum(List,SmallerThan,Minimum)

Minimum is the smaller in the nonempty list List according to the relation SmallerThan: SmallerThan(X, Y) succeeds iff X is smaller than Y.

Meta-predicate with arguments: minimum(?,pred(2),?).

PREDICATEfilter/3

Usage:filter(P,Xs,Ys)

Ys contains all elements X of Xs such that P(X) holds (preserving the order)

Meta-predicate with arguments: filter(pred(1),?,?).

PREDICATEpartition/4

Usage:partition(P,Xs,Ys,Zs)

Ys contains all elements X of Xs such that P(X) holds, and Zs all that does not (preserving the order)

Meta-predicate with arguments: partition(pred(1),?,?,?).

PREDICATEmaplist/2
The map list family maplist/N is equivalent to:

maplist(P, [X11,...,X1n], [Xm1,...,Xmn]) :-
    P(X11, ..., Xm1),
    ...
    P(Xn,  ..., Xmn).

Usage:maplist(P,Xs)

P(X) succeeds for each element X of Xs

Meta-predicate with arguments: maplist(pred(1),?).

PREDICATEmaplist/3

Usage:maplist(P,Xs,Ys)

Like maplist/2 but applied to successive tuples from Xs, Ys.

Meta-predicate with arguments: maplist(pred(2),?,?).

PREDICATEmaplist/4

Usage:maplist(P,Xs,Ys,Zs)

Like maplist/2 but applied to successive tuples from Xs, Ys, Zs.

Meta-predicate with arguments: maplist(pred(3),?,?,?).

PREDICATEmaplist/5

Usage:maplist(P,Xs,Ys,Zs,Vs)

Like maplist/2 but applied to successive tuples from Xs, Ys, Zs, Vs.

Meta-predicate with arguments: maplist(pred(4),?,?,?,?).

PREDICATEmaplist/6

Usage:maplist(P,Xs,Ys,Zs,Vs,Ws)

Like maplist/2 but applied to successive tuples from Xs, Ys, Zs, Vs, Ws.

Meta-predicate with arguments: maplist(pred(5),?,?,?,?,?).

Documentation on imports

This module has the following direct dependencies:

Known bugs and planned improvements

  • We only provide foldr/4. Add more versions if needed.
  • We do not provide scanl/N or scanr/N. Add them if needed.