% 1. variabile neinstanțiate
% ==========================================


% any(X).
any(X) :- display(X).
%  sau: any(X) :- format("X este: ~w~n", [X]).
any(X, X).
% încercați:
% ?- any(X, Y).

% any(X, Y) :- X = Y. % identic cu any(X, X).
% any(X, Y) :- X is Y.
% încercați any(X, 1+2)	cu ambele variante de implementare de mai sus.

% la consolă vad 'ce legări s-au forțat ca să fie adevarat?'.




% 2. generarea numerelor
% ==========================================


% puterea generativă a limbajului: generarea unei liste
% la consolă:
%
% ?- member(1, [1,2,3])
% ?- member(X, [1, 2, 3]).
% ?- member(1, L).
% ?- length(L, 3), member(1, L), member(2, L), member(3, L).


% interval(X) :- X < 10.
interval(0).
interval(X) :- interval(Y), Y < 10, X is Y + 1. % merge la infinit după X = 10



interval2H(I, _, I).
interval2H(I, L, X):- I < L, I1 is I + 1,
	interval2H(I1, L, X).
interval2(X) :- interval2H(0, 10, X).


% merge la infinit după prima soluție (vezi interval/1)
factorial2a(1, 1).
factorial2a(N, F) :- factorial2a(N2, F2), N is N2 + 1, F is F2 * N.


factorial2bH(NI, F, ND, F) :- ND == NI.
factorial2bH(N, FI, N, FD) :- FD == FI.
factorial2bH(NI, FI, ND, FD) :-
	(   number(ND), NI < ND
	;
	number(FD), FI < FD	),
	N1 is NI + 1, F1 is FI * N1,
	factorial2bH(N1, F1, ND, FD).
factorial2b(N, F) :- factorial2bH(0, 1, N, F).

% mai scurt:
factorial2c(N, F, N, F).
factorial2c(NI, FI, ND, FD) :-
	(   number(ND), NI < ND
	;
	number(FD), FI < FD	),
	N1 is NI + 1, F1 is FI * N1,
	factorial2bH(N1, F1, ND, FD).
factorial2c(N, F) :- factorial2c(0, 1, N, F).

% 3. direcția construirii soluțiilor
% ==========================================

inc(X, Y) :- Y is X + 1.

% Simplu - recursivitate pe stivă (se mai face o unificare la
% întoarcere, în argumentul de ieșire).
incListS([], []).
incListS([H|T], LOut) :- inc(H,H1), incListS(T,T1), LOut = [H1 | T1].
% echivalent cu
% incListS([H | T],[H1 | T1]) :- inc(H, H1), incListS(T, T1).

% Cu acumulator și construcția rezultatului pe avansul în recursivitate.
% Recursivitate pe coada
incListT(L,LR) :- incListTH(L,[],LR).

incListTH([], L, LOut) :- reverse(L, LOut).
incListTH([H|T], LA, LR) :- inc(H,H1), incListTH(T, [H1 | LA], LR).



% 4. debugging:
% ==============================================

% folosire predicates trace, notrace (eventual debug și nodebug):
% guitracer/0 pentru activarea debuggerului grafic
% noguitracer/0 pentru dezactivare.

% ?- trace, predicat(args), nodebug.

% pentru predicate de 1 argument
dotracing(P, X) :- trace, call(P, X), nodebug.




% 5. cut și fail
% ==============================================

min(X, Y, M) :- X =< Y, M is X.
min(X, Y, M) :- X > Y,  M is Y.

min2(X, Y, M) :- X =< Y, M = X.
min2(X, Y, M) :- X > Y,  M = Y.

% Echivalent cu min2.
min3(X, Y, X) :- X =< Y.
min3(X, Y, Y) :- X > Y.

% Greșit! A doua soluție nu va fi corectă.
min4(X, Y, X) :- X =< Y.
min4(_, Y, Y).

% Corect: o singură soluție.
min5(X, Y, X) :- X =< Y, !.
min5(_, Y, Y).


este(lili, liliac).
este(fifi, papagal).

zboara(liliac).
zboara(papagal).

% utilizare cut împreună cu fail
pasare(X) :- este(X, liliac), !, fail.
pasare(X) :- este(X, Y), zboara(Y), !.
pasare(X) :- zboara(X).


% 6. afișare: predicatul format
% ==============================================

% print(_).
prettyPrintList(L) :- ppListH(L, 1).
ppListH([], N) :- format("completed, ~w elements printed.~n", [N]).
ppListH([H|T], I) :- format("element no. ~w: ~w~n", [I, H]), I1 is I + 1,
	ppListH(T, I1).