`self` variable in lambdas inside objects

[thinker227]

With the current closure rules, "object-oriented" code like this can be written, although it's a bit of a hack.

func createCounter() {
    let mut x = 0;

    {
        add: (amount) => {
            x += amount;
        },
        get: () => x
    }
}

Instead of actually having x be field inside the object, it has to be a captured variable so that the lambdas can use it with reference semantics. It would be neat however to allow lambdas declared inside objects to somehow reference the object they're declared in.

self variable

The idea is to add a self symbol which acts as an immutable variable and is implicitly declared inside object expressions. When referenced, this symbol returns the object it was declared by.

This would allow turning the above code into this (although the semantics are slightly different):

func createCounter() {
    {
        mut x: 0,
        add: (amount) => {
            self.x += amount;
        },
        get: () => self.x
    }
}

Notably self would not be permitted to be referenced within the value expressions of fields, as in

{ x: self.x }

Since x is not "initialized" when self.x is evaluated, this should be an error. self should only be available inside lambdas inside objects.

Naming

The symbol could be called either self, this, or something different. Both self and this are somewhat confusing though since it's not entirely evident what "self" or "this" is. Another idea would be object, although a 6-letter name is somewhat too long imo.

[thinker227]

This is technically already possible using a fixed-point combinator, albeit the object has to be wrapped in an additional lambda and self has to be invoked as a function.

func fix(f) {
    let mut object = ();
    object = f(() => object);
    object
}

func createCounter() => fix((self) => {
    mut x: 0,
    add: (amount) => {
        self().x += amount;
    },
    get: () => self().x
});

let counter = createCounter();
counter.add(2);
counter.add(3);
counter.add(4);
print(counter.get()); // 9

Maybe consider adding fix as a built-in function, would be neat as something not a lot of languages offer as part of their standard library.