module [match_all]

import Template exposing [parse_template]
import Match

match_all :
    Str,
    Str
    -> Result
        (Dict Str Str)
        [
            DoesNotMatch,
            TemplateError [
                MissingClosingBracket,
                InvalidTokenLength Str,
                InvalidTokenType Str,
                TooManyTokenParts Str
            ]
        ]
match_all = |template_str, input_str|
    specs =
        template_str
        |> parse_template
        |> Result.map_err(TemplateError)?

    input_str
    |> Str.to_utf8
    |> Match.all_specs(specs)

expect
    # that `match_all` returns `Ok` with an empty dict
    # when a template is a literal fully matching the input string
    template_str = "text"
    input_str = "text"
    fields = match_all(template_str, input_str)
    fields == Ok(Dict.empty({}))

expect
    # that `match_all` returns `Ok` with a proper field and value
    # when a template with named token matches the input string
    template_str = "Three symbols: {result:s:6}."
    input_str = "Three symbols: 123Abc."
    fields = match_all(template_str, input_str)
    fields == Ok(Dict.from_list([("result", "123Abc")]))

➜ just test
roc test src/main.roc
thread 'main' panicked at crates/compiler/mono/src/borrow.rs:361:34:
internal error: entered unreachable code:
        No borrow signature for LambdaName { name: `Match.65`, niche: Niche(Captures([])) } layout.

        Tip 1: This can happen when you call a function with fewer arguments than it expects.
        Like `Arg.list!` instead of `Arg.list! {}`.
        Tip 2: `roc check yourfile.roc` can sometimes give you a helpful error.

note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
error: Recipe `test` failed on line 8 with exit code 101

 v = match_all("text", "text")

expect
    v = match_all("text", "text")
    Bool.true

module [Spec, Matcher, all_specs, anything, literal]

Matcher a : List U8 -> Result (List U8) [DoesNotMatch]a

Spec a : {
    field_name : [Anonymous, Named Str],
    length : U64,
    matcher : Matcher a,
}

anything : Matcher a
anything = |input|
    Ok(input)

literal : List U8 -> Matcher a
literal = |value|
    |input|
        if input == value then
            Ok(input)
        else
            Err(DoesNotMatch)

split_input_segment :
    List U8,
    { length : U64 }*
    -> Result { input_segment : List U8, rest_input : List U8 } [DoesNotMatch]
split_input_segment = |input, { length }|
    { before: input_segment, others: rest_input } = List.split_at(input, length)
    if List.len(input_segment) < length then
        Err(DoesNotMatch)
    else
        Ok({ input_segment, rest_input })

## See `all_specs` for the public API.
all_specs_recursive : List U8, List (Spec _), Dict Str Str -> Result (Dict Str Str) [DoesNotMatch]
all_specs_recursive = |input, specs, acc|
    when specs is
        [] ->
            if input == [] then
                Ok(acc)
            else
                Err(DoesNotMatch)

        [spec, .. as rest_specs] ->
            { input_segment, rest_input } = split_input_segment(input, spec)?

            # Even thought `field_value` is not always used,
            # it's important to call `spec.matcher?` here
            field_value =
                input_segment
                |> spec.matcher?
                |> Str.from_utf8_lossy

            all_specs_recursive(
                rest_input,
                rest_specs,
                when spec.field_name is
                    Named(name) -> Dict.insert(acc, name, field_value)
                    Anonymous -> acc,
            )

all_specs : List U8, List (Spec _) -> Result (Dict Str Str) [DoesNotMatch]
all_specs = |input, specs|
    all_specs_recursive(input, specs, Dict.empty({}))

expect
    actual = all_specs(
        ['B', 'u', 'z', 'z', 'F', 'u', 'z', 'z'],
        [
            {
                field_name: Named("field1"),
                length: 4,
                matcher: literal(['B', 'u', 'z', 'z']),
            },
        ],
    )
    actual == Ok(Dict.from_list([("field1", "Buzz"), ("field2", "Fuzz")]))

match_all :
    Str,
    Str
    -> Result
        (Dict Str Str)
        [
            DoesNotMatch,
            TemplateError [
                    MissingClosingBracket,
                    InvalidTokenLength Str,
                    InvalidTokenType Str,
                    TooManyTokenParts Str,
                ],
        ]
match_all = |template_str, input_str|
    # specs =
    #     template_str
    #     |> parse_template
    #     |> Result.map_err(TemplateError)?
    specs = [
        {
            field_name: Named("field1"),
            length: 10,
            matcher: anything,
        },
    ]

    input_str
    |> Str.to_utf8
    |> all_specs(specs)

expect
    # that `match_all` returns `Ok` with an empty dict
    # when a template is a literal fully matching the input string
    template_str = "text"
    input_str = "text"
    fields = match_all(template_str, input_str)
    fields == Ok(Dict.empty({}))

── TYPE MISMATCH in ./Match.roc ────────────────────────────────────────────────

Something is off with the body of the match_all definition:

 80│       Str,
 81│       Str
 82│       -> Result
 83│           (Dict Str Str)
 84│           [
 85│               DoesNotMatch,
 86│               TemplateError [
 87│                       MissingClosingBracket,
 88│                       InvalidTokenLength Str,
 89│                       InvalidTokenType Str,
 90│                       TooManyTokenParts Str,
 91│                   ],
 92│           ]
 93│   match_all = |template_str, input_str|
 94│       # specs =
 95│       #     template_str
 96│       #     |> parse_template
 97│       #     |> Result.map_err(TemplateError)?
 98│       specs = [{
 99│           field_name: Named("field1"),
100│           length: 10,
101│           matcher: anything,
102│       }]
103│
104│>      input_str
105│>      |> Str.to_utf8
106│>      |> all_specs(specs)

This all_specs call produces:

    Result (Dict Str Str) […]a

But the type annotation on match_all says it should be:

    Result (Dict Str Str) [TemplateError [
        InvalidTokenLength Str,
        InvalidTokenType Str,
        MissingClosingBracket,
        TooManyTokenParts Str,
    ], …]