gleamy_structures

-module(gleamy@non_empty_list).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([fold/3, count/1, filter/2, to_list/1, from_list/1, reverse/1, map/2]).
-export_type([non_empty_list/1]).

-type non_empty_list(GPF) :: {'end', GPF} | {next, GPF, non_empty_list(GPF)}.

-spec fold(non_empty_list(GPG), GPI, fun((GPI, GPG) -> GPI)) -> GPI.
fold(List, Initial, Fun) ->
    case List of
        {'end', Item} ->
            Fun(Initial, Item);

        {next, X, Xs} ->
            fold(Xs, Fun(Initial, X), Fun)
    end.

-spec count(non_empty_list(any())) -> integer().
count(List) ->
    fold(List, 0, fun(Acc, _) -> Acc + 1 end).

-spec filter(non_empty_list(GPP), fun((GPP) -> boolean())) -> list(GPP).
filter(List, Predicate) ->
    _pipe = fold(List, [], fun(Acc, Item) -> case Predicate(Item) of
                true ->
                    [Item | Acc];

                false ->
                    Acc
            end end),
    lists:reverse(_pipe).

-spec to_list(non_empty_list(GPS)) -> list(GPS).
to_list(List) ->
    _pipe = fold(List, [], fun(Acc, Item) -> [Item | Acc] end),
    lists:reverse(_pipe).

-spec from_list(list(GPV)) -> {ok, non_empty_list(GPV)} | {error, nil}.
from_list(List) ->
    case List of
        [] ->
            {error, nil};

        [X | Xs] ->
            {ok,
                gleam@list:fold(
                    Xs,
                    {'end', X},
                    fun(Acc, Item) -> {next, Item, Acc} end
                )}
    end.

-spec reverse(non_empty_list(GQA)) -> non_empty_list(GQA).
reverse(List) ->
    case List of
        {'end', _} ->
            List;

        {next, X, Xs} ->
            fold(Xs, {'end', X}, fun(Acc, X@1) -> {next, X@1, Acc} end)
    end.

-spec map(non_empty_list(GPL), fun((GPL) -> GPN)) -> non_empty_list(GPN).
map(List, Transform) ->
    case List of
        {'end', X} ->
            {'end', Transform(X)};

        {next, X@1, Xs} ->
            _pipe = fold(
                Xs,
                {'end', Transform(X@1)},
                fun(Acc, Item) -> {next, Transform(Item), Acc} end
            ),
            reverse(_pipe)
    end.