fp_gl

-module(fp_gl@semigroup).
-compile(no_auto_import).

-export([reverse/1, intercalate/1, struct1/2, struct2/3, struct3/4, tuple1/1, tuple2/2, tuple3/3, min/1, max/1, constant/1, first/0, last/0, concat_all/2]).

-spec reverse(fp_gl@models:semigroup(EVA)) -> fp_gl@models:semigroup(EVA).
reverse(S) ->
    {semigroup, fun(X, Y) -> (erlang:element(2, S))(Y, X) end}.

-spec intercalate(EVD) -> fun((fp_gl@models:semigroup(EVD)) -> fp_gl@models:semigroup(EVD)).
intercalate(Middle) ->
    fun(S) ->
        {semigroup,
         fun(X, Y) ->
             (erlang:element(2, S))(X, (erlang:element(2, S))(Middle, Y))
         end}
    end.

-spec struct1(fp_gl@defunc:defunc1(EVF, EVG), fp_gl@models:semigroup(EVF)) -> fp_gl@models:semigroup(EVG).
struct1(Defunc, Semigroup1) ->
    {semigroup,
     fun(X, Y) ->
         X@1 = (erlang:element(3, Defunc))(X),
         Y@1 = (erlang:element(3, Defunc))(Y),
         (erlang:element(2, Defunc))(
             (erlang:element(2, Semigroup1))(
                 erlang:element(1, X@1),
                 erlang:element(1, Y@1)
             )
         )
     end}.

-spec struct2(
    fp_gl@defunc:defunc2(EVL, EVM, EVN),
    fp_gl@models:semigroup(EVL),
    fp_gl@models:semigroup(EVM)
) -> fp_gl@models:semigroup(EVN).
struct2(Defunc, Semigroup1, Semigroup2) ->
    {semigroup,
     fun(X, Y) ->
         X@1 = (erlang:element(3, Defunc))(X),
         Y@1 = (erlang:element(3, Defunc))(Y),
         (erlang:element(2, Defunc))(
             (erlang:element(2, Semigroup1))(
                 erlang:element(1, X@1),
                 erlang:element(1, Y@1)
             ),
             (erlang:element(2, Semigroup2))(
                 erlang:element(2, X@1),
                 erlang:element(2, Y@1)
             )
         )
     end}.

-spec struct3(
    fp_gl@defunc:defunc3(EVU, EVV, EVW, EVX),
    fp_gl@models:semigroup(EVU),
    fp_gl@models:semigroup(EVV),
    fp_gl@models:semigroup(EVW)
) -> fp_gl@models:semigroup(EVX).
struct3(Defunc, Semigroup1, Semigroup2, Semigroup3) ->
    {semigroup,
     fun(X, Y) ->
         X@1 = (erlang:element(3, Defunc))(X),
         Y@1 = (erlang:element(3, Defunc))(Y),
         (erlang:element(2, Defunc))(
             (erlang:element(2, Semigroup1))(
                 erlang:element(1, X@1),
                 erlang:element(1, Y@1)
             ),
             (erlang:element(2, Semigroup2))(
                 erlang:element(2, X@1),
                 erlang:element(2, Y@1)
             ),
             (erlang:element(2, Semigroup3))(
                 erlang:element(3, X@1),
                 erlang:element(3, Y@1)
             )
         )
     end}.

-spec tuple1(fp_gl@models:semigroup(EWG)) -> fp_gl@models:semigroup({EWG}).
tuple1(Semigroup1) ->
    {semigroup,
     fun(X, Y) ->
         {(erlang:element(2, Semigroup1))(
              erlang:element(1, X),
              erlang:element(1, Y)
          )}
     end}.

-spec tuple2(fp_gl@models:semigroup(EWJ), fp_gl@models:semigroup(EWL)) -> fp_gl@models:semigroup({EWJ,
                                                                                                  EWL}).
tuple2(Semigroup1, Semigroup2) ->
    {semigroup,
     fun(X, Y) ->
         {(erlang:element(2, Semigroup1))(
              erlang:element(1, X),
              erlang:element(1, Y)
          ),
          (erlang:element(2, Semigroup2))(
              erlang:element(2, X),
              erlang:element(2, Y)
          )}
     end}.

-spec tuple3(
    fp_gl@models:semigroup(EWO),
    fp_gl@models:semigroup(EWQ),
    fp_gl@models:semigroup(EWS)
) -> fp_gl@models:semigroup({EWO, EWQ, EWS}).
tuple3(Semigroup1, Semigroup2, Semigroup3) ->
    {semigroup,
     fun(X, Y) ->
         {(erlang:element(2, Semigroup1))(
              erlang:element(1, X),
              erlang:element(1, Y)
          ),
          (erlang:element(2, Semigroup2))(
              erlang:element(2, X),
              erlang:element(2, Y)
          ),
          (erlang:element(2, Semigroup3))(
              erlang:element(3, X),
              erlang:element(3, Y)
          )}
     end}.

-spec min(fp_gl@models:ord(EWV)) -> fp_gl@models:semigroup(EWV).
min(O) ->
    {semigroup, fp_gl@ord:min(O)}.

-spec max(fp_gl@models:ord(EWY)) -> fp_gl@models:semigroup(EWY).
max(O) ->
    {semigroup, fp_gl@ord:max(O)}.

-spec constant(EXB) -> fp_gl@models:semigroup(EXB).
constant(It) ->
    {semigroup, fun(_, _) -> It end}.

-spec first() -> fp_gl@models:semigroup(any()).
first() ->
    {semigroup, fun(X, _) -> X end}.

-spec last() -> fp_gl@models:semigroup(any()).
last() ->
    {semigroup, fun(_, Y) -> Y end}.

-spec concat_all(fp_gl@models:semigroup(EXH), EXH) -> fun((list(EXH)) -> EXH).
concat_all(M, Empty) ->
    fun(Ass) -> gleam@list:fold(Ass, Empty, erlang:element(2, M)) end.