:>(+P:pred(-A), +Q:pred(+A,-B), -Y:B) is det

machine composition: generator :> transducer --> generator

 unfolder(+T:pred(-X,+S,-S), S0:S, -G:unfolder(X,S)) is det

 mapper(+F:pred(+X,-Y), +G:unfolder(X,S), -T:unfolder(Y,S)) is det

 moore(+T:pred(+X,+SB,-SB), +O:pred(+SB,-Y), S0:SB, +G:unfolder(X,SA), -G2:unfolder(Y,pair(SA-SB))) is det

 iterator(+I:pred(-pred(-X,+S,-S)), S0:S, -G:unfolder(pair(X,S),S)) is det

Re-exported predicates

The following predicates are exported from this file while their implementation is defined in imported modules or non-module files loaded by this module.

 foreach(:Generator, :Goal)

True when the conjunction of instances of Goal created from solutions for Generator is true. Except for term copying, this could be implemented as below.

foreach(Generator, Goal) :-
    findall(Goal, Generator, Goals),
    maplist(call, Goals).

The actual implementation uses findall/3 on a template created from the variables shared between Generator and Goal. Subsequently, it uses every instance of this template to instantiate Goal, call Goal and undo only the instantiation of the template and not other instantiations created by running Goal. Here is an example:

?- foreach(between(1,4,X), dif(X,Y)), Y = 5.
Y = 5.
?- foreach(between(1,4,X), dif(X,Y)), Y = 3.
false.

The predicate foreach/2 is mostly used if Goal performs backtrackable destructive assignment on terms. Attributed variables (underlying constraints) are an example. Another example of a backtrackable data structure is in library(hashtable). If we care only about the side effects (I/O, dynamic database, etc.) or the truth value of Goal, forall/2 is a faster and simpler alternative. If Goal instantiates its arguments it is will often fail as the argument cannot be instantiated to multiple values. It is possible to incrementally grow an argument:

?- foreach(between(1,4,X), member(X, L)).
L = [1,2,3,4|_].

Note that SWI-Prolog up to version 8.3.4 created copies of Goal using copy_term/2 for each iteration, this makes the current implementation unable to properly handle compound terms (in Goal's arguments) that share variables with the Generator. As a workaround you can define a goal that does not use compound terms, like in this example:

mem(E,L) :-  % mem/2 hides the compound argument from foreach/2
   member(r(E),L).

?- foreach(  between(1,5,N), mem(N,L)).

 +Parameters >> +Lambda

 >>(+Parameters, +Lambda, ?A1)

 >>(+Parameters, +Lambda, ?A1, ?A2)

 >>(+Parameters, +Lambda, ?A1, ?A2, ?A3)

 >>(+Parameters, +Lambda, ?A1, ?A2, ?A3, ?A4)

 >>(+Parameters, +Lambda, ?A1, ?A2, ?A3, ?A4, ?A5)

 >>(+Parameters, +Lambda, ?A1, ?A2, ?A3, ?A4, ?A5, ?A6)

 >>(+Parameters, +Lambda, ?A1, ?A2, ?A3, ?A4, ?A5, ?A6, ?A7)

Calls a copy of Lambda. This is similar to call(Lambda,A1,...), but arguments are reordered according to the list Parameters:

• The first length(Parameters) arguments from A1, ... are unified with (a copy of) Parameters, which may share them with variables in Lambda.
• Possible excess arguments are passed by position.

Arguments:

Parameters

- is either a plain list of parameters or a term {Free}/List. Free represents variables that are shared between the context and the Lambda term. This is needed for compiling Lambda expressions.

Undocumented predicates

The following predicates are exported, but not or incorrectly documented.

 iterate(Arg1, Arg2, Arg3, Arg4)

 unfold(Arg1, Arg2)

 unfold_finite(Arg1, Arg2)

 cofold(Arg1, Arg2, Arg3)

 scanner(Arg1, Arg2, Arg3)

 scan0(Arg1, Arg2, Arg3, Arg4)

 drop(Arg1, Arg2, Arg3)

 mean(Arg1, Arg2)

 mean(Arg1, Arg2, Arg3, Arg4, Arg5)

 subsample(Arg1, Arg2, Arg3)