Syntactical flexibility

Previously, I kept C++'s member initializer syntax- that is,

    type t {
        var := bool;
        type() : var(true) {}
    }

But this isn't really flexible enough for my needs. For example, var can only be an identifier, but bases need expressions to identify them. In addition, consider the needs of a function that is, say, an exported constructor. This function needs initializers even though it is not, syntactically, a constructor. This causes me to feel the need to unify syntaxes for exporting, explicit return type, and member initializers into a familiar syntax.

    type t {
        var := bool;
        type() var := true; {}
    }
    f()
        export := function;
        member1 := init;
    {}

In addition, consider that now, it could be possible to express the initializer of more than one member. For example,

    type t {
        var := bool;
        var2 := bool;
        type() var, var2 := { true, true }; {}
    }

I also feel that you should be able to define out-of-class functions as members, including a "this" member, and that this should function like a normal "this" in terms of implicit lookup. If the function is not exported as a member then failure. I feel that having export and return as keywords will save the user from not being able to use members that way. You can specify multiple values for export- string, function, or true. True is coming later.

For function I am in the position where you have to use an overload set. This is problematic when it's a member overload set. I feel like I need to re-introduce something like type->member, where -> will denote a static access. This access should produce an overload set including non-static members, where there are non-static member functions.

Finally, I should perform some parameter validation. Code-generation will fail if the exported function is not LLVM-compatible with the one Clang declared, but there's no other sanity checks involved. The same is true of virtual thunks. The compiler should not fail at code generation time.