-module(gleamgen@pattern).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gleamgen/pattern.gleam").
-export([variable/1, string_literal/1, discard/0, named_discard/1, int_literal/1, bool_literal/1, concat_string/2, 'or'/2, from_constructor0/1, tuple0/0, get_output/1, to_dynamic/1, ok/1, error/1, as_/2, from_constructor_dynamic/2, from_constructor1/2, from_constructor2/3, from_constructor3/4, from_constructor4/5, from_constructor5/6, from_constructor6/7, from_constructor7/8, from_constructor8/9, from_constructor9/10, tuple1/1, tuple2/2, tuple3/3, tuple4/4, tuple5/5, tuple6/6, tuple7/7, tuple8/8, tuple9/9, render/3, can_match_on_multiple/1, list_empty/0, list_first_discard_rest/1, option_some/1, option_none/0]).
-export_type([pattern/2]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

-opaque pattern(LFQ, LFR) :: {variable, binary(), LFR} |
    {string_literal, binary(), LFR} |
    {string_concat, {binary(), binary()}, LFR} |
    {int_literal, integer(), LFR} |
    {bool_literal, boolean(), LFR} |
    {tuple,
        list(pattern(gleamgen@type_:dynamic_(), gleamgen@type_:dynamic_())),
        LFR} |
    {constructor,
        {binary(),
            list(pattern(gleamgen@type_:dynamic_(), gleamgen@type_:dynamic_()))},
        LFR,
        gleam@option:option(gleamgen@internal@import_reference:import_reference())} |
    {'or', {pattern(LFQ, LFR), pattern(LFQ, LFR)}, LFR} |
    {as,
        {pattern(gleamgen@type_:dynamic_(), gleamgen@type_:dynamic_()),
            binary()},
        LFR}.

-file("src/gleamgen/pattern.gleam", 39).
?DOC(
    " Match any value with a variable name.\n"
    " If you do not care about the contents, use `discard`\n"
).
-spec variable(binary()) -> pattern(LFS, gleamgen@expression:expression(LFS)).
variable(Name) ->
    {variable, Name, gleamgen@expression:raw(Name)}.

-file("src/gleamgen/pattern.gleam", 44).
?DOC(" Match a string literal\n").
-spec string_literal(binary()) -> pattern(any(), nil).
string_literal(Literal) ->
    {string_literal, Literal, nil}.

-file("src/gleamgen/pattern.gleam", 51).
?DOC(
    " Match and discard any value (Generates `_`).\n"
    " If you want to name the discarded value, use `named_discard`\n"
    " If you want to use the discarded value in the output, use `variable`\n"
).
-spec discard() -> pattern(any(), nil).
discard() ->
    {variable, <<"_"/utf8>>, nil}.

-file("src/gleamgen/pattern.gleam", 56).
?DOC(" Match and discard any value (Generates `_name`)\n").
-spec named_discard(binary()) -> pattern(any(), nil).
named_discard(Name) ->
    {variable, <<"_"/utf8, Name/binary>>, nil}.

-file("src/gleamgen/pattern.gleam", 61).
?DOC(" Match an integer literal\n").
-spec int_literal(integer()) -> pattern(integer(), nil).
int_literal(Literal) ->
    {int_literal, Literal, nil}.

-file("src/gleamgen/pattern.gleam", 66).
?DOC(" Match a boolean literal\n").
-spec bool_literal(boolean()) -> pattern(boolean(), nil).
bool_literal(Literal) ->
    {bool_literal, Literal, nil}.

-file("src/gleamgen/pattern.gleam", 92).
?DOC(
    " Match a string that starts with `initial`\n"
    " ```gleam\n"
    " case_.new(expression.string(\"I love gleam\"))\n"
    " |> case_.with_pattern(\n"
    "   pattern.concat_string(starting: \"I love \", variable: \"thing\"),\n"
    "   fn(thing) {\n"
    "     expression.string(\"I love \")\n"
    "     |> expression.concat_string(thing)\n"
    "     |> expression.concat_string(expression.string(\" too\"))\n"
    "   },\n"
    " )\n"
    " |> case_.with_pattern(pattern.variable(\"_\"), fn(_) {\n"
    "   expression.string(\"interesting\")\n"
    " })\n"
    " |> case_.build_expression()\n"
    " |> expression.render(render.default_context())\n"
    " |> render.to_string()\n"
    " // -> \"case \\\"I love gleam\\\" {\n"
    "  \\\"I love \\\" <> thing -> \\\"I love \\\" <> thing <> \\\" too\\\"\n"
    "  _ -> \\\"Interesting\\\"\n"
    " }\"\n"
    " ```\n"
).
-spec concat_string(binary(), binary()) -> pattern(binary(), gleamgen@expression:expression(any())).
concat_string(Initial, Variable) ->
    {string_concat, {Initial, Variable}, gleamgen@expression:raw(Variable)}.

-file("src/gleamgen/pattern.gleam", 135).
?DOC(
    " Use either of the two patterns\n"
    " ```gleam\n"
    " case_.new(expression.string(\"hello\"))\n"
    " |> case_.with_pattern(\n"
    "   pattern.or(pattern.string_literal(\"hello\"), pattern.string_literal(\"hi\")),\n"
    "   fn(_) { expression.string(\"world\") },\n"
    " )\n"
    " |> case_.with_pattern(pattern.variable(\"v\"), fn(v) {\n"
    "   expression.concat_string(v, expression.string(\" world\"))\n"
    " })\n"
    " |> case_.build_expression()\n"
    " |> expression.render(render.default_context())\n"
    " |> render.to_string()\n"
    " // -> \"case \\\"hello\\\" {\n"
    "  \\\"hello\\\" | \\\"hi\\\" -> \\\"world\\\"\n"
    "  v -> v <> \\\" world\\\"\n"
    " }\",\n"
    " ```\n"
).
-spec 'or'(pattern(LHF, LHG), pattern(LHF, LHG)) -> pattern(LHF, LHG).
'or'(First, Second) ->
    {'or', {First, Second}, erlang:element(3, First)}.

-file("src/gleamgen/pattern.gleam", 170).
?DOC(" See `from_constructor1`.\n").
-spec from_constructor0(
    gleamgen@expression@constructor:constructor(LIN, {}, any())
) -> pattern(LIN, nil).
from_constructor0(Constructor) ->
    {constructor,
        {gleamgen@expression@constructor:name(Constructor), []},
        nil,
        none}.

-file("src/gleamgen/pattern.gleam", 492).
-spec tuple0() -> pattern({}, nil).
tuple0() ->
    {tuple, [], nil}.

-file("src/gleamgen/pattern.gleam", 756).
-spec get_output(pattern(any(), MAA)) -> MAA.
get_output(Pattern) ->
    erlang:element(3, Pattern).

-file("src/gleamgen/pattern.gleam", 762).
-spec to_dynamic(pattern(any(), any())) -> pattern(gleamgen@type_:dynamic_(), gleamgen@type_:dynamic_()).
to_dynamic(Type_) ->
    gleamgen_ffi:identity(Type_).

-file("src/gleamgen/pattern.gleam", 99).
-spec ok(pattern(LGN, LGO)) -> pattern({ok, LGN} | {error, any()}, LGO).
ok(Ok_pattern) ->
    {constructor,
        {<<"Ok"/utf8>>,
            [begin
                    _pipe = Ok_pattern,
                    gleamgen_ffi:identity(_pipe)
                end]},
        erlang:element(3, Ok_pattern),
        none}.

-file("src/gleamgen/pattern.gleam", 107).
-spec error(pattern(LGW, LGX)) -> pattern({ok, any()} | {error, LGW}, LGX).
error(Err_pattern) ->
    {constructor,
        {<<"Error"/utf8>>,
            [begin
                    _pipe = Err_pattern,
                    gleamgen_ffi:identity(_pipe)
                end]},
        erlang:element(3, Err_pattern),
        none}.

-file("src/gleamgen/pattern.gleam", 142).
-spec as_(pattern(LHN, any()), binary()) -> pattern(LHN, gleamgen@expression:expression(LHN)).
as_(Original, Name) ->
    {as,
        {begin
                _pipe = Original,
                gleamgen_ffi:identity(_pipe)
            end,
            Name},
        gleamgen@expression:raw(Name)}.

-file("src/gleamgen/pattern.gleam", 149).
-spec from_constructor_dynamic(
    gleamgen@expression@constructor:constructor(any(), any(), any()),
    list(pattern(gleamgen@type_:dynamic_(), gleamgen@type_:dynamic_()))
) -> pattern(any(), list(gleamgen@expression:expression(gleamgen@type_:dynamic_()))).
from_constructor_dynamic(Constructor, Constructors) ->
    {constructor,
        {gleamgen@expression@constructor:name(Constructor),
            gleam@list:map(Constructors, fun gleamgen_ffi:identity/1)},
        gleam@list:filter_map(
            Constructors,
            fun gleamgen_ffi:get_pattern_output/1
        ),
        none}.

-file("src/gleamgen/pattern.gleam", 201).
?DOC(
    " Create a pattern that matches a custom constructor with one argument.\n"
    " Use `from_constructor_dynamic` for ad dynamic number of arguments.\n"
    " ```gleam\n"
    " let animals =\n"
    "   custom.new(ExampleAnimal)\n"
    "   |> custom.with_variant(fn(_) {\n"
    "     variant.new(\"Dog\")\n"
    "     |> variant.with_argument(option.Some(\"bones\"), type_.int)\n"
    "   })\n"
    " \n"
    " use animal_type, dog_constructor <- module.with_custom_type1(\n"
    "   definition.new(\"Animal\") |> definition.with_publicity(True),\n"
    "   animals,\n"
    " )\n"
    " ...\n"
    " pattern.from_constructor1(\n"
    "   dog_constructor,\n"
    "   pattern.variable(\"bones\"),\n"
    " ) |> pattern.render(context, 1)\n"
    " // -> \"Dog(bones)\"\n"
    " ```\n"
).
-spec from_constructor1(
    gleamgen@expression@constructor:constructor(LIU, {{}, LIV}, LIW),
    pattern(LIV, LJA)
) -> pattern(gleamgen@type_@custom:custom_type(LIU, LIW), LJA).
from_constructor1(Constructor, First) ->
    {constructor,
        {gleamgen@expression@constructor:name(Constructor),
            [begin
                    _pipe = First,
                    gleamgen_ffi:identity(_pipe)
                end]},
        erlang:element(3, First),
        none}.

-file("src/gleamgen/pattern.gleam", 215).
-spec from_constructor2(
    gleamgen@expression@constructor:constructor(LJH, {{{}, LJI}, LJJ}, LJK),
    pattern(LJI, LJO),
    pattern(LJJ, LJR)
) -> pattern(gleamgen@type_@custom:custom_type(LJH, LJK), {LJO, LJR}).
from_constructor2(Constructor, First, Second) ->
    {constructor,
        {gleamgen@expression@constructor:name(Constructor),
            [begin
                    _pipe = First,
                    gleamgen_ffi:identity(_pipe)
                end,
                begin
                    _pipe@1 = Second,
                    gleamgen_ffi:identity(_pipe@1)
                end]},
        {erlang:element(3, First), erlang:element(3, Second)},
        none}.

-file("src/gleamgen/pattern.gleam", 230).
-spec from_constructor3(
    gleamgen@expression@constructor:constructor(LJY, {{{{}, LJZ}, LKA}, LKB}, any()),
    pattern(LJZ, LKG),
    pattern(LKA, LKJ),
    pattern(LKB, LKM)
) -> pattern(LJY, {LKG, LKJ, LKM}).
from_constructor3(Constructor, First, Second, Third) ->
    {constructor,
        {gleamgen@expression@constructor:name(Constructor),
            [begin
                    _pipe = First,
                    gleamgen_ffi:identity(_pipe)
                end,
                begin
                    _pipe@1 = Second,
                    gleamgen_ffi:identity(_pipe@1)
                end,
                begin
                    _pipe@2 = Third,
                    gleamgen_ffi:identity(_pipe@2)
                end]},
        {erlang:element(3, First),
            erlang:element(3, Second),
            erlang:element(3, Third)},
        none}.

-file("src/gleamgen/pattern.gleam", 251).
-spec from_constructor4(
    gleamgen@expression@constructor:constructor(LKR, {{{{{}, LKS}, LKT}, LKU},
        LKV}, any()),
    pattern(LKS, LLA),
    pattern(LKT, LLD),
    pattern(LKU, LLG),
    pattern(LKV, LLJ)
) -> pattern(LKR, {LLA, LLD, LLG, LLJ}).
from_constructor4(Constructor, First, Second, Third, Fourth) ->
    {constructor,
        {gleamgen@expression@constructor:name(Constructor),
            [begin
                    _pipe = First,
                    gleamgen_ffi:identity(_pipe)
                end,
                begin
                    _pipe@1 = Second,
                    gleamgen_ffi:identity(_pipe@1)
                end,
                begin
                    _pipe@2 = Third,
                    gleamgen_ffi:identity(_pipe@2)
                end,
                begin
                    _pipe@3 = Fourth,
                    gleamgen_ffi:identity(_pipe@3)
                end]},
        {erlang:element(3, First),
            erlang:element(3, Second),
            erlang:element(3, Third),
            erlang:element(3, Fourth)},
        none}.

-file("src/gleamgen/pattern.gleam", 274).
-spec from_constructor5(
    gleamgen@expression@constructor:constructor(LLO, {{{{{{}, LLP}, LLQ}, LLR},
            LLS},
        LLT}, any()),
    pattern(LLP, LLY),
    pattern(LLQ, LMB),
    pattern(LLR, LME),
    pattern(LLS, LMH),
    pattern(LLT, LMK)
) -> pattern(LLO, {LLY, LMB, LME, LMH, LMK}).
from_constructor5(Constructor, First, Second, Third, Fourth, Fifth) ->
    {constructor,
        {gleamgen@expression@constructor:name(Constructor),
            [begin
                    _pipe = First,
                    gleamgen_ffi:identity(_pipe)
                end,
                begin
                    _pipe@1 = Second,
                    gleamgen_ffi:identity(_pipe@1)
                end,
                begin
                    _pipe@2 = Third,
                    gleamgen_ffi:identity(_pipe@2)
                end,
                begin
                    _pipe@3 = Fourth,
                    gleamgen_ffi:identity(_pipe@3)
                end,
                begin
                    _pipe@4 = Fifth,
                    gleamgen_ffi:identity(_pipe@4)
                end]},
        {erlang:element(3, First),
            erlang:element(3, Second),
            erlang:element(3, Third),
            erlang:element(3, Fourth),
            erlang:element(3, Fifth)},
        none}.

-file("src/gleamgen/pattern.gleam", 305).
-spec from_constructor6(
    gleamgen@expression@constructor:constructor(LMP, {{{{{{{}, LMQ}, LMR}, LMS},
                LMT},
            LMU},
        LMV}, any()),
    pattern(LMQ, LNA),
    pattern(LMR, LND),
    pattern(LMS, LNG),
    pattern(LMT, LNJ),
    pattern(LMU, LNM),
    pattern(LMV, LNP)
) -> pattern(LMP, {LNA, LND, LNG, LNJ, LNM, LNP}).
from_constructor6(Constructor, First, Second, Third, Fourth, Fifth, Sixth) ->
    {constructor,
        {gleamgen@expression@constructor:name(Constructor),
            [begin
                    _pipe = First,
                    gleamgen_ffi:identity(_pipe)
                end,
                begin
                    _pipe@1 = Second,
                    gleamgen_ffi:identity(_pipe@1)
                end,
                begin
                    _pipe@2 = Third,
                    gleamgen_ffi:identity(_pipe@2)
                end,
                begin
                    _pipe@3 = Fourth,
                    gleamgen_ffi:identity(_pipe@3)
                end,
                begin
                    _pipe@4 = Fifth,
                    gleamgen_ffi:identity(_pipe@4)
                end,
                begin
                    _pipe@5 = Sixth,
                    gleamgen_ffi:identity(_pipe@5)
                end]},
        {erlang:element(3, First),
            erlang:element(3, Second),
            erlang:element(3, Third),
            erlang:element(3, Fourth),
            erlang:element(3, Fifth),
            erlang:element(3, Sixth)},
        none}.

-file("src/gleamgen/pattern.gleam", 342).
-spec from_constructor7(
    gleamgen@expression@constructor:constructor(LNU, {{{{{{{{}, LNV}, LNW}, LNX},
                    LNY},
                LNZ},
            LOA},
        LOB}, any()),
    pattern(LNV, LOG),
    pattern(LNW, LOJ),
    pattern(LNX, LOM),
    pattern(LNY, LOP),
    pattern(LNZ, LOS),
    pattern(LOA, LOV),
    pattern(LOB, LOY)
) -> pattern(LNU, {LOG, LOJ, LOM, LOP, LOS, LOV, LOY}).
from_constructor7(
    Constructor,
    First,
    Second,
    Third,
    Fourth,
    Fifth,
    Sixth,
    Seventh
) ->
    {constructor,
        {gleamgen@expression@constructor:name(Constructor),
            [begin
                    _pipe = First,
                    gleamgen_ffi:identity(_pipe)
                end,
                begin
                    _pipe@1 = Second,
                    gleamgen_ffi:identity(_pipe@1)
                end,
                begin
                    _pipe@2 = Third,
                    gleamgen_ffi:identity(_pipe@2)
                end,
                begin
                    _pipe@3 = Fourth,
                    gleamgen_ffi:identity(_pipe@3)
                end,
                begin
                    _pipe@4 = Fifth,
                    gleamgen_ffi:identity(_pipe@4)
                end,
                begin
                    _pipe@5 = Sixth,
                    gleamgen_ffi:identity(_pipe@5)
                end,
                begin
                    _pipe@6 = Seventh,
                    gleamgen_ffi:identity(_pipe@6)
                end]},
        {erlang:element(3, First),
            erlang:element(3, Second),
            erlang:element(3, Third),
            erlang:element(3, Fourth),
            erlang:element(3, Fifth),
            erlang:element(3, Sixth),
            erlang:element(3, Seventh)},
        none}.

-file("src/gleamgen/pattern.gleam", 382).
-spec from_constructor8(
    gleamgen@expression@constructor:constructor(LPD, {{{{{{{{{}, LPE}, LPF},
                            LPG},
                        LPH},
                    LPI},
                LPJ},
            LPK},
        LPL}, any()),
    pattern(LPE, LPQ),
    pattern(LPF, LPT),
    pattern(LPG, LPW),
    pattern(LPH, LPZ),
    pattern(LPI, LQC),
    pattern(LPJ, LQF),
    pattern(LPK, LQI),
    pattern(LPL, LQL)
) -> pattern(LPD, {LPQ, LPT, LPW, LPZ, LQC, LQF, LQI, LQL}).
from_constructor8(
    Constructor,
    First,
    Second,
    Third,
    Fourth,
    Fifth,
    Sixth,
    Seventh,
    Eighth
) ->
    {constructor,
        {gleamgen@expression@constructor:name(Constructor),
            [begin
                    _pipe = First,
                    gleamgen_ffi:identity(_pipe)
                end,
                begin
                    _pipe@1 = Second,
                    gleamgen_ffi:identity(_pipe@1)
                end,
                begin
                    _pipe@2 = Third,
                    gleamgen_ffi:identity(_pipe@2)
                end,
                begin
                    _pipe@3 = Fourth,
                    gleamgen_ffi:identity(_pipe@3)
                end,
                begin
                    _pipe@4 = Fifth,
                    gleamgen_ffi:identity(_pipe@4)
                end,
                begin
                    _pipe@5 = Sixth,
                    gleamgen_ffi:identity(_pipe@5)
                end,
                begin
                    _pipe@6 = Seventh,
                    gleamgen_ffi:identity(_pipe@6)
                end,
                begin
                    _pipe@7 = Eighth,
                    gleamgen_ffi:identity(_pipe@7)
                end]},
        {erlang:element(3, First),
            erlang:element(3, Second),
            erlang:element(3, Third),
            erlang:element(3, Fourth),
            erlang:element(3, Fifth),
            erlang:element(3, Sixth),
            erlang:element(3, Seventh),
            erlang:element(3, Eighth)},
        none}.

-file("src/gleamgen/pattern.gleam", 434).
-spec from_constructor9(
    gleamgen@expression@constructor:constructor(LQQ, {{{{{{{{{{}, LQR}, LQS},
                                LQT},
                            LQU},
                        LQV},
                    LQW},
                LQX},
            LQY},
        LQZ}, any()),
    pattern(LQR, LRE),
    pattern(LQS, LRH),
    pattern(LQT, LRK),
    pattern(LQU, LRN),
    pattern(LQV, LRQ),
    pattern(LQW, LRT),
    pattern(LQX, LRW),
    pattern(LQY, LRZ),
    pattern(LQZ, LSC)
) -> pattern(LQQ, {LRE, LRH, LRK, LRN, LRQ, LRT, LRW, LRZ, LSC}).
from_constructor9(
    Constructor,
    First,
    Second,
    Third,
    Fourth,
    Fifth,
    Sixth,
    Seventh,
    Eighth,
    Ninth
) ->
    {constructor,
        {gleamgen@expression@constructor:name(Constructor),
            [begin
                    _pipe = First,
                    gleamgen_ffi:identity(_pipe)
                end,
                begin
                    _pipe@1 = Second,
                    gleamgen_ffi:identity(_pipe@1)
                end,
                begin
                    _pipe@2 = Third,
                    gleamgen_ffi:identity(_pipe@2)
                end,
                begin
                    _pipe@3 = Fourth,
                    gleamgen_ffi:identity(_pipe@3)
                end,
                begin
                    _pipe@4 = Fifth,
                    gleamgen_ffi:identity(_pipe@4)
                end,
                begin
                    _pipe@5 = Sixth,
                    gleamgen_ffi:identity(_pipe@5)
                end,
                begin
                    _pipe@6 = Seventh,
                    gleamgen_ffi:identity(_pipe@6)
                end,
                begin
                    _pipe@7 = Eighth,
                    gleamgen_ffi:identity(_pipe@7)
                end,
                begin
                    _pipe@8 = Ninth,
                    gleamgen_ffi:identity(_pipe@8)
                end]},
        {erlang:element(3, First),
            erlang:element(3, Second),
            erlang:element(3, Third),
            erlang:element(3, Fourth),
            erlang:element(3, Fifth),
            erlang:element(3, Sixth),
            erlang:element(3, Seventh),
            erlang:element(3, Eighth),
            erlang:element(3, Ninth)},
        none}.

-file("src/gleamgen/pattern.gleam", 496).
-spec tuple1(pattern(LSJ, LSK)) -> pattern({LSJ}, {LSK}).
tuple1(Pattern) ->
    {tuple,
        [begin
                _pipe = Pattern,
                gleamgen_ffi:identity(_pipe)
            end],
        {erlang:element(3, Pattern)}}.

-file("src/gleamgen/pattern.gleam", 505).
-spec tuple2(pattern(LSP, LSQ), pattern(LST, LSU)) -> pattern({LSP, LST}, {LSQ,
    LSU}).
tuple2(Pattern1, Pattern2) ->
    {tuple,
        [begin
                _pipe = Pattern1,
                gleamgen_ffi:identity(_pipe)
            end,
            begin
                _pipe@1 = Pattern2,
                gleamgen_ffi:identity(_pipe@1)
            end],
        {erlang:element(3, Pattern1), erlang:element(3, Pattern2)}}.

-file("src/gleamgen/pattern.gleam", 515).
-spec tuple3(pattern(LSZ, LTA), pattern(LTD, LTE), pattern(LTH, LTI)) -> pattern({LSZ,
    LTD,
    LTH}, {LTA, LTE, LTI}).
tuple3(Pattern1, Pattern2, Pattern3) ->
    {tuple,
        [begin
                _pipe = Pattern1,
                gleamgen_ffi:identity(_pipe)
            end,
            begin
                _pipe@1 = Pattern2,
                gleamgen_ffi:identity(_pipe@1)
            end,
            begin
                _pipe@2 = Pattern3,
                gleamgen_ffi:identity(_pipe@2)
            end],
        {erlang:element(3, Pattern1),
            erlang:element(3, Pattern2),
            erlang:element(3, Pattern3)}}.

-file("src/gleamgen/pattern.gleam", 530).
-spec tuple4(
    pattern(LTN, LTO),
    pattern(LTR, LTS),
    pattern(LTV, LTW),
    pattern(LTZ, LUA)
) -> pattern({LTN, LTR, LTV, LTZ}, {LTO, LTS, LTW, LUA}).
tuple4(Pattern1, Pattern2, Pattern3, Pattern4) ->
    {tuple,
        [begin
                _pipe = Pattern1,
                gleamgen_ffi:identity(_pipe)
            end,
            begin
                _pipe@1 = Pattern2,
                gleamgen_ffi:identity(_pipe@1)
            end,
            begin
                _pipe@2 = Pattern3,
                gleamgen_ffi:identity(_pipe@2)
            end,
            begin
                _pipe@3 = Pattern4,
                gleamgen_ffi:identity(_pipe@3)
            end],
        {erlang:element(3, Pattern1),
            erlang:element(3, Pattern2),
            erlang:element(3, Pattern3),
            erlang:element(3, Pattern4)}}.

-file("src/gleamgen/pattern.gleam", 555).
-spec tuple5(
    pattern(LUF, LUG),
    pattern(LUJ, LUK),
    pattern(LUN, LUO),
    pattern(LUR, LUS),
    pattern(LUV, LUW)
) -> pattern({LUF, LUJ, LUN, LUR, LUV}, {LUG, LUK, LUO, LUS, LUW}).
tuple5(Pattern1, Pattern2, Pattern3, Pattern4, Pattern5) ->
    {tuple,
        [begin
                _pipe = Pattern1,
                gleamgen_ffi:identity(_pipe)
            end,
            begin
                _pipe@1 = Pattern2,
                gleamgen_ffi:identity(_pipe@1)
            end,
            begin
                _pipe@2 = Pattern3,
                gleamgen_ffi:identity(_pipe@2)
            end,
            begin
                _pipe@3 = Pattern4,
                gleamgen_ffi:identity(_pipe@3)
            end,
            begin
                _pipe@4 = Pattern5,
                gleamgen_ffi:identity(_pipe@4)
            end],
        {erlang:element(3, Pattern1),
            erlang:element(3, Pattern2),
            erlang:element(3, Pattern3),
            erlang:element(3, Pattern4),
            erlang:element(3, Pattern5)}}.

-file("src/gleamgen/pattern.gleam", 583).
-spec tuple6(
    pattern(LVB, LVC),
    pattern(LVF, LVG),
    pattern(LVJ, LVK),
    pattern(LVN, LVO),
    pattern(LVR, LVS),
    pattern(LVV, LVW)
) -> pattern({LVB, LVF, LVJ, LVN, LVR, LVV}, {LVC, LVG, LVK, LVO, LVS, LVW}).
tuple6(Pattern1, Pattern2, Pattern3, Pattern4, Pattern5, Pattern6) ->
    {tuple,
        [begin
                _pipe = Pattern1,
                gleamgen_ffi:identity(_pipe)
            end,
            begin
                _pipe@1 = Pattern2,
                gleamgen_ffi:identity(_pipe@1)
            end,
            begin
                _pipe@2 = Pattern3,
                gleamgen_ffi:identity(_pipe@2)
            end,
            begin
                _pipe@3 = Pattern4,
                gleamgen_ffi:identity(_pipe@3)
            end,
            begin
                _pipe@4 = Pattern5,
                gleamgen_ffi:identity(_pipe@4)
            end,
            begin
                _pipe@5 = Pattern6,
                gleamgen_ffi:identity(_pipe@5)
            end],
        {erlang:element(3, Pattern1),
            erlang:element(3, Pattern2),
            erlang:element(3, Pattern3),
            erlang:element(3, Pattern4),
            erlang:element(3, Pattern5),
            erlang:element(3, Pattern6)}}.

-file("src/gleamgen/pattern.gleam", 614).
-spec tuple7(
    pattern(LWB, LWC),
    pattern(LWF, LWG),
    pattern(LWJ, LWK),
    pattern(LWN, LWO),
    pattern(LWR, LWS),
    pattern(LWV, LWW),
    pattern(LWZ, LXA)
) -> pattern({LWB, LWF, LWJ, LWN, LWR, LWV, LWZ}, {LWC,
    LWG,
    LWK,
    LWO,
    LWS,
    LWW,
    LXA}).
tuple7(Pattern1, Pattern2, Pattern3, Pattern4, Pattern5, Pattern6, Pattern7) ->
    {tuple,
        [begin
                _pipe = Pattern1,
                gleamgen_ffi:identity(_pipe)
            end,
            begin
                _pipe@1 = Pattern2,
                gleamgen_ffi:identity(_pipe@1)
            end,
            begin
                _pipe@2 = Pattern3,
                gleamgen_ffi:identity(_pipe@2)
            end,
            begin
                _pipe@3 = Pattern4,
                gleamgen_ffi:identity(_pipe@3)
            end,
            begin
                _pipe@4 = Pattern5,
                gleamgen_ffi:identity(_pipe@4)
            end,
            begin
                _pipe@5 = Pattern6,
                gleamgen_ffi:identity(_pipe@5)
            end,
            begin
                _pipe@6 = Pattern7,
                gleamgen_ffi:identity(_pipe@6)
            end],
        {erlang:element(3, Pattern1),
            erlang:element(3, Pattern2),
            erlang:element(3, Pattern3),
            erlang:element(3, Pattern4),
            erlang:element(3, Pattern5),
            erlang:element(3, Pattern6),
            erlang:element(3, Pattern7)}}.

-file("src/gleamgen/pattern.gleam", 648).
-spec tuple8(
    pattern(LXF, LXG),
    pattern(LXJ, LXK),
    pattern(LXN, LXO),
    pattern(LXR, LXS),
    pattern(LXV, LXW),
    pattern(LXZ, LYA),
    pattern(LYD, LYE),
    pattern(LYH, LYI)
) -> pattern({LXF, LXJ, LXN, LXR, LXV, LXZ, LYD, LYH}, {LXG,
    LXK,
    LXO,
    LXS,
    LXW,
    LYA,
    LYE,
    LYI}).
tuple8(
    Pattern1,
    Pattern2,
    Pattern3,
    Pattern4,
    Pattern5,
    Pattern6,
    Pattern7,
    Pattern8
) ->
    {tuple,
        [begin
                _pipe = Pattern1,
                gleamgen_ffi:identity(_pipe)
            end,
            begin
                _pipe@1 = Pattern2,
                gleamgen_ffi:identity(_pipe@1)
            end,
            begin
                _pipe@2 = Pattern3,
                gleamgen_ffi:identity(_pipe@2)
            end,
            begin
                _pipe@3 = Pattern4,
                gleamgen_ffi:identity(_pipe@3)
            end,
            begin
                _pipe@4 = Pattern5,
                gleamgen_ffi:identity(_pipe@4)
            end,
            begin
                _pipe@5 = Pattern6,
                gleamgen_ffi:identity(_pipe@5)
            end,
            begin
                _pipe@6 = Pattern7,
                gleamgen_ffi:identity(_pipe@6)
            end,
            begin
                _pipe@7 = Pattern8,
                gleamgen_ffi:identity(_pipe@7)
            end],
        {erlang:element(3, Pattern1),
            erlang:element(3, Pattern2),
            erlang:element(3, Pattern3),
            erlang:element(3, Pattern4),
            erlang:element(3, Pattern5),
            erlang:element(3, Pattern6),
            erlang:element(3, Pattern7),
            erlang:element(3, Pattern8)}}.

-file("src/gleamgen/pattern.gleam", 694).
-spec tuple9(
    pattern(LYN, LYO),
    pattern(LYR, LYS),
    pattern(LYV, LYW),
    pattern(LYZ, LZA),
    pattern(LZD, LZE),
    pattern(LZH, LZI),
    pattern(LZL, LZM),
    pattern(LZP, LZQ),
    pattern(LZT, LZU)
) -> pattern({LYN, LYR, LYV, LYZ, LZD, LZH, LZL, LZP, LZT}, {LYO,
    LYS,
    LYW,
    LZA,
    LZE,
    LZI,
    LZM,
    LZQ,
    LZU}).
tuple9(
    Pattern1,
    Pattern2,
    Pattern3,
    Pattern4,
    Pattern5,
    Pattern6,
    Pattern7,
    Pattern8,
    Pattern9
) ->
    {tuple,
        [begin
                _pipe = Pattern1,
                gleamgen_ffi:identity(_pipe)
            end,
            begin
                _pipe@1 = Pattern2,
                gleamgen_ffi:identity(_pipe@1)
            end,
            begin
                _pipe@2 = Pattern3,
                gleamgen_ffi:identity(_pipe@2)
            end,
            begin
                _pipe@3 = Pattern4,
                gleamgen_ffi:identity(_pipe@3)
            end,
            begin
                _pipe@4 = Pattern5,
                gleamgen_ffi:identity(_pipe@4)
            end,
            begin
                _pipe@5 = Pattern6,
                gleamgen_ffi:identity(_pipe@5)
            end,
            begin
                _pipe@6 = Pattern7,
                gleamgen_ffi:identity(_pipe@6)
            end,
            begin
                _pipe@7 = Pattern8,
                gleamgen_ffi:identity(_pipe@7)
            end,
            begin
                _pipe@8 = Pattern9,
                gleamgen_ffi:identity(_pipe@8)
            end],
        {erlang:element(3, Pattern1),
            erlang:element(3, Pattern2),
            erlang:element(3, Pattern3),
            erlang:element(3, Pattern4),
            erlang:element(3, Pattern5),
            erlang:element(3, Pattern6),
            erlang:element(3, Pattern7),
            erlang:element(3, Pattern8),
            erlang:element(3, Pattern9)}}.

-file("src/gleamgen/pattern.gleam", 766).
-spec render(
    pattern(gleamgen@type_:dynamic_(), gleamgen@type_:dynamic_()),
    gleamgen@internal@render:context(),
    integer()
) -> gleamgen@internal@render:rendered().
render(Pattern, Context, Number_of_subjects) ->
    case Pattern of
        {variable, Name, _} ->
            _pipe = gleam@list:repeat(
                glam@doc:from_string(Name),
                Number_of_subjects
            ),
            _pipe@1 = glam@doc:concat_join(
                _pipe,
                [glam@doc:from_string(<<","/utf8>>),
                    {break, <<" "/utf8>>, <<""/utf8>>}]
            ),
            {render, _pipe@1, {rendered_details, [], [], {report, [], []}}};

        {string_literal, Literal, _} ->
            _pipe@2 = gleamgen@internal@render:escape_string(Literal),
            _pipe@3 = glam@doc:from_string(_pipe@2),
            {render, _pipe@3, {rendered_details, [], [], {report, [], []}}};

        {string_concat, {Literal@1, Variable}, _} ->
            _pipe@4 = gleamgen@internal@render:escape_string(Literal@1),
            _pipe@5 = glam@doc:from_string(_pipe@4),
            _pipe@6 = glam@doc:append(
                _pipe@5,
                glam@doc:concat(
                    [{break, <<" "/utf8>>, <<""/utf8>>},
                        glam@doc:from_string(<<"<>"/utf8>>),
                        {break, <<" "/utf8>>, <<""/utf8>>},
                        glam@doc:from_string(Variable)]
                )
            ),
            _pipe@7 = glam@doc:group(_pipe@6),
            {render, _pipe@7, {rendered_details, [], [], {report, [], []}}};

        {int_literal, Literal@2, _} ->
            _pipe@8 = Literal@2,
            _pipe@9 = erlang:integer_to_binary(_pipe@8),
            _pipe@10 = glam@doc:from_string(_pipe@9),
            {render, _pipe@10, {rendered_details, [], [], {report, [], []}}};

        {bool_literal, true, _} ->
            _pipe@11 = glam@doc:from_string(<<"True"/utf8>>),
            {render, _pipe@11, {rendered_details, [], [], {report, [], []}}};

        {bool_literal, false, _} ->
            _pipe@12 = glam@doc:from_string(<<"False"/utf8>>),
            {render, _pipe@12, {rendered_details, [], [], {report, [], []}}};

        {'or', {First, Second}, _} ->
            Rendered_first = render(First, Context, 1),
            Rendered_second = render(Second, Context, 1),
            _pipe@13 = glam@doc:concat(
                [erlang:element(2, Rendered_first),
                    {break, <<" "/utf8>>, <<""/utf8>>},
                    glam@doc:from_string(<<"|"/utf8>>),
                    {break, <<" "/utf8>>, <<""/utf8>>},
                    erlang:element(2, Rendered_second)]
            ),
            {render,
                _pipe@13,
                gleamgen@internal@render:merge_details(
                    erlang:element(3, Rendered_first),
                    erlang:element(3, Rendered_second)
                )};

        {as, {Original, Name@1}, _} ->
            Original@1 = render(Original, Context, 1),
            _pipe@14 = glam@doc:concat(
                [erlang:element(2, Original@1),
                    {break, <<" "/utf8>>, <<""/utf8>>},
                    glam@doc:from_string(<<"as"/utf8>>),
                    {break, <<" "/utf8>>, <<""/utf8>>},
                    glam@doc:from_string(Name@1)]
            ),
            {render, _pipe@14, erlang:element(3, Original@1)};

        {constructor, {Name@2, Patterns}, _, Module} ->
            {Constructor_doc@1, Module_details} = case Module of
                none ->
                    {glam@doc:from_string(Name@2),
                        {rendered_details, [], [], {report, [], []}}};

                {some, Module@1} ->
                    Module_to_use = gleamgen@internal@render:get_import_from_context(
                        Context,
                        Module@1
                    ),
                    Constructor_doc = gleamgen@internal@import_reference:get_reference(
                        Module_to_use,
                        Name@2
                    ),
                    {Constructor_doc,
                        gleamgen@internal@render:add_import_to_details(
                            {rendered_details, [], [], {report, [], []}},
                            Module@1
                        )}
            end,
            case Patterns of
                [] ->
                    _pipe@15 = Constructor_doc@1,
                    {render, _pipe@15, Module_details};

                _ ->
                    {Details, Rendered_patterns} = begin
                        _pipe@16 = Patterns,
                        gleam@list:map_fold(
                            _pipe@16,
                            {rendered_details, [], [], {report, [], []}},
                            fun(Acc, M) ->
                                Rendered = render(M, Context, 1),
                                {gleamgen@internal@render:merge_details(
                                        Acc,
                                        erlang:element(3, Rendered)
                                    ),
                                    erlang:element(2, Rendered)}
                            end
                        )
                    end,
                    _pipe@17 = Rendered_patterns,
                    _pipe@18 = gleamgen@internal@render:pretty_list(_pipe@17),
                    _pipe@19 = glam@doc:prepend(_pipe@18, Constructor_doc@1),
                    {render,
                        _pipe@19,
                        gleamgen@internal@render:merge_details(
                            Details,
                            Module_details
                        )}
            end;

        {tuple, Patterns@1, _} ->
            {Details@1, Rendered_patterns@1} = begin
                _pipe@20 = Patterns@1,
                gleam@list:map_fold(
                    _pipe@20,
                    {rendered_details, [], [], {report, [], []}},
                    fun(Acc@1, M@1) ->
                        Rendered@1 = render(M@1, Context, 1),
                        {gleamgen@internal@render:merge_details(
                                Acc@1,
                                erlang:element(3, Rendered@1)
                            ),
                            erlang:element(2, Rendered@1)}
                    end
                )
            end,
            _pipe@24 = case Number_of_subjects of
                1 ->
                    _pipe@21 = Rendered_patterns@1,
                    _pipe@22 = gleamgen@internal@render:pretty_list(_pipe@21),
                    glam@doc:prepend(
                        _pipe@22,
                        glam@doc:from_string(<<"#"/utf8>>)
                    );

                _ ->
                    _pipe@23 = Rendered_patterns@1,
                    glam@doc:concat_join(
                        _pipe@23,
                        [glam@doc:from_string(<<","/utf8>>),
                            {break, <<" "/utf8>>, <<""/utf8>>}]
                    )
            end,
            {render, _pipe@24, Details@1}
    end.

-file("src/gleamgen/pattern.gleam", 887).
?DOC(false).
-spec can_match_on_multiple(pattern(any(), any())) -> boolean().
can_match_on_multiple(Pattern) ->
    case Pattern of
        {tuple, _, _} ->
            true;

        {variable, <<"_"/utf8>>, _} ->
            true;

        _ ->
            false
    end.

-file("src/gleamgen/pattern.gleam", 897).
?DOC(" Renders `[]`.\n").
-spec list_empty() -> pattern(list(any()), nil).
list_empty() ->
    {constructor, {<<"[]"/utf8>>, []}, nil, none}.

-file("src/gleamgen/pattern.gleam", 902).
?DOC(" Renders `[first, ..]` and binds the head element to `first`.\n").
-spec list_first_discard_rest(binary()) -> pattern(list(MAV), gleamgen@expression:expression(MAV)).
list_first_discard_rest(First) ->
    {constructor,
        {<<<<"["/utf8, First/binary>>/binary, ", ..]"/utf8>>, []},
        gleamgen@expression:raw(First),
        none}.

-file("src/gleamgen/pattern.gleam", 912).
?DOC(
    " Matches with `option.Some(inner)`. If the option module is already imported, this uses the existing \n"
    " import options (ie qualified or unqualified and aliases). Otherwise, it adds the import.\n"
).
-spec option_some(pattern(MBA, MBB)) -> pattern(gleam@option:option(MBA), MBB).
option_some(Inner) ->
    {constructor,
        {<<"Some"/utf8>>,
            [begin
                    _pipe = Inner,
                    gleamgen_ffi:identity(_pipe)
                end]},
        erlang:element(3, Inner),
        {some,
            gleamgen@internal@import_reference:new_implied_reference(
                [<<"gleam"/utf8>>, <<"option"/utf8>>]
            )}}.

-file("src/gleamgen/pattern.gleam", 924).
?DOC(
    " Matches with `None`. If the option module is already imported, this uses the existing \n"
    " import options (ie qualified or unqualified and aliases). Otherwise, it adds the import.\n"
).
-spec option_none() -> pattern(gleam@option:option(any()), nil).
option_none() ->
    {constructor,
        {<<"None"/utf8>>, []},
        nil,
        {some,
            gleamgen@internal@import_reference:new_implied_reference(
                [<<"gleam"/utf8>>, <<"option"/utf8>>]
            )}}.