Initial data commit

Task/Catamorphism/Prolog/catamorphism-1.pro

@@ -0,0 +1,12 @@
+:- use_module(library(lambda)).
+
+catamorphism :-
+	numlist(1,10,L),
+	foldl(\XS^YS^ZS^(ZS is XS+YS), L, 0, Sum),
+	format('Sum of ~w is ~w~n', [L, Sum]),
+	foldl(\XP^YP^ZP^(ZP is XP*YP), L, 1, Prod),
+	format('Prod of ~w is ~w~n', [L, Prod]),
+	string_to_list(LV, ""),
+	foldl(\XC^YC^ZC^(string_to_atom(XS, XC),string_concat(YC,XS,ZC)),
+	      L, LV, Concat),
+	format('Concat of ~w is ~w~n', [L, Concat]).

Task/Catamorphism/Prolog/catamorphism-2.pro

@@ -0,0 +1,6 @@
+% List to be folded:
+%
+%  +---+---+---+---[]    <-- list backbone/spine, composed of nodes, terminating in the empty list
+%  |   |   |   |
+%  a   b   c   d         <-- list items/entries/elements/members
+%

Task/Catamorphism/Prolog/catamorphism-3.pro

@@ -0,0 +1,14 @@
+% Computes "Out" as:
+%
+% starter value -->--f-->--f-->--f-->--f-->-- Out
+%                    |     |     |     |
+%                    a     b     c     d
+
+
+foldl(Foldy,[Item|Items],Acc,Result) :-    % case of nonempty list
+   !,                                      % GREEN CUT for determinism
+   call(Foldy,Item,Acc,AccNext),           % call Foldy(Item,Acc,AccNext)
+   foldl(Foldy,Items,AccNext,Result).      % then recurse (open to tail call optimization)
+
+foldl(_,[],Acc,Result) :-                  % case of empty list
+   Acc=Result.                             % unification not in head for clarity

Task/Catamorphism/Prolog/catamorphism-4.pro

@@ -0,0 +1,13 @@
+% Computes "Out" as:
+%
+% Out --<--f--<--f--<--f--<--f--<-- starter value
+%          |     |     |     |
+%          a     b     c     d
+
+foldr(Foldy,[Item|Items],Starter,AccUp) :-    % case of nonempty list
+   !,                                         % GREEN CUT for determinism
+   foldr(Foldy,Items,Starter,AccUpPrev),      % recurse (NOT open to tail-call optimization)
+   call(Foldy,Item,AccUpPrev,AccUp).          % call Foldy(Item,AccupPrev,AccUp) as last action
+
+foldr(_,[],Starter,AccUp) :-                  % empty list: bounce Starter "upwards" into AccUp
+   AccUp=Starter.                             % unification not in head for clarity

Task/Catamorphism/Prolog/catamorphism-5.pro

@@ -0,0 +1,28 @@
+:- use_module(library(clpfd)). % We are using #= instead of the raw "is".
+
+foldy_len(_Item,ThreadIn,ThreadOut) :-
+   succ(ThreadIn,ThreadOut).
+
+foldy_add(Item,ThreadIn,ThreadOut) :-
+   ThreadOut #= Item+ThreadIn.
+
+foldy_mult(Item,ThreadIn,ThreadOut) :-
+   ThreadOut #= Item*ThreadIn.
+
+foldy_squadd(Item,ThreadIn,ThreadOut) :-
+   ThreadOut #= Item+(ThreadIn^2).
+
+% '[|]' is SWI-Prolog specific, replace by '.' as consbox constructor in other Prologs
+
+foldy_build(Item,ThreadIn,ThreadOut) :-
+   ThreadOut = '[|]'(Item,ThreadIn).
+
+foldy_join(Item,ThreadIn,ThreadOut) :-
+   (ThreadIn \= "")
+   -> with_output_to(string(ThreadOut),format("~w,~w",[Item,ThreadIn]))
+   ;  with_output_to(string(ThreadOut),format("~w",[Item])).
+
+% '=..' ("univ") constructs a term from a list of functor and arguments
+
+foldy_expr(Functor,Item,ThreadIn,ThreadOut) :-
+   ThreadOut =.. [Functor,Item,ThreadIn].

Task/Catamorphism/Prolog/catamorphism-6.pro

@@ -0,0 +1,52 @@
+:- begin_tests(foldr).
+
+in([1,2,3,4,5]).
+
+ffr(Foldy,List,Starter,AccUp) :- foldr(Foldy,List,Starter,AccUp).
+
+test(foo_foldr_len)    :- in(L),ffr(foldy_len     , L ,  0 , R), R=5.
+test(foo_foldr_add)    :- in(L),ffr(foldy_add     , L ,  0 , R), R=15.
+test(foo_foldr_mult)   :- in(L),ffr(foldy_mult    , L ,  1 , R), R=120.
+test(foo_foldr_build)  :- in(L),ffr(foldy_build   , L , [] , R), R=[1,2,3,4,5].
+test(foo_foldr_squadd) :- in(L),ffr(foldy_squadd  , L ,  0 , R), R=507425426245.
+test(foo_foldr_join)   :- in(L),ffr(foldy_join    , L , "" , R), R="1,2,3,4,5".
+test(foo_foldr_expr)   :- in(L),ffr(foldy_expr(*) , L ,  1 , R), R=1*(2*(3*(4*(5*1)))).
+
+test(foo_foldr_len_empty)    :- ffr(foldy_len     , [],  0 , R), R=0.
+test(foo_foldr_add_empty)    :- ffr(foldy_add     , [],  0 , R), R=0.
+test(foo_foldr_mult_empty)   :- ffr(foldy_mult    , [],  1 , R), R=1.
+test(foo_foldr_build_empty)  :- ffr(foldy_build   , [], [] , R), R=[].
+test(foo_foldr_squadd_empty) :- ffr(foldy_squadd  , [],  0 , R), R=0.
+test(foo_foldr_join_empty)   :- ffr(foldy_join    , [], "" , R), R="".
+test(foo_foldr_expr_empty)   :- ffr(foldy_expr(*) , [],  1 , R), R=1.
+
+% library(apply) has no "foldr" so no comparison tests!
+
+:- end_tests(foldr).
+
+
+:- begin_tests(foldl).
+
+in([1,2,3,4,5]).
+
+ffl(Foldy,List,Starter,Result) :- foldl(Foldy,List,Starter,Result).
+
+test(foo_foldl_len)    :- in(L),ffl(foldy_len     , L ,  0 , R), R=5.
+test(foo_foldl_add)    :- in(L),ffl(foldy_add     , L,   0 , R), R=15.
+test(foo_foldl_mult)   :- in(L),ffl(foldy_mult    , L,   1 , R), R=120.
+test(foo_foldl_build)  :- in(L),ffl(foldy_build   , L,  [] , R), R=[5,4,3,2,1].
+test(foo_foldl_squadd) :- in(L),ffl(foldy_squadd  , L,   0 , R), R=21909.
+test(foo_foldl_join)   :- in(L),ffl(foldy_join    , L,  "" , R), R="5,4,3,2,1".
+test(foo_foldl_expr)   :- in(L),ffl(foldy_expr(*) , L,   1 , R), R=5*(4*(3*(2*(1*1)))).
+
+test(foo_foldl_len_empty)    :- ffl(foldy_len     , [],  0 , R), R=0.
+test(foo_foldl_add_empty)    :- ffl(foldy_add     , [],  0 , R), R=0.
+test(foo_foldl_mult_empty)   :- ffl(foldy_mult    , [],  1 , R), R=1.
+test(foo_foldl_build_empty)  :- ffl(foldy_build   , [], [] , R), R=[].
+test(foo_foldl_squadd_empty) :- ffl(foldy_squadd  , [],  0 , R), R=0.
+test(foo_foldl_join_empty)   :- ffl(foldy_join    , [], "" , R), R="".
+test(foo_foldl_expr_empty)   :- ffl(foldy_expr(*) , [],  1 , R), R=1.
+
+:- end_tests(foldl).
+
+rt :- run_tests(foldr),run_tests(foldl).