-module(dp3).
-compile(export_all).

% Append rekurzióval.
% @spec append_1(Xs::[any()],Ys::[any()]) -> Zs::[any()].
% Zs = az Xs az Ys elé fűzve.
append_1([], Ys) ->
    Ys;
append_1([X|Xs], Ys) ->
    [X|append_1(Xs, Ys)].

% Naív megfordítás.
% @spec nrev(Xs::[any()]) -> Zs::[any()].
% Zs = az Xs fordított sorrendben.
nrev([]) ->
    [];
nrev([X|Xs]) ->
    append_1(nrev(Xs), [X]).

% Gyűjtőargumentumos megfordítás.
% @spec revapp_1(Xs::[any()],Ys::[any()]) -> Zs::[any()].
% Zs = a megfordított Xs az Ys elé fűzve.
revapp_1([], Ys) ->
    Ys;
revapp_1([X|Xs], Ys) ->
    revapp_1(Xs, [X|Ys]).

% @spec rev(Xs::[any()]) -> Zs::[any()].
% Zs = az Xs fordított sorrendben.
rev(L) ->
    revapp_1(L, []).

% Map rekurzióval.
% @spec map_1(F::fun(X::any()) -> Y::any(), Xs::[any()]) -> Ys::[any()]
% Ys = az Xs elemeiből az F transzformációval létrehozott elemek listája 
map_1(_F, []) ->
    [];
map_1(F, [X|Xs]) ->
    [F(X)|map_1(F, Xs)].

% Map listanézettel.
% @spec map_2: lásd map_1
map_2(F, Xs) ->
    [F(X) || X <- Xs].

% Filter rekurzióval.
% @spec filter_1(P::fun(X::any()) -> bool(), Xs::[any()]) -> Ys::[any()]
% Ys = az Xs elemei közül a P predikátumot kielégítő elemek listája
filter_1(_F, []) ->
    [];
filter_1(F, [X|Xs]) ->
    case F(X) of
	true ->
	    [X|filter_1(F, Xs)];
	_ ->
	    filter_1(F, Xs)
    end.

% Kódismétlés elkerülése rosszul (kommentben) és jól.
% @spec filter_2: lásd filter_1
filter_2(_F, []) ->
    [];
filter_2(F, [X|Xs]) ->
    R = fun() -> filter_2(F, Xs) end,
    %R = filter_2(F, Xs),
    case F(X) of
	true ->
	    [X|R()];
	    %[X|R];
	_ ->
	    R()
	    %R
    end.

% Filter listanézettel.
% @spec filter_3: lásd filter_2
filter_3(F, Xs) ->
    [X || X <- Xs, F(X)].

% Left fold. Jobbrekurzív.
% @spec foldl(F::fun(X::any(),Y::any()) -> Z::any(),
%                                  E::any(), Xs::[any()]) -> R::any()
% R = az Xs elemeire balról jobbra haladva alkalmazott,
%     E gyűjtőargumentumú, kétoperandusú F művelet eredménye
foldl(_F, E, []) ->
    E;
foldl(F, E, [X|Xs]) ->
    foldl(F, F(X,E), Xs).

% Revapp mint fold.
% @spec revapp_2: lásd revapp_1
revapp_2(L1, L2) ->
    foldl(fun(X,Xs) -> [X|Xs] end, L2, L1).

% Right fold. Nem jobbrekurziv.
% @spec foldr(F::fun(X::any(),Y::any()) -> Z::any(),
%                                  E::any(), Xs::[any()]) -> R::any()
% R = az Xs elemeire jobbról balra haladva alkalmazott,
%     E gyűjtőargumentumú, kétoperandusú F művelet eredménye
foldr(_F, E, []) ->
    E;
foldr(F, E, [X|Xs]) ->
    F(X, foldr(F, E, Xs)).

% Append mint fold.
% @spec append_2: lásd append_1
append_2(L1, L2) ->
    foldr(fun(X,Xs) -> [X|Xs] end, L2, L1).

% @spec parban_1(Xs::[any()]) -> Zs::[any()].
% Zs = az Xs azon elemeinek listája, amelyeket ugyanolyan elemek követnek
parban_1([E,E|Xs]) ->
    [E|parban_1([E|Xs])];
parban_1(L) ->
    if
	length(L) > 1 ->
	    parban_1(tl(L));
	true ->
	    []
    end.

% Tails.
% @spec tails_1(Xs::[any()]) -> Zss::[[any()]].
% Zss = az Xs-ből és egyre rövidülő farkaiból álló lista.
tails_1([]) ->
    [[]];
tails_1(L=[_|T]) ->
    [L|tails_1(T)].

% Tails mint fold.
% @spec tails_2: lásd tails_1
tails_2(L) ->
    foldr(fun(X,Xs) -> [[X|hd(Xs)]|Xs] end, [[]], L).

% Parban listafuggvenyekkel.
% @spec parban_2: lásd parban_1
parban_2(L) ->
    [E || [E,E|_] <- tails_1(L)].

% @spec dadogo(Xs::[any()]) -> Zss::[[any()]].
% Zss = olyan lista, amelynek minden egyes Zs eleme olyan nem üres
%       részlistája Xs-nek, amelyet vele megegyező részlista követ
dadogo(L) ->
    [P || R <- lists:sublist(tails_1(L),length(L)-2),
	  N <- lists:seq(1,trunc(length(R)/2)),
	  begin
	      {P,R2} = lists:split(N,R),
	      lists:prefix(P,R2)
	  end].