-module(glance).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([precedence/1, module/1]).
-export_type([definition/1, attribute/0, module_/0, function_/0, span/0, statement/0, assignment_kind/0, use_pattern/0, pattern/0, expression/0, clause/0, bit_string_segment_option/1, binary_operator/0, fn_parameter/0, function_parameter/0, assignment_name/0, import/0, constant/0, unqualified_import/0, publicity/0, type_alias/0, custom_type/0, variant/0, record_update_field/1, variant_field/0, field/1, type/0, error/0, parse_expression_unit_context/0]).

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

-type definition(HVX) :: {definition, list(attribute()), HVX}.

-type attribute() :: {attribute, binary(), list(expression())}.

-type module_() :: {module,
        list(definition(import())),
        list(definition(custom_type())),
        list(definition(type_alias())),
        list(definition(constant())),
        list(definition(function_()))}.

-type function_() :: {function,
        span(),
        binary(),
        publicity(),
        list(function_parameter()),
        gleam@option:option(type()),
        list(statement())}.

-type span() :: {span, integer(), integer()}.

-type statement() :: {use, list(use_pattern()), expression()} |
    {assignment,
        assignment_kind(),
        pattern(),
        gleam@option:option(type()),
        expression()} |
    {assert, expression(), gleam@option:option(expression())} |
    {expression, expression()}.

-type assignment_kind() :: 'let' |
    {let_assert, gleam@option:option(expression())}.

-type use_pattern() :: {use_pattern, pattern(), gleam@option:option(type())}.

-type pattern() :: {pattern_int, binary()} |
    {pattern_float, binary()} |
    {pattern_string, binary()} |
    {pattern_discard, binary()} |
    {pattern_variable, binary()} |
    {pattern_tuple, list(pattern())} |
    {pattern_list, list(pattern()), gleam@option:option(pattern())} |
    {pattern_assignment, pattern(), binary()} |
    {pattern_concatenate,
        binary(),
        gleam@option:option(assignment_name()),
        assignment_name()} |
    {pattern_bit_string,
        list({pattern(), list(bit_string_segment_option(pattern()))})} |
    {pattern_variant,
        gleam@option:option(binary()),
        binary(),
        list(field(pattern())),
        boolean()}.

-type expression() :: {int, binary()} |
    {float, binary()} |
    {string, binary()} |
    {variable, binary()} |
    {negate_int, expression()} |
    {negate_bool, expression()} |
    {block, list(statement())} |
    {panic, gleam@option:option(expression())} |
    {todo, gleam@option:option(expression())} |
    {tuple, list(expression())} |
    {list, list(expression()), gleam@option:option(expression())} |
    {fn, list(fn_parameter()), gleam@option:option(type()), list(statement())} |
    {record_update,
        gleam@option:option(binary()),
        binary(),
        expression(),
        list(record_update_field(expression()))} |
    {field_access, expression(), binary()} |
    {call, expression(), list(field(expression()))} |
    {tuple_index, expression(), integer()} |
    {fn_capture,
        gleam@option:option(binary()),
        expression(),
        list(field(expression())),
        list(field(expression()))} |
    {bit_string,
        list({expression(), list(bit_string_segment_option(expression()))})} |
    {'case', list(expression()), list(clause())} |
    {binary_operator, binary_operator(), expression(), expression()} |
    {echo, gleam@option:option(expression())}.

-type clause() :: {clause,
        list(list(pattern())),
        gleam@option:option(expression()),
        expression()}.

-type bit_string_segment_option(HVY) :: bytes_option |
    int_option |
    float_option |
    bits_option |
    utf8_option |
    utf16_option |
    utf32_option |
    utf8_codepoint_option |
    utf16_codepoint_option |
    utf32_codepoint_option |
    signed_option |
    unsigned_option |
    big_option |
    little_option |
    native_option |
    {size_value_option, HVY} |
    {size_option, integer()} |
    {unit_option, integer()}.

-type binary_operator() :: 'and' |
    'or' |
    eq |
    not_eq |
    lt_int |
    lt_eq_int |
    lt_float |
    lt_eq_float |
    gt_eq_int |
    gt_int |
    gt_eq_float |
    gt_float |
    pipe |
    add_int |
    add_float |
    sub_int |
    sub_float |
    mult_int |
    mult_float |
    div_int |
    div_float |
    remainder_int |
    concatenate.

-type fn_parameter() :: {fn_parameter,
        assignment_name(),
        gleam@option:option(type())}.

-type function_parameter() :: {function_parameter,
        gleam@option:option(binary()),
        assignment_name(),
        gleam@option:option(type())}.

-type assignment_name() :: {named, binary()} | {discarded, binary()}.

-type import() :: {import,
        span(),
        binary(),
        gleam@option:option(assignment_name()),
        list(unqualified_import()),
        list(unqualified_import())}.

-type constant() :: {constant,
        binary(),
        publicity(),
        gleam@option:option(type()),
        expression()}.

-type unqualified_import() :: {unqualified_import,
        binary(),
        gleam@option:option(binary())}.

-type publicity() :: public | private.

-type type_alias() :: {type_alias,
        span(),
        binary(),
        publicity(),
        list(binary()),
        type()}.

-type custom_type() :: {custom_type,
        span(),
        binary(),
        publicity(),
        boolean(),
        list(binary()),
        list(variant())}.

-type variant() :: {variant, binary(), list(variant_field()), list(attribute())}.

-type record_update_field(HVZ) :: {record_update_field,
        binary(),
        gleam@option:option(HVZ)}.

-type variant_field() :: {labelled_variant_field, type(), binary()} |
    {unlabelled_variant_field, type()}.

-type field(HWA) :: {labelled_field, binary(), HWA} |
    {shorthand_field, binary()} |
    {unlabelled_field, HWA}.

-type type() :: {named_type,
        span(),
        binary(),
        gleam@option:option(binary()),
        list(type())} |
    {tuple_type, span(), list(type())} |
    {function_type, span(), list(type()), type()} |
    {variable_type, span(), binary()} |
    {hole_type, span(), binary()}.

-type error() :: unexpected_end_of_input |
    {unexpected_token, glexer@token:token(), glexer:position()}.

-type parse_expression_unit_context() :: regular_expression_unit |
    expression_unit_after_pipe.

-file("src/glance.gleam", 199).
-spec precedence(binary_operator()) -> integer().
precedence(Operator) ->
    case Operator of
        'or' ->
            1;

        'and' ->
            2;

        eq ->
            3;

        not_eq ->
            3;

        lt_int ->
            4;

        lt_eq_int ->
            4;

        lt_float ->
            4;

        lt_eq_float ->
            4;

        gt_eq_int ->
            4;

        gt_int ->
            4;

        gt_eq_float ->
            4;

        gt_float ->
            4;

        concatenate ->
            5;

        pipe ->
            6;

        add_int ->
            7;

        add_float ->
            7;

        sub_int ->
            7;

        sub_float ->
            7;

        mult_int ->
            8;

        mult_float ->
            8;

        div_int ->
            8;

        div_float ->
            8;

        remainder_int ->
            8
    end.

-file("src/glance.gleam", 377).
-spec push_variant(custom_type(), variant()) -> custom_type().
push_variant(Custom_type, Variant) ->
    _record = Custom_type,
    {custom_type,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        erlang:element(6, _record),
        [Variant | erlang:element(7, Custom_type)]}.

-file("src/glance.gleam", 381).
-spec expect(
    glexer@token:token(),
    list({glexer@token:token(), glexer:position()}),
    fun((glexer:position(), list({glexer@token:token(), glexer:position()})) -> {ok,
            HWI} |
        {error, error()})
) -> {ok, HWI} | {error, error()}.
expect(Expected, Tokens, Next) ->
    case Tokens of
        [] ->
            {error, unexpected_end_of_input};

        [{Token, Position} | Tokens@1] when Token =:= Expected ->
            Next(Position, Tokens@1);

        [{Other, Position@1} | _] ->
            {error, {unexpected_token, Other, Position@1}}
    end.

-file("src/glance.gleam", 394).
-spec expect_upper_name(
    list({glexer@token:token(), glexer:position()}),
    fun((binary(), integer(), list({glexer@token:token(), glexer:position()})) -> {ok,
            HWN} |
        {error, error()})
) -> {ok, HWN} | {error, error()}.
expect_upper_name(Tokens, Next) ->
    case Tokens of
        [] ->
            {error, unexpected_end_of_input};

        [{{upper_name, Name}, {position, End}} | Tokens@1] ->
            Next(Name, End, Tokens@1);

        [{Other, Position} | _] ->
            {error, {unexpected_token, Other, Position}}
    end.

-file("src/glance.gleam", 405).
-spec expect_name(
    list({glexer@token:token(), glexer:position()}),
    fun((binary(), list({glexer@token:token(), glexer:position()})) -> {ok, HWS} |
        {error, error()})
) -> {ok, HWS} | {error, error()}.
expect_name(Tokens, Next) ->
    case Tokens of
        [] ->
            {error, unexpected_end_of_input};

        [{{name, Name}, _} | Tokens@1] ->
            Next(Name, Tokens@1);

        [{Other, Position} | _] ->
            {error, {unexpected_token, Other, Position}}
    end.

-file("src/glance.gleam", 416).
-spec until(
    glexer@token:token(),
    HWX,
    list({glexer@token:token(), glexer:position()}),
    fun((HWX, list({glexer@token:token(), glexer:position()})) -> {ok,
            {HWX, list({glexer@token:token(), glexer:position()})}} |
        {error, error()})
) -> {ok, {HWX, integer(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
until(Limit, Acc, Tokens, Callback) ->
    case Tokens of
        [] ->
            {error, unexpected_end_of_input};

        [{Token, {position, I}} | Tokens@1] when Token =:= Limit ->
            {ok, {Acc, I, Tokens@1}};

        [_ | _] ->
            case Callback(Acc, Tokens) of
                {ok, {Acc@1, Tokens@2}} ->
                    until(Limit, Acc@1, Tokens@2, Callback);

                {error, Error} ->
                    {error, Error}
            end
    end.

-file("src/glance.gleam", 531).
-spec module_name(
    binary(),
    integer(),
    list({glexer@token:token(), glexer:position()})
) -> {ok,
        {binary(), integer(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
module_name(Name, End, Tokens) ->
    case Tokens of
        [{slash, _}, {{name, S}, {position, I}} | Tokens@1] when Name =/= <<""/utf8>> ->
            End@1 = I + erlang:byte_size(S),
            module_name(
                <<<<Name/binary, "/"/utf8>>/binary, S/binary>>,
                End@1,
                Tokens@1
            );

        [{{name, S@1}, {position, I@1}} | Tokens@2] when Name =:= <<""/utf8>> ->
            End@2 = I@1 + erlang:byte_size(S@1),
            module_name(S@1, End@2, Tokens@2);

        [] when Name =:= <<""/utf8>> ->
            {error, unexpected_end_of_input};

        [{Other, Position} | _] when Name =:= <<""/utf8>> ->
            {error, {unexpected_token, Other, Position}};

        _ ->
            {ok, {Name, End, Tokens}}
    end.

-file("src/glance.gleam", 554).
-spec optional_module_alias(list({glexer@token:token(), glexer:position()})) -> {gleam@option:option(assignment_name()),
    list({glexer@token:token(), glexer:position()})}.
optional_module_alias(Tokens) ->
    case Tokens of
        [{as, _}, {{name, Alias}, _} | Tokens@1] ->
            {{some, {named, Alias}}, Tokens@1};

        [{as, _}, {{discard_name, Alias@1}, _} | Tokens@2] ->
            {{some, {discarded, Alias@1}}, Tokens@2};

        _ ->
            {none, Tokens}
    end.

-file("src/glance.gleam", 922).
-spec unexpected_error(list({glexer@token:token(), glexer:position()})) -> {ok,
        any()} |
    {error, error()}.
unexpected_error(Tokens) ->
    case Tokens of
        [{Token, Position} | _] ->
            {error, {unexpected_token, Token, Position}};

        [] ->
            {error, unexpected_end_of_input}
    end.

-file("src/glance.gleam", 929).
-spec binary_operator(glexer@token:token()) -> {ok, binary_operator()} |
    {error, nil}.
binary_operator(Token) ->
    case Token of
        amper_amper ->
            {ok, 'and'};

        equal_equal ->
            {ok, eq};

        greater ->
            {ok, gt_int};

        greater_dot ->
            {ok, gt_float};

        greater_equal ->
            {ok, gt_eq_int};

        greater_equal_dot ->
            {ok, gt_eq_float};

        less ->
            {ok, lt_int};

        less_dot ->
            {ok, lt_float};

        less_equal ->
            {ok, lt_eq_int};

        less_equal_dot ->
            {ok, lt_eq_float};

        less_greater ->
            {ok, concatenate};

        minus ->
            {ok, sub_int};

        minus_dot ->
            {ok, sub_float};

        not_equal ->
            {ok, not_eq};

        percent ->
            {ok, remainder_int};

        v_bar_v_bar ->
            {ok, 'or'};

        pipe ->
            {ok, pipe};

        plus ->
            {ok, add_int};

        plus_dot ->
            {ok, add_float};

        slash ->
            {ok, div_int};

        slash_dot ->
            {ok, div_float};

        star ->
            {ok, mult_int};

        star_dot ->
            {ok, mult_float};

        _ ->
            {error, nil}
    end.

-file("src/glance.gleam", 958).
-spec pop_binary_operator(list({glexer@token:token(), glexer:position()})) -> {ok,
        {binary_operator(), list({glexer@token:token(), glexer:position()})}} |
    {error, nil}.
pop_binary_operator(Tokens) ->
    case Tokens of
        [{Token, _} | Tokens@1] ->
            gleam@result:map(
                binary_operator(Token),
                fun(Op) -> {Op, Tokens@1} end
            );

        [] ->
            {error, nil}
    end.

-file("src/glance.gleam", 1002).
?DOC(" Simple-Precedence-Parser, handle seeing an operator or end\n").
-spec handle_operator(
    gleam@option:option(binary_operator()),
    list(binary_operator()),
    list(expression())
) -> {gleam@option:option(expression()),
    list(binary_operator()),
    list(expression())}.
handle_operator(Next, Operators, Values) ->
    case {Next, Operators, Values} of
        {{some, Operator}, [], _} ->
            {none, [Operator], Values};

        {{some, Next@1}, [Previous | Operators@1], [A, B | Rest_values]} ->
            case precedence(Previous) >= precedence(Next@1) of
                true ->
                    Values@1 = [{binary_operator, Previous, B, A} | Rest_values],
                    handle_operator({some, Next@1}, Operators@1, Values@1);

                false ->
                    {none, [Next@1, Previous | Operators@1], Values}
            end;

        {none, [Operator@1 | Operators@2], [A@1, B@1 | Values@2]} ->
            Values@3 = [{binary_operator, Operator@1, B@1, A@1} | Values@2],
            handle_operator(none, Operators@2, Values@3);

        {none, [], [Expression]} ->
            {{some, Expression}, Operators, Values};

        {none, [], []} ->
            {none, Operators, Values};

        {_, _, _} ->
            erlang:error(#{gleam_error => panic,
                    message => <<"parser bug, expression not full reduced"/utf8>>,
                    module => <<"glance"/utf8>>,
                    function => <<"handle_operator"/utf8>>,
                    line => 1029})
    end.

-file("src/glance.gleam", 1499).
-spec list(
    fun((list({glexer@token:token(), glexer:position()})) -> {ok,
            {ICW, list({glexer@token:token(), glexer:position()})}} |
        {error, error()}),
    gleam@option:option(ICW),
    list(ICW),
    list({glexer@token:token(), glexer:position()})
) -> {ok,
        {list(ICW),
            gleam@option:option(ICW),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
list(Parser, Discard, Acc, Tokens) ->
    case Tokens of
        [{right_square, _} | Tokens@1] ->
            {ok, {lists:reverse(Acc), none, Tokens@1}};

        [{comma, _}, {right_square, _} | Tokens@2] when Acc =/= [] ->
            {ok, {lists:reverse(Acc), none, Tokens@2}};

        [{dot_dot, _}, {right_square, _} = Close | Tokens@3] ->
            case Discard of
                none ->
                    unexpected_error([Close | Tokens@3]);

                {some, Discard@1} ->
                    {ok, {lists:reverse(Acc), {some, Discard@1}, Tokens@3}}
            end;

        [{dot_dot, _} | Tokens@4] ->
            gleam@result:'try'(
                Parser(Tokens@4),
                fun(_use0) ->
                    {Rest, Tokens@5} = _use0,
                    expect(
                        right_square,
                        Tokens@5,
                        fun(_, Tokens@6) ->
                            {ok, {lists:reverse(Acc), {some, Rest}, Tokens@6}}
                        end
                    )
                end
            );

        _ ->
            gleam@result:'try'(
                Parser(Tokens),
                fun(_use0@1) ->
                    {Element, Tokens@7} = _use0@1,
                    Acc@1 = [Element | Acc],
                    case Tokens@7 of
                        [{right_square, _} | Tokens@8] ->
                            {ok, {lists:reverse(Acc@1), none, Tokens@8}};

                        [{comma, _}, {right_square, _} | Tokens@8] ->
                            {ok, {lists:reverse(Acc@1), none, Tokens@8}};

                        [{comma, _},
                            {dot_dot, _},
                            {right_square, _} = Close@1 |
                            Tokens@9] ->
                            case Discard of
                                none ->
                                    unexpected_error([Close@1 | Tokens@9]);

                                {some, Discard@2} ->
                                    {ok,
                                        {lists:reverse(Acc@1),
                                            {some, Discard@2},
                                            Tokens@9}}
                            end;

                        [{comma, _}, {dot_dot, _} | Tokens@10] ->
                            gleam@result:'try'(
                                Parser(Tokens@10),
                                fun(_use0@2) ->
                                    {Rest@1, Tokens@11} = _use0@2,
                                    expect(
                                        right_square,
                                        Tokens@11,
                                        fun(_, Tokens@12) ->
                                            {ok,
                                                {lists:reverse(Acc@1),
                                                    {some, Rest@1},
                                                    Tokens@12}}
                                        end
                                    )
                                end
                            );

                        [{comma, _} | Tokens@13] ->
                            list(Parser, Discard, Acc@1, Tokens@13);

                        [{Other, Position} | _] ->
                            {error, {unexpected_token, Other, Position}};

                        [] ->
                            {error, unexpected_end_of_input}
                    end
                end
            )
    end.

-file("src/glance.gleam", 331).
-spec push_constant(module_(), list(attribute()), constant()) -> module_().
push_constant(Module, Attributes, Constant) ->
    _record = Module,
    {module,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        [{definition, lists:reverse(Attributes), Constant} |
            erlang:element(5, Module)],
        erlang:element(6, _record)}.

-file("src/glance.gleam", 342).
-spec push_function(module_(), list(attribute()), function_()) -> module_().
push_function(Module, Attributes, Function) ->
    _record = Module,
    {module,
        erlang:element(2, _record),
        erlang:element(3, _record),
        erlang:element(4, _record),
        erlang:element(5, _record),
        [{definition, lists:reverse(Attributes), Function} |
            erlang:element(6, Module)]}.

-file("src/glance.gleam", 353).
-spec push_custom_type(module_(), list(attribute()), custom_type()) -> module_().
push_custom_type(Module, Attributes, Custom_type) ->
    Custom_type@1 = begin
        _record = Custom_type,
        {custom_type,
            erlang:element(2, _record),
            erlang:element(3, _record),
            erlang:element(4, _record),
            erlang:element(5, _record),
            erlang:element(6, _record),
            lists:reverse(erlang:element(7, Custom_type))}
    end,
    _record@1 = Module,
    {module,
        erlang:element(2, _record@1),
        [{definition, lists:reverse(Attributes), Custom_type@1} |
            erlang:element(3, Module)],
        erlang:element(4, _record@1),
        erlang:element(5, _record@1),
        erlang:element(6, _record@1)}.

-file("src/glance.gleam", 366).
-spec push_type_alias(module_(), list(attribute()), type_alias()) -> module_().
push_type_alias(Module, Attributes, Type_alias) ->
    _record = Module,
    {module,
        erlang:element(2, _record),
        erlang:element(3, _record),
        [{definition, lists:reverse(Attributes), Type_alias} |
            erlang:element(4, Module)],
        erlang:element(5, _record),
        erlang:element(6, _record)}.

-file("src/glance.gleam", 575).
-spec unqualified_imports(
    list(unqualified_import()),
    list(unqualified_import()),
    list({glexer@token:token(), glexer:position()})
) -> {ok,
        {list(unqualified_import()),
            list(unqualified_import()),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
unqualified_imports(Types, Values, Tokens) ->
    case Tokens of
        [] ->
            {error, unexpected_end_of_input};

        [{right_brace, _} | Tokens@1] ->
            {ok, {lists:reverse(Types), lists:reverse(Values), Tokens@1}};

        [{{upper_name, Name}, _},
            {as, _},
            {{upper_name, Alias}, _},
            {comma, _} |
            Tokens@2] ->
            Import_ = {unqualified_import, Name, {some, Alias}},
            unqualified_imports(Types, [Import_ | Values], Tokens@2);

        [{{name, Name}, _}, {as, _}, {{name, Alias}, _}, {comma, _} | Tokens@2] ->
            Import_ = {unqualified_import, Name, {some, Alias}},
            unqualified_imports(Types, [Import_ | Values], Tokens@2);

        [{{upper_name, Name@1}, _},
            {as, _},
            {{upper_name, Alias@1}, _},
            {right_brace, _} |
            Tokens@3] ->
            Import_@1 = {unqualified_import, Name@1, {some, Alias@1}},
            {ok,
                {lists:reverse(Types),
                    lists:reverse([Import_@1 | Values]),
                    Tokens@3}};

        [{{name, Name@1}, _},
            {as, _},
            {{name, Alias@1}, _},
            {right_brace, _} |
            Tokens@3] ->
            Import_@1 = {unqualified_import, Name@1, {some, Alias@1}},
            {ok,
                {lists:reverse(Types),
                    lists:reverse([Import_@1 | Values]),
                    Tokens@3}};

        [{{upper_name, Name@2}, _}, {comma, _} | Tokens@4] ->
            Import_@2 = {unqualified_import, Name@2, none},
            unqualified_imports(Types, [Import_@2 | Values], Tokens@4);

        [{{name, Name@2}, _}, {comma, _} | Tokens@4] ->
            Import_@2 = {unqualified_import, Name@2, none},
            unqualified_imports(Types, [Import_@2 | Values], Tokens@4);

        [{{upper_name, Name@3}, _}, {right_brace, _} | Tokens@5] ->
            Import_@3 = {unqualified_import, Name@3, none},
            {ok,
                {lists:reverse(Types),
                    lists:reverse([Import_@3 | Values]),
                    Tokens@5}};

        [{{name, Name@3}, _}, {right_brace, _} | Tokens@5] ->
            Import_@3 = {unqualified_import, Name@3, none},
            {ok,
                {lists:reverse(Types),
                    lists:reverse([Import_@3 | Values]),
                    Tokens@5}};

        [{type, _},
            {{upper_name, Name@4}, _},
            {as, _},
            {{upper_name, Alias@2}, _},
            {comma, _} |
            Tokens@6] ->
            Import_@4 = {unqualified_import, Name@4, {some, Alias@2}},
            unqualified_imports([Import_@4 | Types], Values, Tokens@6);

        [{type, _},
            {{upper_name, Name@5}, _},
            {as, _},
            {{upper_name, Alias@3}, _},
            {right_brace, _} |
            Tokens@7] ->
            Import_@5 = {unqualified_import, Name@5, {some, Alias@3}},
            {ok,
                {lists:reverse([Import_@5 | Types]),
                    lists:reverse(Values),
                    Tokens@7}};

        [{type, _}, {{upper_name, Name@6}, _}, {comma, _} | Tokens@8] ->
            Import_@6 = {unqualified_import, Name@6, none},
            unqualified_imports([Import_@6 | Types], Values, Tokens@8);

        [{type, _}, {{upper_name, Name@7}, _}, {right_brace, _} | Tokens@9] ->
            Import_@7 = {unqualified_import, Name@7, none},
            {ok,
                {lists:reverse([Import_@7 | Types]),
                    lists:reverse(Values),
                    Tokens@9}};

        [{Other, Position} | _] ->
            {error, {unexpected_token, Other, Position}}
    end.

-file("src/glance.gleam", 565).
-spec optional_unqualified_imports(
    list({glexer@token:token(), glexer:position()})
) -> {ok,
        {list(unqualified_import()),
            list(unqualified_import()),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
optional_unqualified_imports(Tokens) ->
    case Tokens of
        [{dot, _}, {left_brace, _} | Tokens@1] ->
            unqualified_imports([], [], Tokens@1);

        _ ->
            {ok, {[], [], Tokens}}
    end.

-file("src/glance.gleam", 515).
-spec import_statement(
    module_(),
    list(attribute()),
    list({glexer@token:token(), glexer:position()}),
    integer()
) -> {ok, {module_(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
import_statement(Module, Attributes, Tokens, Start) ->
    gleam@result:'try'(
        module_name(<<""/utf8>>, 0, Tokens),
        fun(_use0) ->
            {Module_name, End, Tokens@1} = _use0,
            gleam@result:'try'(
                optional_unqualified_imports(Tokens@1),
                fun(_use0@1) ->
                    {Ts, Vs, Tokens@2} = _use0@1,
                    {Alias, Tokens@3} = optional_module_alias(Tokens@2),
                    Span = {span, Start, End},
                    Import_ = {import, Span, Module_name, Alias, Ts, Vs},
                    Definition = {definition,
                        lists:reverse(Attributes),
                        Import_},
                    Module@1 = begin
                        _record = Module,
                        {module,
                            [Definition | erlang:element(2, Module)],
                            erlang:element(3, _record),
                            erlang:element(4, _record),
                            erlang:element(5, _record),
                            erlang:element(6, _record)}
                    end,
                    {ok, {Module@1, Tokens@3}}
                end
            )
        end
    ).

-file("src/glance.gleam", 1167).
-spec bit_string_segment_options(
    fun((list({glexer@token:token(), glexer:position()})) -> {ok,
            {IAT, list({glexer@token:token(), glexer:position()})}} |
        {error, error()}),
    list(bit_string_segment_option(IAT)),
    list({glexer@token:token(), glexer:position()})
) -> {ok,
        {list(bit_string_segment_option(IAT)),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
bit_string_segment_options(Parser, Options, Tokens) ->
    gleam@result:'try'(case Tokens of
            [{{int, I}, Position} | Tokens@1] ->
                case gleam_stdlib:parse_int(I) of
                    {ok, I@1} ->
                        {ok, {{size_option, I@1}, Tokens@1}};

                    {error, _} ->
                        {error, {unexpected_token, {int, I}, Position}}
                end;

            [{{name, <<"size"/utf8>>}, _}, {left_paren, _} | Tokens@2] ->
                gleam@result:'try'(
                    Parser(Tokens@2),
                    fun(_use0) ->
                        {Value, Tokens@3} = _use0,
                        expect(
                            right_paren,
                            Tokens@3,
                            fun(_, Tokens@4) ->
                                {ok, {{size_value_option, Value}, Tokens@4}}
                            end
                        )
                    end
                );

            [{{name, <<"unit"/utf8>>}, Position@1},
                {left_paren, _},
                {{int, I@2}, _},
                {right_paren, _} |
                Tokens@5] ->
                case gleam_stdlib:parse_int(I@2) of
                    {ok, I@3} ->
                        {ok, {{unit_option, I@3}, Tokens@5}};

                    {error, _} ->
                        {error, {unexpected_token, {int, I@2}, Position@1}}
                end;

            [{{name, <<"bytes"/utf8>>}, _} | Tokens@6] ->
                {ok, {bytes_option, Tokens@6}};

            [{{name, <<"binary"/utf8>>}, _} | Tokens@7] ->
                {ok, {bytes_option, Tokens@7}};

            [{{name, <<"int"/utf8>>}, _} | Tokens@8] ->
                {ok, {int_option, Tokens@8}};

            [{{name, <<"float"/utf8>>}, _} | Tokens@9] ->
                {ok, {float_option, Tokens@9}};

            [{{name, <<"bits"/utf8>>}, _} | Tokens@10] ->
                {ok, {bits_option, Tokens@10}};

            [{{name, <<"bit_string"/utf8>>}, _} | Tokens@11] ->
                {ok, {bits_option, Tokens@11}};

            [{{name, <<"utf8"/utf8>>}, _} | Tokens@12] ->
                {ok, {utf8_option, Tokens@12}};

            [{{name, <<"utf16"/utf8>>}, _} | Tokens@13] ->
                {ok, {utf16_option, Tokens@13}};

            [{{name, <<"utf32"/utf8>>}, _} | Tokens@14] ->
                {ok, {utf32_option, Tokens@14}};

            [{{name, <<"utf8_codepoint"/utf8>>}, _} | Tokens@15] ->
                {ok, {utf8_codepoint_option, Tokens@15}};

            [{{name, <<"utf16_codepoint"/utf8>>}, _} | Tokens@16] ->
                {ok, {utf16_codepoint_option, Tokens@16}};

            [{{name, <<"utf32_codepoint"/utf8>>}, _} | Tokens@17] ->
                {ok, {utf32_codepoint_option, Tokens@17}};

            [{{name, <<"signed"/utf8>>}, _} | Tokens@18] ->
                {ok, {signed_option, Tokens@18}};

            [{{name, <<"unsigned"/utf8>>}, _} | Tokens@19] ->
                {ok, {unsigned_option, Tokens@19}};

            [{{name, <<"big"/utf8>>}, _} | Tokens@20] ->
                {ok, {big_option, Tokens@20}};

            [{{name, <<"little"/utf8>>}, _} | Tokens@21] ->
                {ok, {little_option, Tokens@21}};

            [{{name, <<"native"/utf8>>}, _} | Tokens@22] ->
                {ok, {native_option, Tokens@22}};

            [{Other, Position@2} | _] ->
                {error, {unexpected_token, Other, Position@2}};

            [] ->
                {error, unexpected_end_of_input}
        end, fun(_use0@1) ->
            {Option, Tokens@23} = _use0@1,
            Options@1 = [Option | Options],
            case Tokens@23 of
                [{minus, _} | Tokens@24] ->
                    bit_string_segment_options(Parser, Options@1, Tokens@24);

                _ ->
                    {ok, {lists:reverse(Options@1), Tokens@23}}
            end
        end).

-file("src/glance.gleam", 1157).
-spec optional_bit_string_segment_options(
    fun((list({glexer@token:token(), glexer:position()})) -> {ok,
            {IAM, list({glexer@token:token(), glexer:position()})}} |
        {error, error()}),
    list({glexer@token:token(), glexer:position()})
) -> {ok,
        {list(bit_string_segment_option(IAM)),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
optional_bit_string_segment_options(Parser, Tokens) ->
    case Tokens of
        [{colon, _} | Tokens@1] ->
            bit_string_segment_options(Parser, [], Tokens@1);

        _ ->
            {ok, {[], Tokens}}
    end.

-file("src/glance.gleam", 1147).
-spec bit_string_segment(
    fun((list({glexer@token:token(), glexer:position()})) -> {ok,
            {IAF, list({glexer@token:token(), glexer:position()})}} |
        {error, error()}),
    list({glexer@token:token(), glexer:position()})
) -> {ok,
        {{IAF, list(bit_string_segment_option(IAF))},
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
bit_string_segment(Parser, Tokens) ->
    gleam@result:'try'(
        Parser(Tokens),
        fun(_use0) ->
            {Value, Tokens@1} = _use0,
            Result = optional_bit_string_segment_options(Parser, Tokens@1),
            gleam@result:'try'(
                Result,
                fun(_use0@1) ->
                    {Options, Tokens@2} = _use0@1,
                    {ok, {{Value, Options}, Tokens@2}}
                end
            )
        end
    ).

-file("src/glance.gleam", 1468).
-spec delimited(
    list(ICM),
    list({glexer@token:token(), glexer:position()}),
    fun((list({glexer@token:token(), glexer:position()})) -> {ok,
            {ICM, list({glexer@token:token(), glexer:position()})}} |
        {error, error()}),
    glexer@token:token()
) -> {ok, {list(ICM), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
delimited(Acc, Tokens, Parser, Delimeter) ->
    gleam@result:'try'(
        Parser(Tokens),
        fun(_use0) ->
            {T, Tokens@1} = _use0,
            Acc@1 = [T | Acc],
            case Tokens@1 of
                [{Token, _} | Tokens@2] when Token =:= Delimeter ->
                    delimited(Acc@1, Tokens@2, Parser, Delimeter);

                _ ->
                    {ok, {lists:reverse(Acc@1), Tokens@1}}
            end
        end
    ).

-file("src/glance.gleam", 1628).
-spec comma_delimited(
    list(IDP),
    list({glexer@token:token(), glexer:position()}),
    fun((list({glexer@token:token(), glexer:position()})) -> {ok,
            {IDP, list({glexer@token:token(), glexer:position()})}} |
        {error, error()}),
    glexer@token:token()
) -> {ok,
        {list(IDP), integer(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
comma_delimited(Items, Tokens, Parser, Final) ->
    case Tokens of
        [] ->
            {error, unexpected_end_of_input};

        [{Token, {position, I}} | Tokens@1] when Token =:= Final ->
            {ok, {lists:reverse(Items), I, Tokens@1}};

        _ ->
            gleam@result:'try'(
                Parser(Tokens),
                fun(_use0) ->
                    {Element, Tokens@2} = _use0,
                    case Tokens@2 of
                        [{comma, _} | Tokens@3] ->
                            comma_delimited(
                                [Element | Items],
                                Tokens@3,
                                Parser,
                                Final
                            );

                        [{Token@1, {position, I@1}} | Tokens@4] when Token@1 =:= Final ->
                            {ok,
                                {lists:reverse([Element | Items]),
                                    I@1,
                                    Tokens@4}};

                        [{Other, Position} | _] ->
                            {error, {unexpected_token, Other, Position}};

                        [] ->
                            {error, unexpected_end_of_input}
                    end
                end
            )
    end.

-file("src/glance.gleam", 1814).
-spec name(list({glexer@token:token(), glexer:position()})) -> {ok,
        {binary(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
name(Tokens) ->
    case Tokens of
        [] ->
            {error, unexpected_end_of_input};

        [{{name, Name}, _} | Tokens@1] ->
            {ok, {Name, Tokens@1}};

        [{Token, Position} | _] ->
            {error, {unexpected_token, Token, Position}}
    end.

-file("src/glance.gleam", 1869).
-spec field(
    list({glexer@token:token(), glexer:position()}),
    fun((list({glexer@token:token(), glexer:position()})) -> {ok,
            {IFA, list({glexer@token:token(), glexer:position()})}} |
        {error, error()})
) -> {ok, {field(IFA), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
field(Tokens, Parser) ->
    case Tokens of
        [{{name, Name}, _}, {colon, _} | Tokens@1] ->
            case Tokens@1 of
                [{comma, _} | _] ->
                    {ok, {{shorthand_field, Name}, Tokens@1}};

                [{right_paren, _} | _] ->
                    {ok, {{shorthand_field, Name}, Tokens@1}};

                _ ->
                    gleam@result:'try'(
                        Parser(Tokens@1),
                        fun(_use0) ->
                            {T, Tokens@2} = _use0,
                            {ok, {{labelled_field, Name, T}, Tokens@2}}
                        end
                    )
            end;

        _ ->
            gleam@result:'try'(
                Parser(Tokens),
                fun(_use0@1) ->
                    {T@1, Tokens@3} = _use0@1,
                    {ok, {{unlabelled_field, T@1}, Tokens@3}}
                end
            )
    end.

-file("src/glance.gleam", 736).
-spec statement(list({glexer@token:token(), glexer:position()})) -> {ok,
        {statement(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
statement(Tokens) ->
    case Tokens of
        [{'let', _}, {assert, _} | Tokens@1] ->
            assignment({let_assert, none}, Tokens@1);

        [{'let', _} | Tokens@2] ->
            assignment('let', Tokens@2);

        [{use, _} | Tokens@3] ->
            use_(Tokens@3);

        [{assert, _} | Tokens@4] ->
            assert_(Tokens@4);

        Tokens@5 ->
            gleam@result:'try'(
                expression(Tokens@5),
                fun(_use0) ->
                    {Expression, Tokens@6} = _use0,
                    {ok, {{expression, Expression}, Tokens@6}}
                end
            )
    end.

-file("src/glance.gleam", 918).
-spec expression(list({glexer@token:token(), glexer:position()})) -> {ok,
        {expression(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
expression(Tokens) ->
    expression_loop(Tokens, [], [], regular_expression_unit).

-file("src/glance.gleam", 968).
-spec expression_loop(
    list({glexer@token:token(), glexer:position()}),
    list(binary_operator()),
    list(expression()),
    parse_expression_unit_context()
) -> {ok, {expression(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
expression_loop(Tokens, Operators, Values, Context) ->
    gleam@result:'try'(
        expression_unit(Tokens, Context),
        fun(_use0) ->
            {Expression, Tokens@1} = _use0,
            case Expression of
                none ->
                    unexpected_error(Tokens@1);

                {some, E} ->
                    Values@1 = [E | Values],
                    case pop_binary_operator(Tokens@1) of
                        {ok, {Operator, Tokens@2}} ->
                            case handle_operator(
                                {some, Operator},
                                Operators,
                                Values@1
                            ) of
                                {{some, Expression@1}, _, _} ->
                                    {ok, {Expression@1, Tokens@2}};

                                {none, Operators@1, Values@2} ->
                                    expression_loop(
                                        Tokens@2,
                                        Operators@1,
                                        Values@2,
                                        case Operator of
                                            pipe ->
                                                expression_unit_after_pipe;

                                            _ ->
                                                regular_expression_unit
                                        end
                                    )
                            end;

                        _ ->
                            case erlang:element(
                                1,
                                handle_operator(none, Operators, Values@1)
                            ) of
                                none ->
                                    unexpected_error(Tokens@1);

                                {some, Expression@2} ->
                                    {ok, {Expression@2, Tokens@1}}
                            end
                    end
            end
        end
    ).

-file("src/glance.gleam", 1038).
-spec expression_unit(
    list({glexer@token:token(), glexer:position()}),
    parse_expression_unit_context()
) -> {ok,
        {gleam@option:option(expression()),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
expression_unit(Tokens, Context) ->
    gleam@result:'try'(case Tokens of
            [{{name, Module}, _},
                {dot, _},
                {{upper_name, Constructor}, _},
                {left_paren, _},
                {dot_dot, _} |
                Tokens@1] ->
                record_update({some, Module}, Constructor, Tokens@1);

            [{{upper_name, Constructor@1}, _},
                {left_paren, _},
                {dot_dot, _} |
                Tokens@2] ->
                record_update(none, Constructor@1, Tokens@2);

            [{{upper_name, Name}, _} | Tokens@3] ->
                {ok, {{some, {variable, Name}}, Tokens@3}};

            [{{int, Value}, _} | Tokens@4] ->
                {ok, {{some, {int, Value}}, Tokens@4}};

            [{{float, Value@1}, _} | Tokens@5] ->
                {ok, {{some, {float, Value@1}}, Tokens@5}};

            [{{string, Value@2}, _} | Tokens@6] ->
                {ok, {{some, {string, Value@2}}, Tokens@6}};

            [{{name, Name@1}, _} | Tokens@7] ->
                {ok, {{some, {variable, Name@1}}, Tokens@7}};

            [{fn, _} | Tokens@8] ->
                fn_(Tokens@8);

            [{'case', _} | Tokens@9] ->
                case_(Tokens@9);

            [{panic, _} | Tokens@10] ->
                todo_panic(Tokens@10, fun(Field@0) -> {panic, Field@0} end);

            [{todo, _} | Tokens@11] ->
                todo_panic(Tokens@11, fun(Field@0) -> {todo, Field@0} end);

            [{left_square, _} | Tokens@12] ->
                Result = list(fun expression/1, none, [], Tokens@12),
                gleam@result:map(
                    Result,
                    fun(_use0) ->
                        {Elements, Rest, Tokens@13} = _use0,
                        {{some, {list, Elements, Rest}}, Tokens@13}
                    end
                );

            [{hash, _}, {left_paren, _} | Tokens@14] ->
                Result@1 = comma_delimited(
                    [],
                    Tokens@14,
                    fun expression/1,
                    right_paren
                ),
                gleam@result:map(
                    Result@1,
                    fun(_use0@1) ->
                        {Expressions, _, Tokens@15} = _use0@1,
                        {{some, {tuple, Expressions}}, Tokens@15}
                    end
                );

            [{bang, _} | Tokens@16] ->
                gleam@result:map(
                    expression(Tokens@16),
                    fun(_use0@2) ->
                        {Expression, Tokens@17} = _use0@2,
                        {{some, {negate_bool, Expression}}, Tokens@17}
                    end
                );

            [{minus, _} | Tokens@18] ->
                gleam@result:map(
                    expression(Tokens@18),
                    fun(_use0@3) ->
                        {Expression@1, Tokens@19} = _use0@3,
                        Expression@2 = case Expression@1 of
                            {float, Amount} ->
                                {float, <<"-"/utf8, Amount/binary>>};

                            _ ->
                                {negate_int, Expression@1}
                        end,
                        {{some, Expression@2}, Tokens@19}
                    end
                );

            [{left_brace, _} | Tokens@20] ->
                gleam@result:map(
                    statements([], Tokens@20),
                    fun(_use0@4) ->
                        {Statements, _, Tokens@21} = _use0@4,
                        {{some, {block, Statements}}, Tokens@21}
                    end
                );

            [{less_less, _} | Tokens@22] ->
                Parser = fun(_capture) ->
                    bit_string_segment(fun expression/1, _capture)
                end,
                Result@2 = comma_delimited(
                    [],
                    Tokens@22,
                    Parser,
                    greater_greater
                ),
                gleam@result:map(
                    Result@2,
                    fun(_use0@5) ->
                        {Segments, _, Tokens@23} = _use0@5,
                        {{some, {bit_string, Segments}}, Tokens@23}
                    end
                );

            [{echo, _} | Tokens@24] ->
                case Context of
                    expression_unit_after_pipe ->
                        {ok, {{some, {echo, none}}, Tokens@24}};

                    regular_expression_unit ->
                        gleam@result:map(
                            expression(Tokens@24),
                            fun(Expression_and_tokens) ->
                                {Expression@3, Tokens@25} = Expression_and_tokens,
                                {{some, {echo, {some, Expression@3}}},
                                    Tokens@25}
                            end
                        )
                end;

            _ ->
                {ok, {none, Tokens}}
        end, fun(_use0@6) ->
            {Parsed, Tokens@26} = _use0@6,
            case Parsed of
                {some, Expression@4} ->
                    case after_expression(Expression@4, Tokens@26) of
                        {ok, {Expression@5, Tokens@27}} ->
                            {ok, {{some, Expression@5}, Tokens@27}};

                        {error, Error} ->
                            {error, Error}
                    end;

                none ->
                    {ok, {none, Tokens@26}}
            end
        end).

-file("src/glance.gleam", 722).
-spec statements(
    list(statement()),
    list({glexer@token:token(), glexer:position()})
) -> {ok,
        {list(statement()),
            integer(),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
statements(Acc, Tokens) ->
    case Tokens of
        [{right_brace, {position, End}} | Tokens@1] ->
            {ok, {lists:reverse(Acc), End + 1, Tokens@1}};

        _ ->
            gleam@result:'try'(
                statement(Tokens),
                fun(_use0) ->
                    {Statement, Tokens@2} = _use0,
                    statements([Statement | Acc], Tokens@2)
                end
            )
    end.

-file("src/glance.gleam", 434).
-spec attribute(list({glexer@token:token(), glexer:position()})) -> {ok,
        {attribute(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
attribute(Tokens) ->
    gleam@result:'try'(case Tokens of
            [{{name, Name}, _} | Tokens@1] ->
                {ok, {Name, Tokens@1}};

            [{Other, Position} | _] ->
                {error, {unexpected_token, Other, Position}};

            [] ->
                {error, unexpected_end_of_input}
        end, fun(_use0) ->
            {Name@1, Tokens@2} = _use0,
            case Tokens@2 of
                [{left_paren, _} | Tokens@3] ->
                    Result = comma_delimited(
                        [],
                        Tokens@3,
                        fun expression/1,
                        right_paren
                    ),
                    gleam@result:'try'(
                        Result,
                        fun(_use0@1) ->
                            {Parameters, _, Tokens@4} = _use0@1,
                            {ok, {{attribute, Name@1, Parameters}, Tokens@4}}
                        end
                    );

                _ ->
                    {ok, {{attribute, Name@1, []}, Tokens@2}}
            end
        end).

-file("src/glance.gleam", 750).
-spec assert_(list({glexer@token:token(), glexer:position()})) -> {ok,
        {statement(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
assert_(Tokens) ->
    gleam@result:'try'(
        expression(Tokens),
        fun(_use0) ->
            {Subject, Tokens@1} = _use0,
            case Tokens@1 of
                [{as, _} | Tokens@2] ->
                    case expression(Tokens@2) of
                        {error, Error} ->
                            {error, Error};

                        {ok, {Message, Tokens@3}} ->
                            {ok, {{assert, Subject, {some, Message}}, Tokens@3}}
                    end;

                _ ->
                    {ok, {{assert, Subject, none}, Tokens@1}}
            end
        end
    ).

-file("src/glance.gleam", 1134).
-spec todo_panic(
    list({glexer@token:token(), glexer:position()}),
    fun((gleam@option:option(expression())) -> expression())
) -> {ok,
        {gleam@option:option(expression()),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
todo_panic(Tokens, Constructor) ->
    case Tokens of
        [{as, _} | Tokens@1] ->
            gleam@result:'try'(
                expression(Tokens@1),
                fun(_use0) ->
                    {Reason, Tokens@2} = _use0,
                    {ok, {{some, Constructor({some, Reason})}, Tokens@2}}
                end
            );

        _ ->
            {ok, {{some, Constructor(none)}, Tokens}}
    end.

-file("src/glance.gleam", 1395).
-spec record_update_field(list({glexer@token:token(), glexer:position()})) -> {ok,
        {record_update_field(expression()),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
record_update_field(Tokens) ->
    case Tokens of
        [{{name, Name}, _}, {colon, _} | Tokens@1] ->
            case Tokens@1 of
                [{comma, _} | _] ->
                    {ok, {{record_update_field, Name, none}, Tokens@1}};

                [{right_paren, _} | _] ->
                    {ok, {{record_update_field, Name, none}, Tokens@1}};

                _ ->
                    gleam@result:'try'(
                        expression(Tokens@1),
                        fun(_use0) ->
                            {Expression, Tokens@2} = _use0,
                            {ok,
                                {{record_update_field, Name, {some, Expression}},
                                    Tokens@2}}
                        end
                    )
            end;

        [{Other, Position} | _] ->
            {error, {unexpected_token, Other, Position}};

        [] ->
            {error, unexpected_end_of_input}
    end.

-file("src/glance.gleam", 1374).
-spec record_update(
    gleam@option:option(binary()),
    binary(),
    list({glexer@token:token(), glexer:position()})
) -> {ok,
        {gleam@option:option(expression()),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
record_update(Module, Constructor, Tokens) ->
    gleam@result:'try'(
        expression(Tokens),
        fun(_use0) ->
            {Record, Tokens@1} = _use0,
            case Tokens@1 of
                [{right_paren, _} | Tokens@2] ->
                    {ok,
                        {{some,
                                {record_update, Module, Constructor, Record, []}},
                            Tokens@2}};

                [{comma, _} | Tokens@3] ->
                    Result = comma_delimited(
                        [],
                        Tokens@3,
                        fun record_update_field/1,
                        right_paren
                    ),
                    gleam@result:'try'(
                        Result,
                        fun(_use0@1) ->
                            {Fields, _, Tokens@4} = _use0@1,
                            {ok,
                                {{some,
                                        {record_update,
                                            Module,
                                            Constructor,
                                            Record,
                                            Fields}},
                                    Tokens@4}}
                        end
                    );

                _ ->
                    {ok, {none, Tokens@1}}
            end
        end
    ).

-file("src/glance.gleam", 1422).
-spec case_subjects(
    list(expression()),
    list({glexer@token:token(), glexer:position()})
) -> {ok, {list(expression()), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
case_subjects(Subjects, Tokens) ->
    gleam@result:'try'(
        expression(Tokens),
        fun(_use0) ->
            {Subject, Tokens@1} = _use0,
            Subjects@1 = [Subject | Subjects],
            case Tokens@1 of
                [{comma, _} | Tokens@2] ->
                    case_subjects(Subjects@1, Tokens@2);

                _ ->
                    {ok, {lists:reverse(Subjects@1), Tokens@1}}
            end
        end
    ).

-file("src/glance.gleam", 1456).
-spec optional_clause_guard(list({glexer@token:token(), glexer:position()})) -> {ok,
        {gleam@option:option(expression()),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
optional_clause_guard(Tokens) ->
    case Tokens of
        [{'if', _} | Tokens@1] ->
            gleam@result:'try'(
                expression(Tokens@1),
                fun(_use0) ->
                    {Expression, Tokens@2} = _use0,
                    {ok, {{some, Expression}, Tokens@2}}
                end
            );

        _ ->
            {ok, {none, Tokens}}
    end.

-file("src/glance.gleam", 1840).
-spec attributes(
    list(attribute()),
    list({glexer@token:token(), glexer:position()})
) -> {ok, {list(attribute()), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
attributes(Accumulated_attributes, Tokens) ->
    case Tokens of
        [{at, _} | Tokens@1] ->
            case attribute(Tokens@1) of
                {error, Error} ->
                    {error, Error};

                {ok, {Attribute, Tokens@2}} ->
                    attributes([Attribute | Accumulated_attributes], Tokens@2)
            end;

        _ ->
            {ok, {lists:reverse(Accumulated_attributes), Tokens}}
    end.

-file("src/glance.gleam", 1264).
-spec call(
    list(field(expression())),
    expression(),
    list({glexer@token:token(), glexer:position()})
) -> {ok, {expression(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
call(Arguments, Function, Tokens) ->
    case Tokens of
        [] ->
            {error, unexpected_end_of_input};

        [{right_paren, _} | Tokens@1] ->
            Call = {call, Function, lists:reverse(Arguments)},
            after_expression(Call, Tokens@1);

        [{{name, Label}, _},
            {colon, _},
            {{discard_name, <<""/utf8>>}, _},
            {comma, _},
            {right_paren, _} |
            Tokens@2] ->
            Capture = {fn_capture,
                {some, Label},
                Function,
                lists:reverse(Arguments),
                []},
            after_expression(Capture, Tokens@2);

        [{{name, Label}, _},
            {colon, _},
            {{discard_name, <<""/utf8>>}, _},
            {right_paren, _} |
            Tokens@2] ->
            Capture = {fn_capture,
                {some, Label},
                Function,
                lists:reverse(Arguments),
                []},
            after_expression(Capture, Tokens@2);

        [{{name, Label@1}, _},
            {colon, _},
            {{discard_name, <<""/utf8>>}, _},
            {comma, _} |
            Tokens@3] ->
            fn_capture(
                {some, Label@1},
                Function,
                lists:reverse(Arguments),
                [],
                Tokens@3
            );

        [{{name, Label@1}, _},
            {colon, _},
            {{discard_name, <<""/utf8>>}, _} |
            Tokens@3] ->
            fn_capture(
                {some, Label@1},
                Function,
                lists:reverse(Arguments),
                [],
                Tokens@3
            );

        [{{discard_name, <<""/utf8>>}, _},
            {comma, _},
            {right_paren, _} |
            Tokens@4] ->
            Capture@1 = {fn_capture,
                none,
                Function,
                lists:reverse(Arguments),
                []},
            after_expression(Capture@1, Tokens@4);

        [{{discard_name, <<""/utf8>>}, _}, {right_paren, _} | Tokens@4] ->
            Capture@1 = {fn_capture,
                none,
                Function,
                lists:reverse(Arguments),
                []},
            after_expression(Capture@1, Tokens@4);

        [{{discard_name, <<""/utf8>>}, _}, {comma, _} | Tokens@5] ->
            fn_capture(none, Function, lists:reverse(Arguments), [], Tokens@5);

        [{{discard_name, <<""/utf8>>}, _} | Tokens@5] ->
            fn_capture(none, Function, lists:reverse(Arguments), [], Tokens@5);

        _ ->
            gleam@result:'try'(
                field(Tokens, fun expression/1),
                fun(_use0) ->
                    {Argument, Tokens@6} = _use0,
                    Arguments@1 = [Argument | Arguments],
                    case Tokens@6 of
                        [{comma, _} | Tokens@7] ->
                            call(Arguments@1, Function, Tokens@7);

                        [{right_paren, _} | Tokens@8] ->
                            Call@1 = {call,
                                Function,
                                lists:reverse(Arguments@1)},
                            after_expression(Call@1, Tokens@8);

                        [{Other, Position} | _] ->
                            {error, {unexpected_token, Other, Position}};

                        [] ->
                            {error, unexpected_end_of_input}
                    end
                end
            )
    end.

-file("src/glance.gleam", 1236).
-spec after_expression(
    expression(),
    list({glexer@token:token(), glexer:position()})
) -> {ok, {expression(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
after_expression(Parsed, Tokens) ->
    case Tokens of
        [{dot, _}, {{name, Label}, _} | Tokens@1] ->
            after_expression({field_access, Parsed, Label}, Tokens@1);

        [{dot, _}, {{upper_name, Label}, _} | Tokens@1] ->
            after_expression({field_access, Parsed, Label}, Tokens@1);

        [{dot, _}, {{int, Value} = Token, Position} | Tokens@2] ->
            case gleam_stdlib:parse_int(Value) of
                {ok, I} ->
                    after_expression({tuple_index, Parsed, I}, Tokens@2);

                {error, _} ->
                    {error, {unexpected_token, Token, Position}}
            end;

        [{left_paren, _} | Tokens@3] ->
            call([], Parsed, Tokens@3);

        _ ->
            {ok, {Parsed, Tokens}}
    end.

-file("src/glance.gleam", 1339).
-spec fn_capture(
    gleam@option:option(binary()),
    expression(),
    list(field(expression())),
    list(field(expression())),
    list({glexer@token:token(), glexer:position()})
) -> {ok, {expression(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
fn_capture(Label, Function, Before, After, Tokens) ->
    case Tokens of
        [] ->
            {error, unexpected_end_of_input};

        [{right_paren, _} | Tokens@1] ->
            Capture = {fn_capture,
                Label,
                Function,
                Before,
                lists:reverse(After)},
            after_expression(Capture, Tokens@1);

        _ ->
            gleam@result:'try'(
                field(Tokens, fun expression/1),
                fun(_use0) ->
                    {Argument, Tokens@2} = _use0,
                    After@1 = [Argument | After],
                    case Tokens@2 of
                        [{comma, _} | Tokens@3] ->
                            fn_capture(
                                Label,
                                Function,
                                Before,
                                After@1,
                                Tokens@3
                            );

                        [{right_paren, _} | Tokens@4] ->
                            Call = {fn_capture,
                                Label,
                                Function,
                                Before,
                                lists:reverse(After@1)},
                            after_expression(Call, Tokens@4);

                        [{Other, Position} | _] ->
                            {error, {unexpected_token, Other, Position}};

                        [] ->
                            {error, unexpected_end_of_input}
                    end
                end
            )
    end.

-file("src/glance.gleam", 822).
-spec pattern_constructor_arguments(
    list(field(pattern())),
    list({glexer@token:token(), glexer:position()})
) -> {ok,
        {list(field(pattern())),
            boolean(),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
pattern_constructor_arguments(Arguments, Tokens) ->
    case Tokens of
        [{right_paren, _} | Tokens@1] ->
            {ok, {Arguments, false, Tokens@1}};

        [{dot_dot, _}, {comma, _}, {right_paren, _} | Tokens@2] ->
            {ok, {Arguments, true, Tokens@2}};

        [{dot_dot, _}, {right_paren, _} | Tokens@2] ->
            {ok, {Arguments, true, Tokens@2}};

        Tokens@3 ->
            gleam@result:'try'(
                field(Tokens@3, fun pattern/1),
                fun(_use0) ->
                    {Pattern, Tokens@4} = _use0,
                    Arguments@1 = [Pattern | Arguments],
                    case Tokens@4 of
                        [{right_paren, _} | Tokens@5] ->
                            {ok, {Arguments@1, false, Tokens@5}};

                        [{comma, _}, {dot_dot, _}, {right_paren, _} | Tokens@6] ->
                            {ok, {Arguments@1, true, Tokens@6}};

                        [{comma, _} | Tokens@7] ->
                            pattern_constructor_arguments(Arguments@1, Tokens@7);

                        [{Token, Position} | _] ->
                            {error, {unexpected_token, Token, Position}};

                        [] ->
                            {error, unexpected_end_of_input}
                    end
                end
            )
    end.

-file("src/glance.gleam", 853).
-spec pattern(list({glexer@token:token(), glexer:position()})) -> {ok,
        {pattern(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
pattern(Tokens) ->
    gleam@result:'try'(case Tokens of
            [{{upper_name, Name}, _} | Tokens@1] ->
                pattern_constructor(none, Name, Tokens@1);

            [{{name, Module}, _},
                {dot, _},
                {{upper_name, Name@1}, _} |
                Tokens@2] ->
                pattern_constructor({some, Module}, Name@1, Tokens@2);

            [{{string, V}, _},
                {as, _},
                {{name, L}, _},
                {less_greater, _},
                {{name, R}, _} |
                Tokens@3] ->
                {ok,
                    {{pattern_concatenate, V, {some, {named, L}}, {named, R}},
                        Tokens@3}};

            [{{string, V@1}, _},
                {as, _},
                {{discard_name, L@1}, _},
                {less_greater, _},
                {{name, R@1}, _} |
                Tokens@4] ->
                {ok,
                    {{pattern_concatenate,
                            V@1,
                            {some, {discarded, L@1}},
                            {named, R@1}},
                        Tokens@4}};

            [{{string, V@2}, _}, {less_greater, _}, {{name, N}, _} | Tokens@5] ->
                {ok, {{pattern_concatenate, V@2, none, {named, N}}, Tokens@5}};

            [{{string, V@3}, _},
                {less_greater, _},
                {{discard_name, N@1}, _} |
                Tokens@6] ->
                {ok,
                    {{pattern_concatenate, V@3, none, {discarded, N@1}},
                        Tokens@6}};

            [{{int, Value}, _} | Tokens@7] ->
                {ok, {{pattern_int, Value}, Tokens@7}};

            [{{float, Value@1}, _} | Tokens@8] ->
                {ok, {{pattern_float, Value@1}, Tokens@8}};

            [{{string, Value@2}, _} | Tokens@9] ->
                {ok, {{pattern_string, Value@2}, Tokens@9}};

            [{{discard_name, Name@2}, _} | Tokens@10] ->
                {ok, {{pattern_discard, Name@2}, Tokens@10}};

            [{{name, Name@3}, _} | Tokens@11] ->
                {ok, {{pattern_variable, Name@3}, Tokens@11}};

            [{left_square, _} | Tokens@12] ->
                Result = list(
                    fun pattern/1,
                    {some, {pattern_discard, <<""/utf8>>}},
                    [],
                    Tokens@12
                ),
                gleam@result:map(
                    Result,
                    fun(_use0) ->
                        {Elements, Rest, Tokens@13} = _use0,
                        {{pattern_list, Elements, Rest}, Tokens@13}
                    end
                );

            [{hash, _}, {left_paren, _} | Tokens@14] ->
                Result@1 = comma_delimited(
                    [],
                    Tokens@14,
                    fun pattern/1,
                    right_paren
                ),
                gleam@result:'try'(
                    Result@1,
                    fun(_use0@1) ->
                        {Patterns, _, Tokens@15} = _use0@1,
                        {ok, {{pattern_tuple, Patterns}, Tokens@15}}
                    end
                );

            [{less_less, _} | Tokens@16] ->
                Parser = fun(_capture) ->
                    bit_string_segment(fun pattern/1, _capture)
                end,
                Result@2 = comma_delimited(
                    [],
                    Tokens@16,
                    Parser,
                    greater_greater
                ),
                gleam@result:'try'(
                    Result@2,
                    fun(_use0@2) ->
                        {Segments, _, Tokens@17} = _use0@2,
                        {ok, {{pattern_bit_string, Segments}, Tokens@17}}
                    end
                );

            [{Other, Position} | _] ->
                {error, {unexpected_token, Other, Position}};

            [] ->
                {error, unexpected_end_of_input}
        end, fun(_use0@3) ->
            {Pattern, Tokens@18} = _use0@3,
            case Tokens@18 of
                [{as, _}, {{name, Name@4}, _} | Tokens@19] ->
                    {ok, {{pattern_assignment, Pattern, Name@4}, Tokens@19}};

                _ ->
                    {ok, {Pattern, Tokens@18}}
            end
        end).

-file("src/glance.gleam", 802).
-spec pattern_constructor(
    gleam@option:option(binary()),
    binary(),
    list({glexer@token:token(), glexer:position()})
) -> {ok, {pattern(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
pattern_constructor(Module, Constructor, Tokens) ->
    case Tokens of
        [{left_paren, _} | Tokens@1] ->
            Result = pattern_constructor_arguments([], Tokens@1),
            gleam@result:'try'(
                Result,
                fun(_use0) ->
                    {Patterns, Spread, Tokens@2} = _use0,
                    Arguments = lists:reverse(Patterns),
                    Pattern = {pattern_variant,
                        Module,
                        Constructor,
                        Arguments,
                        Spread},
                    {ok, {Pattern, Tokens@2}}
                end
            );

        _ ->
            Pattern@1 = {pattern_variant, Module, Constructor, [], false},
            {ok, {Pattern@1, Tokens}}
    end.

-file("src/glance.gleam", 1446).
-spec case_clause(list({glexer@token:token(), glexer:position()})) -> {ok,
        {clause(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
case_clause(Tokens) ->
    Multipatterns = fun(_capture) ->
        delimited([], _capture, fun pattern/1, comma)
    end,
    Result = delimited([], Tokens, Multipatterns, v_bar),
    gleam@result:'try'(
        Result,
        fun(_use0) ->
            {Patterns, Tokens@1} = _use0,
            gleam@result:'try'(
                optional_clause_guard(Tokens@1),
                fun(_use0@1) ->
                    {Guard, Tokens@2} = _use0@1,
                    expect(
                        right_arrow,
                        Tokens@2,
                        fun(_, Tokens@3) ->
                            gleam@result:map(
                                expression(Tokens@3),
                                fun(_use0@2) ->
                                    {Expression, Tokens@4} = _use0@2,
                                    {{clause, Patterns, Guard, Expression},
                                        Tokens@4}
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glance.gleam", 1434).
-spec case_clauses(
    list(clause()),
    list({glexer@token:token(), glexer:position()})
) -> {ok, {list(clause()), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
case_clauses(Clauses, Tokens) ->
    gleam@result:'try'(
        case_clause(Tokens),
        fun(_use0) ->
            {Clause, Tokens@1} = _use0,
            Clauses@1 = [Clause | Clauses],
            case Tokens@1 of
                [{right_brace, _} | Tokens@2] ->
                    {ok, {lists:reverse(Clauses@1), Tokens@2}};

                _ ->
                    case_clauses(Clauses@1, Tokens@1)
            end
        end
    ).

-file("src/glance.gleam", 1415).
-spec case_(list({glexer@token:token(), glexer:position()})) -> {ok,
        {gleam@option:option(expression()),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
case_(Tokens) ->
    gleam@result:'try'(
        case_subjects([], Tokens),
        fun(_use0) ->
            {Subjects, Tokens@1} = _use0,
            expect(
                left_brace,
                Tokens@1,
                fun(_, Tokens@2) ->
                    gleam@result:'try'(
                        case_clauses([], Tokens@2),
                        fun(_use0@1) ->
                            {Clauses, Tokens@3} = _use0@1,
                            {ok,
                                {{some, {'case', Subjects, Clauses}}, Tokens@3}}
                        end
                    )
                end
            )
        end
    ).

-file("src/glance.gleam", 1758).
-spec named_type(
    binary(),
    gleam@option:option(binary()),
    list({glexer@token:token(), glexer:position()}),
    integer(),
    integer()
) -> {ok, {type(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
named_type(Name, Module, Tokens, Start, Name_start) ->
    gleam@result:'try'(case Tokens of
            [{left_paren, _} | Tokens@1] ->
                comma_delimited([], Tokens@1, fun type_/1, right_paren);

            _ ->
                End = (Name_start + erlang:byte_size(Name)) - 1,
                {ok, {[], End, Tokens}}
        end, fun(_use0) ->
            {Parameters, End@1, Tokens@2} = _use0,
            T = {named_type, {span, Start, End@1 + 1}, Name, Module, Parameters},
            {ok, {T, Tokens@2}}
        end).

-file("src/glance.gleam", 1724).
-spec type_(list({glexer@token:token(), glexer:position()})) -> {ok,
        {type(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
type_(Tokens) ->
    case Tokens of
        [] ->
            {error, unexpected_end_of_input};

        [{fn, {position, I}}, {left_paren, _} | Tokens@1] ->
            fn_type(I, Tokens@1);

        [{hash, {position, I@1}}, {left_paren, _} | Tokens@2] ->
            tuple_type(I@1, Tokens@2);

        [{{name, Module}, {position, Start}},
            {dot, _},
            {{upper_name, Name}, {position, End}} |
            Tokens@3] ->
            named_type(Name, {some, Module}, Tokens@3, Start, End);

        [{{upper_name, Name@1}, {position, Start@1}} | Tokens@4] ->
            named_type(Name@1, none, Tokens@4, Start@1, Start@1);

        [{{discard_name, Name@2}, {position, I@2}} | Tokens@5] ->
            Value = {hole_type,
                {span, I@2, I@2 + erlang:byte_size(Name@2)},
                Name@2},
            {ok, {Value, Tokens@5}};

        [{{name, Name@3}, {position, I@3}} | Tokens@6] ->
            Value@1 = {variable_type,
                {span, I@3, I@3 + erlang:byte_size(Name@3)},
                Name@3},
            {ok, {Value@1, Tokens@6}};

        [{Token, Position} | _] ->
            {error, {unexpected_token, Token, Position}}
    end.

-file("src/glance.gleam", 709).
-spec optional_return_annotation(
    integer(),
    list({glexer@token:token(), glexer:position()})
) -> {ok,
        {gleam@option:option(type()),
            integer(),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
optional_return_annotation(End, Tokens) ->
    case Tokens of
        [{right_arrow, {position, End@1}} | Tokens@1] ->
            gleam@result:'try'(
                type_(Tokens@1),
                fun(_use0) ->
                    {Return_type, Tokens@2} = _use0,
                    {ok, {{some, Return_type}, End@1, Tokens@2}}
                end
            );

        _ ->
            {ok, {none, End, Tokens}}
    end.

-file("src/glance.gleam", 1616).
-spec optional_type_annotation(list({glexer@token:token(), glexer:position()})) -> {ok,
        {gleam@option:option(type()),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
optional_type_annotation(Tokens) ->
    case Tokens of
        [{colon, _} | Tokens@1] ->
            gleam@result:map(
                type_(Tokens@1),
                fun(_use0) ->
                    {Annotation, Tokens@2} = _use0,
                    {{some, Annotation}, Tokens@2}
                end
            );

        _ ->
            {ok, {none, Tokens}}
    end.

-file("src/glance.gleam", 773).
-spec use_pattern(list({glexer@token:token(), glexer:position()})) -> {ok,
        {use_pattern(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
use_pattern(Tokens) ->
    gleam@result:'try'(
        pattern(Tokens),
        fun(_use0) ->
            {Pattern, Tokens@1} = _use0,
            gleam@result:'try'(
                optional_type_annotation(Tokens@1),
                fun(_use0@1) ->
                    {Annotation, Tokens@2} = _use0@1,
                    {ok, {{use_pattern, Pattern, Annotation}, Tokens@2}}
                end
            )
        end
    ).

-file("src/glance.gleam", 762).
-spec use_(list({glexer@token:token(), glexer:position()})) -> {ok,
        {statement(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
use_(Tokens) ->
    gleam@result:'try'(case Tokens of
            [{left_arrow, _} | _] ->
                {ok, {[], Tokens}};

            _ ->
                delimited([], Tokens, fun use_pattern/1, comma)
        end, fun(_use0) ->
            {Patterns, Tokens@1} = _use0,
            expect(
                left_arrow,
                Tokens@1,
                fun(_, Tokens@2) ->
                    gleam@result:'try'(
                        expression(Tokens@2),
                        fun(_use0@1) ->
                            {Function, Tokens@3} = _use0@1,
                            {ok, {{use, Patterns, Function}, Tokens@3}}
                        end
                    )
                end
            )
        end).

-file("src/glance.gleam", 781).
-spec assignment(
    assignment_kind(),
    list({glexer@token:token(), glexer:position()})
) -> {ok, {statement(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
assignment(Kind, Tokens) ->
    gleam@result:'try'(
        pattern(Tokens),
        fun(_use0) ->
            {Pattern, Tokens@1} = _use0,
            gleam@result:'try'(
                optional_type_annotation(Tokens@1),
                fun(_use0@1) ->
                    {Annotation, Tokens@2} = _use0@1,
                    expect(
                        equal,
                        Tokens@2,
                        fun(_, Tokens@3) ->
                            gleam@result:'try'(
                                expression(Tokens@3),
                                fun(_use0@2) ->
                                    {Value, Tokens@4} = _use0@2,
                                    gleam@result:'try'(case {Kind, Tokens@4} of
                                            {{let_assert, none},
                                                [{as, _} | Tokens@5]} ->
                                                gleam@result:map(
                                                    expression(Tokens@5),
                                                    fun(_use0@3) ->
                                                        {Message, Tokens@6} = _use0@3,
                                                        {{let_assert,
                                                                {some, Message}},
                                                            Tokens@6}
                                                    end
                                                );

                                            {{let_assert, _}, _} ->
                                                {ok, {Kind, Tokens@4}};

                                            {'let', _} ->
                                                {ok, {Kind, Tokens@4}}
                                        end, fun(_use0@4) ->
                                            {Kind@1, Tokens@7} = _use0@4,
                                            Statement = {assignment,
                                                Kind@1,
                                                Pattern,
                                                Annotation,
                                                Value},
                                            {ok, {Statement, Tokens@7}}
                                        end)
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glance.gleam", 1552).
-spec fn_parameter(list({glexer@token:token(), glexer:position()})) -> {ok,
        {fn_parameter(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
fn_parameter(Tokens) ->
    gleam@result:'try'(case Tokens of
            [{{name, Name}, _} | Tokens@1] ->
                {ok, {{named, Name}, Tokens@1}};

            [{{discard_name, Name@1}, _} | Tokens@2] ->
                {ok, {{discarded, Name@1}, Tokens@2}};

            [{Other, Position} | _] ->
                {error, {unexpected_token, Other, Position}};

            [] ->
                {error, unexpected_end_of_input}
        end, fun(_use0) ->
            {Name@2, Tokens@3} = _use0,
            gleam@result:'try'(
                optional_type_annotation(Tokens@3),
                fun(_use0@1) ->
                    {Type_, Tokens@4} = _use0@1,
                    {ok, {{fn_parameter, Name@2, Type_}, Tokens@4}}
                end
            )
        end).

-file("src/glance.gleam", 1483).
-spec fn_(list({glexer@token:token(), glexer:position()})) -> {ok,
        {gleam@option:option(expression()),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
fn_(Tokens) ->
    expect(
        left_paren,
        Tokens,
        fun(_, Tokens@1) ->
            Result = comma_delimited(
                [],
                Tokens@1,
                fun fn_parameter/1,
                right_paren
            ),
            gleam@result:'try'(
                Result,
                fun(_use0) ->
                    {Parameters, _, Tokens@2} = _use0,
                    gleam@result:'try'(
                        optional_return_annotation(0, Tokens@2),
                        fun(_use0@1) ->
                            {Return, _, Tokens@3} = _use0@1,
                            expect(
                                left_brace,
                                Tokens@3,
                                fun(_, Tokens@4) ->
                                    gleam@result:'try'(
                                        statements([], Tokens@4),
                                        fun(_use0@2) ->
                                            {Body, _, Tokens@5} = _use0@2,
                                            {ok,
                                                {{some,
                                                        {fn,
                                                            Parameters,
                                                            Return,
                                                            Body}},
                                                    Tokens@5}}
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glance.gleam", 1568).
-spec function_parameter(list({glexer@token:token(), glexer:position()})) -> {ok,
        {function_parameter(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
function_parameter(Tokens) ->
    gleam@result:'try'(case Tokens of
            [] ->
                {error, unexpected_end_of_input};

            [{{name, Label}, _}, {{discard_name, Name}, _} | Tokens@1] ->
                {ok, {{some, Label}, {discarded, Name}, Tokens@1}};

            [{{discard_name, Name@1}, _} | Tokens@2] ->
                {ok, {none, {discarded, Name@1}, Tokens@2}};

            [{{name, Label@1}, _}, {{name, Name@2}, _} | Tokens@3] ->
                {ok, {{some, Label@1}, {named, Name@2}, Tokens@3}};

            [{{name, Name@3}, _} | Tokens@4] ->
                {ok, {none, {named, Name@3}, Tokens@4}};

            [{Token, Position} | _] ->
                {error, {unexpected_token, Token, Position}}
        end, fun(_use0) ->
            {Label@2, Parameter, Tokens@5} = _use0,
            gleam@result:'try'(
                optional_type_annotation(Tokens@5),
                fun(_use0@1) ->
                    {Type_, Tokens@6} = _use0@1,
                    {ok,
                        {{function_parameter, Label@2, Parameter, Type_},
                            Tokens@6}}
                end
            )
        end).

-file("src/glance.gleam", 679).
-spec function_definition(
    module_(),
    list(attribute()),
    publicity(),
    binary(),
    integer(),
    list({glexer@token:token(), glexer:position()})
) -> {ok, {module_(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
function_definition(Module, Attributes, Publicity, Name, Start, Tokens) ->
    expect(
        left_paren,
        Tokens,
        fun(_use0, Tokens@1) ->
            {position, End} = _use0,
            Result = comma_delimited(
                [],
                Tokens@1,
                fun function_parameter/1,
                right_paren
            ),
            gleam@result:'try'(
                Result,
                fun(_use0@1) ->
                    {Parameters, _, Tokens@2} = _use0@1,
                    Result@1 = optional_return_annotation(End, Tokens@2),
                    gleam@result:'try'(
                        Result@1,
                        fun(_use0@2) ->
                            {Return_type, End@1, Tokens@3} = _use0@2,
                            gleam@result:'try'(case Tokens@3 of
                                    [{left_brace, _} | Tokens@4] ->
                                        statements([], Tokens@4);

                                    _ ->
                                        {ok, {[], End@1, Tokens@3}}
                                end, fun(_use0@3) ->
                                    {Body, End@2, Tokens@5} = _use0@3,
                                    Location = {span, Start, End@2},
                                    Function = {function,
                                        Location,
                                        Name,
                                        Publicity,
                                        Parameters,
                                        Return_type,
                                        Body},
                                    Module@1 = push_function(
                                        Module,
                                        Attributes,
                                        Function
                                    ),
                                    {ok, {Module@1, Tokens@5}}
                                end)
                        end
                    )
                end
            )
        end
    ).

-file("src/glance.gleam", 1594).
-spec const_definition(
    module_(),
    list(attribute()),
    publicity(),
    list({glexer@token:token(), glexer:position()})
) -> {ok, {module_(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
const_definition(Module, Attributes, Publicity, Tokens) ->
    expect_name(
        Tokens,
        fun(Name, Tokens@1) ->
            gleam@result:'try'(
                optional_type_annotation(Tokens@1),
                fun(_use0) ->
                    {Annotation, Tokens@2} = _use0,
                    expect(
                        equal,
                        Tokens@2,
                        fun(_, Tokens@3) ->
                            gleam@result:'try'(
                                expression(Tokens@3),
                                fun(_use0@1) ->
                                    {Expression, Tokens@4} = _use0@1,
                                    Constant = {constant,
                                        Name,
                                        Publicity,
                                        Annotation,
                                        Expression},
                                    Module@1 = push_constant(
                                        Module,
                                        Attributes,
                                        Constant
                                    ),
                                    {ok, {Module@1, Tokens@4}}
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/glance.gleam", 1708).
-spec type_alias(
    module_(),
    list(attribute()),
    binary(),
    list(binary()),
    publicity(),
    integer(),
    list({glexer@token:token(), glexer:position()})
) -> {ok, {module_(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
type_alias(Module, Attributes, Name, Parameters, Publicity, Start, Tokens) ->
    gleam@result:'try'(
        type_(Tokens),
        fun(_use0) ->
            {Type_, Tokens@1} = _use0,
            Span = {span, Start, erlang:element(3, erlang:element(2, Type_))},
            Alias = {type_alias, Span, Name, Publicity, Parameters, Type_},
            Module@1 = push_type_alias(Module, Attributes, Alias),
            {ok, {Module@1, Tokens@1}}
        end
    ).

-file("src/glance.gleam", 1778).
-spec fn_type(integer(), list({glexer@token:token(), glexer:position()})) -> {ok,
        {type(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
fn_type(Start, Tokens) ->
    Result = comma_delimited([], Tokens, fun type_/1, right_paren),
    gleam@result:'try'(
        Result,
        fun(_use0) ->
            {Parameters, _, Tokens@1} = _use0,
            expect(
                right_arrow,
                Tokens@1,
                fun(_, Tokens@2) ->
                    gleam@result:'try'(
                        type_(Tokens@2),
                        fun(_use0@1) ->
                            {Return, Tokens@3} = _use0@1,
                            Span = {span,
                                Start,
                                erlang:element(3, erlang:element(2, Return))},
                            {ok,
                                {{function_type, Span, Parameters, Return},
                                    Tokens@3}}
                        end
                    )
                end
            )
        end
    ).

-file("src/glance.gleam", 1787).
-spec tuple_type(integer(), list({glexer@token:token(), glexer:position()})) -> {ok,
        {type(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
tuple_type(Start, Tokens) ->
    Result = comma_delimited([], Tokens, fun type_/1, right_paren),
    gleam@result:'try'(
        Result,
        fun(_use0) ->
            {Types, End, Tokens@1} = _use0,
            Span = {span, Start, End + 1},
            {ok, {{tuple_type, Span, Types}, Tokens@1}}
        end
    ).

-file("src/glance.gleam", 1856).
-spec variant_field(list({glexer@token:token(), glexer:position()})) -> {ok,
        {variant_field(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
variant_field(Tokens) ->
    case Tokens of
        [{{name, Name}, _}, {colon, _} | Tokens@1] ->
            gleam@result:'try'(
                type_(Tokens@1),
                fun(_use0) ->
                    {Type_, Tokens@2} = _use0,
                    {ok, {{labelled_variant_field, Type_, Name}, Tokens@2}}
                end
            );

        Tokens@3 ->
            gleam@result:'try'(
                type_(Tokens@3),
                fun(_use0@1) ->
                    {Type_@1, Tokens@4} = _use0@1,
                    {ok, {{unlabelled_variant_field, Type_@1}, Tokens@4}}
                end
            )
    end.

-file("src/glance.gleam", 1822).
-spec variants(custom_type(), list({glexer@token:token(), glexer:position()})) -> {ok,
        {custom_type(),
            integer(),
            list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
variants(Ct, Tokens) ->
    until(
        right_brace,
        Ct,
        Tokens,
        fun(Ct@1, Tokens@1) ->
            gleam@result:'try'(
                attributes([], Tokens@1),
                fun(_use0) ->
                    {Attributes, Tokens@2} = _use0,
                    expect_upper_name(
                        Tokens@2,
                        fun(Name, _, Tokens@3) ->
                            gleam@result:'try'(case Tokens@3 of
                                    [{left_paren, _},
                                        {right_paren, {position, I}} |
                                        Tokens@4] ->
                                        {ok, {[], I, Tokens@4}};

                                    [{left_paren, _} | Tokens@5] ->
                                        comma_delimited(
                                            [],
                                            Tokens@5,
                                            fun variant_field/1,
                                            right_paren
                                        );

                                    _ ->
                                        {ok, {[], 0, Tokens@3}}
                                end, fun(_use0@1) ->
                                    {Fields, _, Tokens@6} = _use0@1,
                                    Ct@2 = push_variant(
                                        Ct@1,
                                        {variant, Name, Fields, Attributes}
                                    ),
                                    {ok, {Ct@2, Tokens@6}}
                                end)
                        end
                    )
                end
            )
        end
    ).

-file("src/glance.gleam", 1794).
-spec custom_type(
    module_(),
    list(attribute()),
    binary(),
    list(binary()),
    publicity(),
    boolean(),
    list({glexer@token:token(), glexer:position()}),
    integer()
) -> {ok, {module_(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
custom_type(
    Module,
    Attributes,
    Name,
    Parameters,
    Publicity,
    Opaque_,
    Tokens,
    Start
) ->
    Ct = {custom_type, {span, 0, 0}, Name, Publicity, Opaque_, Parameters, []},
    gleam@result:'try'(
        variants(Ct, Tokens),
        fun(_use0) ->
            {Ct@1, End, Tokens@1} = _use0,
            Ct@2 = begin
                _record = Ct@1,
                {custom_type,
                    {span, Start, End},
                    erlang:element(3, _record),
                    erlang:element(4, _record),
                    erlang:element(5, _record),
                    erlang:element(6, _record),
                    erlang:element(7, _record)}
            end,
            Module@1 = push_custom_type(Module, Attributes, Ct@2),
            {ok, {Module@1, Tokens@1}}
        end
    ).

-file("src/glance.gleam", 1659).
-spec type_definition(
    module_(),
    list(attribute()),
    publicity(),
    boolean(),
    list({glexer@token:token(), glexer:position()}),
    integer()
) -> {ok, {module_(), list({glexer@token:token(), glexer:position()})}} |
    {error, error()}.
type_definition(Module, Attributes, Publicity, Opaque_, Tokens, Start) ->
    expect_upper_name(
        Tokens,
        fun(Name_value, Name_start, Tokens@1) ->
            gleam@result:'try'(case Tokens@1 of
                    [{left_paren, _} | Tokens@2] ->
                        comma_delimited([], Tokens@2, fun name/1, right_paren);

                    _ ->
                        {ok, {[], 0, Tokens@1}}
                end, fun(_use0) ->
                    {Parameters, _, Tokens@3} = _use0,
                    case Tokens@3 of
                        [{equal, _} | Tokens@4] ->
                            type_alias(
                                Module,
                                Attributes,
                                Name_value,
                                Parameters,
                                Publicity,
                                Start,
                                Tokens@4
                            );

                        [{left_brace, _} | Tokens@5] ->
                            _pipe = Module,
                            custom_type(
                                _pipe,
                                Attributes,
                                Name_value,
                                Parameters,
                                Publicity,
                                Opaque_,
                                Tokens@5,
                                Start
                            );

                        _ ->
                            Span = {span,
                                Start,
                                Name_start + erlang:byte_size(Name_value)},
                            Ct = {custom_type,
                                Span,
                                Name_value,
                                Publicity,
                                Opaque_,
                                Parameters,
                                []},
                            Module@1 = push_custom_type(Module, Attributes, Ct),
                            {ok, {Module@1, Tokens@3}}
                    end
                end)
        end
    ).

-file("src/glance.gleam", 452).
-spec slurp(
    module_(),
    list(attribute()),
    list({glexer@token:token(), glexer:position()})
) -> {ok, module_()} | {error, error()}.
slurp(Module, Attributes, Tokens) ->
    case Tokens of
        [{at, _} | Tokens@1] ->
            gleam@result:'try'(
                attribute(Tokens@1),
                fun(_use0) ->
                    {Attribute, Tokens@2} = _use0,
                    slurp(Module, [Attribute | Attributes], Tokens@2)
                end
            );

        [{import, {position, Start}} | Tokens@3] ->
            Result = import_statement(Module, Attributes, Tokens@3, Start),
            gleam@result:'try'(
                Result,
                fun(_use0@1) ->
                    {Module@1, Tokens@4} = _use0@1,
                    slurp(Module@1, [], Tokens@4)
                end
            );

        [{pub, {position, Start@1}}, {type, _} | Tokens@5] ->
            Result@1 = type_definition(
                Module,
                Attributes,
                public,
                false,
                Tokens@5,
                Start@1
            ),
            gleam@result:'try'(
                Result@1,
                fun(_use0@2) ->
                    {Module@2, Tokens@6} = _use0@2,
                    slurp(Module@2, [], Tokens@6)
                end
            );

        [{pub, {position, Start@2}}, {opaque, _}, {type, _} | Tokens@7] ->
            Result@2 = type_definition(
                Module,
                Attributes,
                public,
                true,
                Tokens@7,
                Start@2
            ),
            gleam@result:'try'(
                Result@2,
                fun(_use0@3) ->
                    {Module@3, Tokens@8} = _use0@3,
                    slurp(Module@3, [], Tokens@8)
                end
            );

        [{type, {position, Start@3}} | Tokens@9] ->
            Result@3 = type_definition(
                Module,
                Attributes,
                private,
                false,
                Tokens@9,
                Start@3
            ),
            gleam@result:'try'(
                Result@3,
                fun(_use0@4) ->
                    {Module@4, Tokens@10} = _use0@4,
                    slurp(Module@4, [], Tokens@10)
                end
            );

        [{pub, _}, {const, _} | Tokens@11] ->
            Result@4 = const_definition(Module, Attributes, public, Tokens@11),
            gleam@result:'try'(
                Result@4,
                fun(_use0@5) ->
                    {Module@5, Tokens@12} = _use0@5,
                    slurp(Module@5, [], Tokens@12)
                end
            );

        [{const, _} | Tokens@13] ->
            Result@5 = const_definition(Module, Attributes, private, Tokens@13),
            gleam@result:'try'(
                Result@5,
                fun(_use0@6) ->
                    {Module@6, Tokens@14} = _use0@6,
                    slurp(Module@6, [], Tokens@14)
                end
            );

        [{pub, Start@4}, {fn, _}, {{name, Name}, _} | Tokens@15] ->
            {position, Start@5} = Start@4,
            Result@6 = function_definition(
                Module,
                Attributes,
                public,
                Name,
                Start@5,
                Tokens@15
            ),
            gleam@result:'try'(
                Result@6,
                fun(_use0@7) ->
                    {Module@7, Tokens@16} = _use0@7,
                    slurp(Module@7, [], Tokens@16)
                end
            );

        [{fn, Start@6}, {{name, Name@1}, _} | Tokens@17] ->
            {position, Start@7} = Start@6,
            Result@7 = function_definition(
                Module,
                Attributes,
                private,
                Name@1,
                Start@7,
                Tokens@17
            ),
            gleam@result:'try'(
                Result@7,
                fun(_use0@8) ->
                    {Module@8, Tokens@18} = _use0@8,
                    slurp(Module@8, [], Tokens@18)
                end
            );

        [] ->
            {ok, Module};

        Tokens@19 ->
            unexpected_error(Tokens@19)
    end.

-file("src/glance.gleam", 323).
-spec module(binary()) -> {ok, module_()} | {error, error()}.
module(Src) ->
    _pipe = glexer:new(Src),
    _pipe@1 = glexer:discard_comments(_pipe),
    _pipe@2 = glexer:discard_whitespace(_pipe@1),
    _pipe@3 = glexer:lex(_pipe@2),
    slurp({module, [], [], [], [], []}, [], _pipe@3).