apply_macros.pl provides compile-time expansion for part
of this library. tests/library/test_apply.plThis module defines meta-predicates that apply a predicate on all members of a list.
All predicates support partial application in the Goal argument. This means that these calls are identical:
?- maplist(=, [foo, foo], [X, Y]). ?- maplist(=(foo), [X, Y]).
call(Goal, Xi)
succeeds.
call(Goal, Xi)
fails.
call(Pred, X) succeeds and
Excluded contains the remaining elements.
call(Pred, Xi, Place),
where Place must be unified to one of <, =
or >.
Pred must be deterministic.
maplist(G, [X_11, ..., X_1n], [X_21, ..., X_2n], ..., [X_m1, ..., X_mn]) :- call(G, X_11, ..., X_m1), call(G, X_12, ..., X_m2), ... call(G, X_1n, ..., X_mn).
This family of predicates is deterministic iff Goal is
deterministic and List1 is a proper list, i.e., a list that
ends in [].
call(Goal, ElemIn, _) fails are
omitted from ListOut. For example (using library(yall)):
?- convlist([X,Y]>>(integer(X), Y is X^2), [3, 5, foo, 2], L). L = [9, 25, 4].
library(maplist) and SICStus
library(lists).<= 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.
<= m <=
4) lists of length n head-to-tail ("scan-left"), using columns of m
list elements as arguments for Goal. The scanl
family of predicates is defined as follows, with V0 an
initial value and V the final value of the scanning
operation:
scanl(G, [X_11, ..., X_1n], [X_21, ..., X_2n], ..., [X_m1, ..., X_mn], V0, [V0, V1, ..., Vn] ) :- 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>, Vn).
scanl behaves like a foldl that collects
the sequence of values taken on by the Vx accumulator into a
list.
maplist/2 example:
?- maplist(integer, [1, 2, 3]). true. ?- maplist(integer, [1, 2.2, 3]). false.
maplist/3 example:
?- maplist(plus(1), [1, 2, 3, 4, 5], Result). Result = [2, 3, 4, 5, 6].
maplist/4 example:
?- maplist(plus, [1, 2, 3], [5, 2, 6], Result). Result = [6, 4, 9].
foldl/4 example:
?- foldl(plus, [1, 2, 3, 4, 5], 0, Result). Result = 15.
scanl/4 example:
?- scanl(plus, [1, 2, 3, 4, 5], 0, Result). Result = [0, 1, 3, 6, 10, 15].
I had some fun writing foldl/4 and foldr/4, including an implementation of foldl/4 based on maplist/5. Complete with test cases.
A markdown page is here: Linear foldl and foldr in Prolog
Also good to peruse: The Wikipedia entry on "linear folds":
https://en.wikipedia.org/wiki/Fold_(higher-order_function)#Linear_folds
For more info on maplist/2, maplist/3, maplist/4, check out the comment section of those pages.