/**
         
 * Warranty & Liability
         
 * To the extent permitted by applicable law and unless explicitly
         
 * otherwise agreed upon, XLOG Technologies AG makes no warranties
         
 * regarding the provided information. XLOG Technologies AG assumes
         
 * no liability that any problems might be solved with the information
         
 * provided by XLOG Technologies AG.
         
 *
         
 * Rights & License
         
 * All industrial property rights regarding the information - copyright
         
 * and patent rights in particular - are the sole property of XLOG
         
 * Technologies AG. If the company was not the originator of some
         
 * excerpts, XLOG Technologies AG has at least obtained the right to
         
 * reproduce, change and translate the information.
         
 *
         
 * Reproduction is restricted to the whole unaltered document. Reproduction
         
 * of the information is only allowed for non-commercial uses. Selling,
         
 * giving away or letting of the execution of the library is prohibited.
         
 * The library can be distributed as part of your applications and libraries
         
 * for execution provided this comment remains unchanged.
         
 *
         
 * Restrictions
         
 * Only to be distributed with programs that add significant and primary
         
 * functionality to the library. Not to be distributed with additional
         
 * software intended to replace any components of the library.
         
 *
         
 * Trademarks
         
 * Jekejeke is a registered trademark of XLOG Technologies AG.
         
 */
         

         
runner_file(calculate, lists, 'XLOG 1.3 lists').
         

         
/****************************************************************/
         
/* lists.p List Processimg                                      */
         
/****************************************************************/
         

         
/* memberchk(X, Y) */
         

         
runner_pred(memberchk,2, calculate, lists, 'XLOG 1.3.1').
         
runner_case(memberchk,2, calculate, lists, 'XLOG 1.3.1, XLOG 1') :-
         
   memberchk(2, [1,2,3,2]).
         
runner_case(memberchk,2, calculate, lists, 'XLOG 1.3.1, XLOG 2') :-
         
   \+ memberchk(4, [1,2,3]).
         
runner_case(memberchk,2, calculate, lists, 'XLOG 1.3.1, XLOG 3') :-
         
   memberchk(g(X), [f(1), g(2), h(3), g(4)]), X == 2.
         
runner_case(memberchk,2, calculate, lists, 'XLOG 1.3.1, XLOG 4') :-
         
   \+ (memberchk(g(X), [f(1), g(2), h(3), g(4)]), X == 4).
         
runner_case(memberchk,2, calculate, lists, 'XLOG 1.3.1, XLOG 5') :-
         
   memberchk(a, [b|X]), X = [a|_].
         

         
/* last(X, Y) */
         

         
runner_pred(last,2, calculate, lists, 'XLOG 1.3.2').
         
runner_case(last,2, calculate, lists, 'XLOG 1.3.2, XLOG 1') :-
         
   last([a,b,c], X),
         
   X == c.
         

         
/* last(X, Y, Z) */
         

         
runner_pred(last,3, calculate, lists, 'XLOG 1.3.3').
         
runner_case(last,3, calculate, lists, 'XLOG 1.3.3, XLOG 1') :-
         
    last([a,b,c], X, Y),
         
    X == c, Y == [a, b].
         
runner_case(last,3, calculate, lists, 'XLOG 1.3.3, XLOG 2') :-
         
    last(Y, c, [a,b]),
         
    Y = [a, b, c].
         

         
/* nth0(X, Y, Z) */
         

         
runner_pred(nth0,3, calculate, lists, 'XLOG 1.3.4').
         
runner_case(nth0,3, calculate, lists, 'XLOG 1.3.4, XLOG 1') :-
         
   nth0(1, [a,b,c], X),
         
   X == b.
         
runner_case(nth0,3, calculate, lists, 'XLOG 1.3.4, XLOG 2') :-
         
   nth0(K, [a,b,c], c),
         
   K == 2.
         

         
/* nth0(X, Y, Z, T) */
         

         
runner_pred(nth0,4, calculate, lists, 'XLOG 1.3.5').
         
runner_case(nth0,4, calculate, lists, 'XLOG 1.3.5, XLOG 1') :-
         
   nth0(0, [a,b,c], X, R),
         
   X == a, R == [b, c].
         
runner_case(nth0,4, calculate, lists, 'XLOG 1.3.5, XLOG 2') :-
         
   nth0(J, [a,b,c], b, R),
         
   J == 1, R == [a, c].
         

         
/* nth1(X, Y, Z) */
         

         
runner_pred(nth1,3, calculate, lists, 'XLOG 1.3.6').
         
runner_case(nth1,3, calculate, lists, 'XLOG 1.3.6, XLOG 1') :-
         
   nth1(1, [a,b,c], X),
         
   X == a.
         
runner_case(nth1,3, calculate, lists, 'XLOG 1.3.6, XLOG 2') :-
         
   nth1(K, [a,b,c], c),
         
   K == 3.
         

         
/* nth1(X, Y, Z, T) */
         

         
runner_pred(nth1,4, calculate, lists, 'XLOG 1.3.7').
         
runner_case(nth1,4, calculate, lists, 'XLOG 1.3.7, XLOG 1') :-
         
   nth1(1, [a,b,c], X, R),
         
   X == a, R == [b, c].
         
runner_case(nth1,4, calculate, lists, 'XLOG 1.3.7, XLOG 2') :-
         
   nth1(J, [a,b,c], b, R),
         
   J == 2, R == [a, c].
         

         
/* free_variables(Q, L, G) */
         

         
runner_pred(free_variables,3, calculate, lists, 'ISO 7.1.1.4').
         
runner_case(free_variables,3, calculate, lists, 'ISO 7.1.1.4, ISO 1') :-
         
   free_variables(f(Z)^(X+Y+Z), L, G),
         
   L == [X, Y], G == X+Y+Z.
         
runner_case(free_variables,3, calculate, lists, 'ISO 7.1.1.4, ISO 2') :-
         
   free_variables(A^Z^(A+X+Y+Z), L, G),
         
   L == [X, Y], G == A+X+Y+Z.
         

         
/****************************************************************/
         
/* Sort Predicates                                              */
         
/****************************************************************/
         

         
a(1, f(_)).
         
a(2, f(_)).
         

         
b(1, 1).
         
b(1, 2).
         
b(1, 1).
         
b(2, 2).
         
b(2, 1).
         
b(2, 2).
         

         
/* sort(L, R) */
         

         
runner_pred(sort, 2, calculate, lists, 'Corr.2 8.4.3.4').
         
runner_case(sort, 2, calculate, lists, 'Corr.2 8.4.3.4, XLOG 1') :-
         
   sort([1, 1.0], L), L == [1.0, 1].
         
runner_case(sort, 2, calculate, lists, 'Corr.2 8.4.3.4, XLOG 2') :-
         
   sort([1.0, X, a, a, X], L), L == [X, 1.0, a].
         
runner_case(sort, 2, calculate, lists, 'Corr.2 8.4.3.4, XLOG 3') :-
         
   sort([north(a), shorter, short, foo(a,b)], L),
         
   L == [short, shorter, north(a), foo(a, b)].
         
runner_case(sort, 2, calculate, lists, 'Corr.2 8.4.3.4, ISO 6') :-
         
   sort([f(U),V,f(V),U],L),
         
   (L == [U, V, f(U), f(V)]; L == [V, U, f(V), f(U)]).
         
runner_case(sort, 2, calculate, lists, 'Corr.2 8.4.3.4, XLOG 4') :-
         
   findall(Y,a(_,Y),L), sort(L,R), L=[A,B], (R == [A,B]; R == [B,A]).
         
runner_case(sort, 2, calculate, lists, 'Corr.2 8.4.3.4, XLOG 5') :-
         
   catch(sort(_, _), error(E, _), true),
         
   E == instantiation_error.
         
runner_case(sort, 2, calculate, lists, 'Corr.2 8.4.3.4, XLOG 6') :-
         
   catch(sort([77|35], _), error(E, _), true),
         
   nonvar(E), E = type_error(list,_).
         
runner_case(sort, 2, calculate, lists, 'Corr.2 8.4.3.4, XLOG 7') :-
         
   sort(['a','A','b','B'], L),
         
   L == ['A','B','a','b'].
         
runner_case(sort, 2, calculate, lists, 'Corr.2 8.4.3.4, XLOG 8') :-
         
   sort(['ü','u','œ','o'], L),
         
   L == ['o','u','ü','œ'].
         

         
/* keysort(L, R) */
         

         
runner_pred(keysort, 2, calculate, lists, 'Corr.2 8.4.4.4').
         
runner_case(keysort, 2, calculate, lists, 'Corr.2 8.4.4.4, XLOG 1') :-
         
   keysort([1-x, 1.0-y], L), L == [1.0-y, 1-x].
         
runner_case(keysort, 2, calculate, lists, 'Corr.2 8.4.4.4, XLOG 2') :-
         
   keysort([1.0-z, X-x, a-y, a-x, X-y], L),
         
   L == [X-x, X-y, 1.0-z, a-y, a-x].
         
runner_case(keysort, 2, calculate, lists, 'Corr.2 8.4.4.4, XLOG 3') :-
         
   keysort([north(a)-x, shorter-y, short-z, foo(a,b)-t], L),
         
   L == [short-z, shorter-y, north(a)-x, foo(a, b)-t].
         
runner_case(keysort, 2, calculate, lists, 'Corr.2 8.4.4.4, XLOG 4') :-
         
   keysort([f(U)-x,V-y,f(V)-z,U-t],L),
         
   (L == [U-t, V-y, f(U)-x, f(V)-z]; L == [V-y, U-t, f(V)-z, f(U)-x]).
         
runner_case(keysort, 2, calculate, lists, 'Corr.2 8.4.4.4, XLOG 5') :-
         
   findall(X-Y,a(X,Y),L), keysort(L,R), L == R.
         
runner_case(keysort, 2, calculate, lists, 'Corr.2 8.4.4.4, XLOG 6') :-
         
   catch(keysort(_, _), error(E, _), true),
         
   E == instantiation_error.
         
runner_case(keysort, 2, calculate, lists, 'Corr.2 8.4.4.4, XLOG 7') :-
         
   catch(keysort([77-x|35], _), error(E, _), true),
         
   nonvar(E), E = type_error(list,_).
         
runner_case(keysort, 2, calculate, lists, 'Corr.2 8.4.4.4, XLOG 8') :-
         
   catch(keysort([77], _), error(E, _), true),
         
   E == type_error(pair,77).
         
runner_case(keysort, 2, calculate, lists, 'Corr.2 8.4.4.4, XLOG 9') :-
         
   keysort(['a'-1,'A'-2,'a'-3,'B'-4,'b'-5,'B'-6], L),
         
   L == ['A'-2,'B'-4,'B'-6,'a'-1,'a'-3,'b'-5].
         
runner_case(keysort, 2, calculate, lists, 'Corr.2 8.4.4.4, XLOG 10') :-
         
   keysort(['ü'-1,'u'-2,'ü'-3,'œ'-4,'o'-5,'o'-6], L),
         
   L == ['o'-5,'o'-6,'u'-2,'ü'-1,'ü'-3,'œ'-4].
         

         
/* maplist(C, L, R) */
         

         
funplus(X, Y, Z) :- Z is X+Y.
         

         
runner_pred(maplist, 3, calculate, lists, 'N235 7.4').
         
runner_case(maplist, 3, calculate, lists, 'N235 7.4, XLOG 1') :-
         
   maplist(funplus(1), [2,3,4], X),
         
   X == [3, 4, 5].
         
runner_case(maplist, 3, calculate, lists, 'N235 7.4, XLOG 2') :-
         
   findall(X-Y, maplist(between(1,2), [X,Y]), L),
         
   L == [1-1, 1-2, 2-1, 2-2].
         
runner_case(maplist, 3, calculate, lists, 'N235 7.4, XLOG 3') :-
         
   \+  maplist(=, [1,2,3], [1,2]).
         
runner_case(maplist, 3, calculate, lists, 'N235 7.4, XLOG 4') :-
         
   catch(maplist(char_code, [a,1,c], _), error(E,_), true),
         
   E == type_error(atom, 1).
         

         
/* foldl(C, L, R, I, O) */
         

         
binact --> [0].
         
binact --> [1].
         

         
runner_pred(foldl, 5, calculate, lists, 'XLOG 1.3.8').
         
runner_case(foldl, 5, calculate, lists, 'XLOG 1.3.8, XLOG 1') :-
         
   foldl(funplus, [1,2,3], 0, X),
         
   X == 6.
         
runner_case(foldl, 5, calculate, lists, 'XLOG 1.3.8, XLOG 2') :-
         
   findall(X, foldl(call, [binact, binact], X, []), L),
         
   L == [[0, 0], [0, 1], [1, 0], [1, 1]].
         
runner_case(foldl, 5, calculate, lists, 'XLOG 1.3.8, XLOG 3') :-
         
   \+ foldl(call, [=,=], 1, 2).
         
runner_case(foldl, 5, calculate, lists, 'XLOG 1.3.8, XLOG 4') :-
         
   catch(foldl(atom_concat, [abc,1,def], '', _), error(E,_), true),
         
   E == type_error(atom, 1).