List Processing Paradigm (declarative)

1. Test For Existence

     foobar(elt, (x . y)) :-
                      foo(elt, x).
     foobar(elt, (x . y)) :-
                      foobar(elt, y).

For example, the familiar <member> function can be written as:
     member(elt, (x . y)) :-
                     elt == x.
     member(elt, (x . y)) :-
                     member(elt, y).

2. Test For All Elements

     foobar(elt, ()).
     foobar(elt, (x . y)) :-
                     foo(elt, x),
                     foobar(elt, y).

For example, <all-digits>, which tests if all elemnts of a list are digits, can be written as:
     all-digits(()).
     all-digits((x . y) :-
                    member(x, (1,2,3,4,5,6,7,8,9,0)),
                    all-digits(y).

3. Return a Result -- Having processed ONE element

      foobar(foo, (x . y), Result) :-
                    foo(x),
                    result(x, y, Result)..
      foobar(foo, (x . y), Result) :-
                    foobar(foo, y, Result).

For example, <tail-after-a>, which returns sublist after a, can be written as:
      tail-after-a((x . y), result) :-
                     x == a,
                     result = y.
      tail-after-a((x . y), result) :-
                     tail-after-a(y, result).

4. Return a Result -- Having processed ALL elements

       foobar(foo, (), ()).
       foobar(foo, (x . y), (a . b)) :-
                    foo(x, a),
                    foobar(foo, y, b).

For example, <double>, which doubles every element in a list, can be written as:
       double((), ()).
       double((x . y), (a . b)) :-
                    a is 2 * x,
                    double(y, b).

Footnote: note the difference of building structure in the clause head and clause body.