Did you know ... Search Documentation:
Predicate foldl/4
Availability::- use_module(library(apply)).(can be autoloaded)
Sourcefoldl(:Goal, +List, +V0, -V)
foldl(:Goal, +List1, +List2, +V0, -V)
foldl(:Goal, +List1, +List2, +List3, +V0, -V)
foldl(:Goal, +List1, +List2, +List3, +List4, +V0, -V)
Fold an ensemble of m (0 <= m <= 4) lists of length n head-to-tail ("fold-left"), using columns of m list elements as arguments for Goal. The foldl family of predicates is defined as follows, with V0 an initial value and V the final value of the folding operation: 
foldl(G, [X_11, ..., X_1n],
         [X_21, ..., X_2n],
         ...,
         [X_m1, ..., X_mn], V0, V) :-
   call(G, X_11, ..., X_m1, V0, V1),
   call(G, X_12, ..., X_m2, V1, V2),
   ...
   call(G, X_1n, ..., X_mn, V<n-1>, V).

No implementation for a corresponding foldr is given. A foldr implementation would consist in first calling reverse/2 on each of the m input lists, then applying the appropriate foldl. This is actually more efficient than using a properly programmed-out recursive algorithm that cannot be tail-call optimized.

Examples

Accumulation using foldl/4-7

Accumulation using foldl/4-7

?- foldl(plus, [1,2,3], 0, N).
N = 6.
Convert a list of goals to a conjunction

Convert a list of goals to a conjunction

Note that the last two arguments [of foldl/4-7] form a typical difference pair, so at least when the predicate is just building data structure, it is common for the last argument to be the "input" (the trivial case of the data structure) and the second-to-last argument to be the "output" (the complete data structure).

(From "An Elementary Prolog Library" by Richard O'Keefe)

flip_conj(Goal, (Goal, Conj), Conj).

?- foldl(flip_conj, [p, q, r], Conj, true).
Conj =  (p, q, r, true).
See also
- comma_list/2 for translating between a conjunction and a list.
Tags are associated to your profile if you are logged in|Report abuse
Tags:
  • doc-needs-help
  • foldr
LogicalCaptain said (2021-01-19T20:37:48):0 upvotes 0 0 downvotes
Picture of user LogicalCaptain.

Doc needs help

The example says:

the last two arguments [of foldl/4-7] form a typical difference pair

That's definitely not right. These values may not even be lists! They form the start and the end of a data-flowing "accumulator" chain (or "weave") though.

Companion README

A companion README with several examples (and an implementation of foldr/4) can be found here

Super Simple Explainer

The key is: foldl(Goal,[a,b,c,d],Starter,Final) sets up a dataflow pipeline like this:

Starter -->--Goal-->--Goal-->--Goal-->--Goal-->--Final
              ^        ^        ^        ^
              |        |        |        |
          [   a   ,    b   ,    c   ,    d  ]

And Goal is called with parameters whose name should be this:

Goal(Element,FromLeft,ToRight)                              for single list
Goal(Element1,Element2,FromLeft,ToRight)                    for two lists
Goal(Element1,Element2,Element3,FromLeft,ToRight)           for three lists
Goal(Element1,Element2,Element3,Element4,FromLeft,ToRight)  for four lists

... and that's all one really needs to know.

RdR said (2016-11-05T01:13:58):0 upvotes 0 0 downvotes
Picture of user RdR.

An example might help here.

add(X,Y,Sum):- Sum is X+Y.
sum(Xs,Sum):- foldl(add,Xs,0,Sum).

:- sum([1,2,3],S).

S = 6.

As per the documentation, each element of Xs is used as the leftmost argument of Goal ('add' in the example). V0 and V1 are used as the last arguments in Goal. In our example, V0=0 and V1=Sum, so 0 and Sum are used as the last arguments of 'add'.

Vijay Saraswat said (2016-08-05T07:57:19):0 upvotes 0 0 downvotes
Picture of user Vijay Saraswat.

Please change to: The fold family of predicates is defined by:

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

where q = n-1.