desugar bang help · contributing

I'm currently having some trouble working with the Defs in crates/compiler/parse/src/ast.rs. Specifically to implement the algorithm the way I want, I need to be able to remove a definition from the Defs, from the start or from within the middle of the vec. Hence I've added the remove_value_def helper. To get the index I wrote the search_suffixed_defs which finds the first value def that I am interested in.

But I'm really unsure about how to work with the pub tags: std::vec::Vec<EitherIndex<TypeDef<'a>, ValueDef<'a>>> part. It probably doesn't help I'm also just fumbling my way through rust at the same time so I am not sure where I'm going wrong.

I started off by just working with the value_defs vec but then realised that I probably need to also work with the type_defs and the other parts of the Defs struct if I am removing things. I know there is an issue here because I get "panicked at 'index out of bounds: the len is 1 but the index is 1'" errors.

It may not be helpful, but here is my plan to desugar Defs worked out manually

// FROM THIS
// ```
// main =
//    a = line! "FIRST ARGS"
//    mid = "MID THING"
//    b = write! "SECOND ARGS"
//    c = read! "THIRD ARGS"
//
//    ok {}
// ```
// TO THIS
// ```
// main =
//     await (line "FIRST ARGS") \a ->
//         mid = "MID THING"
//         await (write "SECOND ARGS") \b ->
//             await (read "THIRD ARGS") \c ->
//                 ok {}
// ```

// start
Defs(
    [
        // note that we have a Suffixed first
        Body(a, Apply(Suffixed("line"), "FIRST ARGS", called_via_space)),
        Body(mid, "MID THING"),
        Body(b, Apply(Suffixed("write"), "SECOND ARGS", called_via_space)),
        Body(c, Apply(Suffixed("read"), "THIRD ARGS", called_via_space)),
    ],
    "ok {}", // this is actually another Apply ... simplified here
)

// first - pop the first Suffixed and wrap Defs node with an Apply and Closure
Apply(
    "await",
    [
        Apply("line", "FIRST ARGS", called_via_space),
        Closure(
            [Identifier "a"],
            Defs(
                [
                    Body(mid, "MID THING"),
                    // note that the next Suffixed is now in the middle of the Defs
                    Body(b, Apply(Suffixed("write"), "SECOND ARGS", called_via_space)),
                    Body(c, Apply(Suffixed("read"), "THIRD ARGS", called_via_space)),
                ],
                "ok {}",
            ))
    ],
    called_via_space,
)

// second - wrap loc_ret "ok {}" in the Defs node with Apply and Closure, moving remaining defs into new Defs node
Apply(
    "await",
    [
        Apply("line", "FIRST ARGS", called_via_space),
        Closure(
            [Identifier "a"],
            Defs(
                [
                    // all Defs before Suffixed are left behind
                    Body(mid, "MID THING"),
                ],
                // here the loc_ret "ok {}" was wrapped in an Apply and Closure and new Defs node
                Apply(
                    "await",
                    [
                        Apply("write", "SECOND ARGS", called_via_space),
                        Closure(
                            [Identifier "b"],
                            Defs(
                                [
                                    // all Defs after the Suffixed were brought forward into new Def node
                                    // note that now there is only a single Suffixed def remaining
                                    Body(c, Apply(Suffixed("read"), "THIRD ARGS", called_via_space)),
                                ],
                                "ok {}"
                            )
                        )
                    ]
                    called_via_space,
                ),
            )
        )
    ],
    called_via_space,
)

// third - wrap the loc_ret with the Apply and Closure
Apply(
    "await",
    [
        Apply("line", "FIRST ARGS", called_via_space),
        Closure(
            [Identifier "a"],
            Defs(
                [
                    Body(mid, "MID THING"),
                ],
                Apply(
                    "await",
                    [
                        Apply("write", "SECOND ARGS", called_via_space),
                        Closure(
                            [Identifier "b"],
                            // The loc_ret was wrapped with an Apply and Closure
                            // There are no Defs left so we just have the loc_ret node
                            Apply(
                                "await",
                                [
                                    Apply("read", "THIRD ARGS", called_via_space),
                                    Closure(
                                        [Identifier "c"],
                                        "ok {}",
                                    ),
                                ],
                                called_via_space,
                            )
                        )
                    ]
                    called_via_space,
                ),
            )
        )
    ],
    called_via_space,
)

Luke Boswell (Mar 19 2024 at 08:29):

I think I know what the issue with my logic is. Using Vec::remove shifts the remaining values left, so the remaining indexes will now be all off by 1.

Stream: contributing

Topic: desugar bang help

Luke Boswell (Mar 19 2024 at 05:13):

Luke Boswell (Mar 19 2024 at 08:29):