`grab` expressions

[bvssvni]

This PR adds grab expressions to Dyon. For design, see #316.

What is a grab expression?

A grab expression is a partial evaluation operator that evaluates expressions in the closure environment. This can be used to capture variables read-only.

fn main() {
    a := \(x) = \(y) = \(z) = z + (grab y) + (grab '2 x)
    // prints `\(x: any) = \(y: any) = \(z: any) = z + (grab y) + (grab '2 x)`
    println(a)
    b := \a(1)
    // prints `\(y: any) = \(z: any) = z + (grab y) + 1`
    println(b)
    c := \b(2)
    // prints `\(z: any) = z + 2 + 1`
    println(c)
    d := \c(3)
    println(d)
}

Higher order functions

The grab expression allows you compute with higher order functions, such as function currying, composition of traversing operators, etc.

fn main() {
    f := \(x) = x + 1

    a := fmap(f, for_each())
    list := [1, 2, 3]
    println(\a(list)) // prints `[2, 3, 4]`

    a := fmap(f, maybe())
    b := some(2)
    println(\a(b)) // prints `some(3)`
    println(\a(none())) // prints `none()`

    a := fmap(f, tree())
    b := {left: 1, right: {left: 2, right: 3}}
    println(\a(b)) // prints `{right: {right: 4, left: 3}, left: 2}`

    // Combine two functors.
    a := fmap(f, fjoin(for_each(), maybe()))
    b := [some(1), some(2), some(3)]
    // prints `[some(2), some(3), some(4)]`
    println(\a(b))

    // Combine a list of functors.
    a := fmap(f, fjoins([for_each(), maybe(), tree()]))
    b := [some({left: 1, right: 2}), some({left: 2, right: 3}), some({left: 3, right: 4})]
    // prints `[some([2, 3]), some([3, 4]), some([4, 5])]`
    println(\a(b))

    println(fjoins([for_each(), maybe(), tree()]))
}

for_each() = \(f, v) = sift i {\f(v[i])}
maybe() = \(f, v) = if v == none() { none() } else { some(\f(unwrap(v))) }
tree() = \(f, v) = {
    if typeof(v) == "object" {
        t := tree()
        {left: \t(f, v.left), right: \t(f, v.right)}
    } else {
        \f(v)
    }
}

fn fmap(f: \(any) -> any, g: \(\(any) -> any, any) -> any) -> \(any) -> any {
    return \(x) = {
        g := grab g
        \g(grab f, x)
    }
}

fn fjoin(
    a: \(\(any) -> any, any) -> any,
    b: \(\(any) -> any, any) -> any
) -> \(\(any) -> any, any) -> any {
    return \(f, v) = {
        a := grab a
        \a(\(v) = {
            b := grab '2 b
            \b(grab f, v)
        }, v)
    }
}

fn fjoins(fs: [\(\(any) -> any, any) -> any])
-> \(\(any) -> any, any) -> any {
    a := fs[0]
    for i [1, len(fs)) {
        a = fjoin(a, fs[i])
    }
    return clone(a)
}

Code generation

grab expressions can be used as form of run-time code generation:

fn main() {
    a := 5
    b := sift i a { \(x) = x / grab prod j i + 1 { j + 1 } }
    // [
    //   \(x: any) = x / 1,
    //   \(x: any) = x / 2,
    //   \(x: any) = x / 6,
    //   \(x: any) = x / 24,
    //   \(x: any) = x / 120
    // ]
    println(b)
}

This has the following benefits:

• The generated code is already lifetime/type checked
• No need to write strings together and output them to a file, and then load it as a dynamic module
• Can be used to optimize some expressions that are used frequently but not known before running

Motivation

Before, closures in Dyon could not capture variables from their envionment. With grab expressions they can, and gives you more precise control over how this happens.

Adds a non-state capture ability of variables in the environment of closures. It is more powerful in the way that it works as a partial evaluation operator, but less flexible than mutable captured variables.

Dyon uses current objects for mutating the environment, so there is less need for capturing mutatable variables. A non-state capture is easier to reason about, requires no lifetime, and does not add overhead when calling closures.