gleam_zlists

-module(erl@interface).
-compile(no_auto_import).

-export([new/2, generate/2, recurrent_2/2, recurrent_3/3, foreach/2, foldl/3, map/2, seq/3, dropwhile/2, drop/2, takewhile/2, take/2, filter/2, expand/1, append/1, scroll/2, merge/2, splitwith/2, cartesian/2, zip/2, ziph/2, unique_1/1, unique_2/2, count/1, print/1]).

-spec new(list(any()), fun(() -> list(DA))) -> erl@zlist:z_list(DA).
new(Ls, F) ->
    erl@zlist:new(Ls, F).

-spec generate(erl@zlist:z_list(DD), fun((DD) -> erl@zlist:z_list(DF))) -> erl@zlist:z_list(DF).
generate(Zl, F) ->
    erl@zlist:generate(Zl, F).

-spec recurrent_2(DI, fun((DI) -> DI)) -> erl@zlist:z_list(DI).
recurrent_2(Elem, F) ->
    erl@zlist:recurrent_2(Elem, F).

-spec recurrent_3(DK, DL, fun((DK, DL) -> {DK, DL})) -> erl@zlist:z_list(DK).
recurrent_3(Elem, Elem_1, F) ->
    erl@zlist:recurrent_3(Elem, Elem_1, F).

-spec foreach(fun((DN) -> any()), erl@zlist:z_list(DN)) -> nil.
foreach(F, Zl) ->
    erl@zlist:foreach(F, Zl).

-spec foldl(fun((DQ, DR) -> DR), DR, erl@zlist:z_list(DQ)) -> DR.
foldl(F, Accum, Zl) ->
    erl@zlist:foldl(F, Accum, Zl).

-spec map(fun((DT) -> DU), erl@zlist:z_list(DT)) -> erl@zlist:z_list(DU).
map(F, Zl) ->
    erl@zlist:map(F, Zl).

-spec seq(integer(), integer(), integer()) -> erl@zlist:z_list(integer()).
seq(From, To, Incr) ->
    erl@zlist:seq(From, To, Incr).

-spec dropwhile(fun((DY) -> boolean()), erl@zlist:z_list(DY)) -> erl@zlist:z_list(DY).
dropwhile(Pred, Zl) ->
    erl@zlist:dropwhile(Pred, Zl).

-spec drop(integer(), erl@zlist:z_list(EB)) -> erl@zlist:z_list(EB).
drop(N, Zl) ->
    erl@zlist:drop(N, Zl).

-spec takewhile(fun((EE) -> boolean()), erl@zlist:z_list(EE)) -> erl@zlist:z_list(EE).
takewhile(Pred, Zl) ->
    erl@zlist:takewhile(Pred, Zl).

-spec take(integer(), erl@zlist:z_list(EH)) -> erl@zlist:z_list(EH).
take(N, Zl) ->
    erl@zlist:take(N, Zl).

-spec filter(fun((EK) -> boolean()), erl@zlist:z_list(EK)) -> erl@zlist:z_list(EK).
filter(Pred, Zl) ->
    erl@zlist:filter(Pred, Zl).

-spec expand(erl@zlist:z_list(EN)) -> list(EN).
expand(Zl) ->
    erl@zlist:expand(Zl).

-spec append(erl@zlist:z_list(erl@zlist:z_list(EQ))) -> erl@zlist:z_list(EQ).
append(Zlsts) ->
    erl@zlist:append(Zlsts).

-spec scroll(integer(), erl@zlist:z_list(EU)) -> {list(EU),
                                                  erl@zlist:z_list(EU)}.
scroll(N, Zl) ->
    erl@zlist:scroll(N, Zl).

-spec merge(erl@zlist:z_list(EY), erl@zlist:z_list(EY)) -> erl@zlist:z_list(EY).
merge(Zl_1, Zl_2) ->
    erl@zlist:merge(Zl_1, Zl_2).

-spec splitwith(fun((FC) -> boolean()), erl@zlist:z_list(FC)) -> {list(FC),
                                                                  erl@zlist:z_list(FC)}.
splitwith(Pred, Zl) ->
    erl@zlist:splitwith(Pred, Zl).

-spec cartesian(erl@zlist:z_list(FG), erl@zlist:z_list(FG)) -> erl@zlist:z_list(FG).
cartesian(Zl_1, Zl_2) ->
    erl@zlist:cartesian(Zl_1, Zl_2).

-spec zip(erl@zlist:z_list(FK), erl@zlist:z_list(FM)) -> erl@zlist:z_list({FK,
                                                                           FM}).
zip(Zl_1, Zl_2) ->
    erl@zlist:zip(Zl_1, Zl_2).

-spec ziph(erl@zlist:z_list(FP), erl@zlist:z_list(FR)) -> erl@zlist:z_list({FP,
                                                                            FR}).
ziph(Zl_1, Zl_2) ->
    erl@zlist:ziph(Zl_1, Zl_2).

-spec unique_1(erl@zlist:z_list(FU)) -> erl@zlist:z_list(FU).
unique_1(Zl) ->
    erl@zlist:unique_1(Zl).

-spec unique_2(fun((FX, FX) -> boolean()), erl@zlist:z_list(FX)) -> erl@zlist:z_list(FX).
unique_2(Pred, Zl) ->
    erl@zlist:unique_2(Pred, Zl).

-spec count(erl@zlist:z_list(any())) -> integer().
count(Zl) ->
    erl@zlist:count(Zl).

-spec print(erl@zlist:z_list(any())) -> nil.
print(Zl) ->
    erl@zlist:print(Zl).