Language directives

[feds01]

Oveview

Language directives are a way to signal to the compiler to perform a particular behaviour. The directive can be used to mark an expression that the compiler will then perform the specified directive on.

The syntax would follow:

let foo = #directive ... ;

and for multiple directives, this can be used:

let foo = #directive_a, #directive_b ... ;

This means that directives follow the standard identifier syntax preceded with a #.
Directives have many uses, for example:

let fact = #memoised (n: bigint) -> bigint => if n < 2 {  1 } else { n * fact(n - 1) };

This could mean that the compiler would inline particular logic that would memoise function calls to
the function fact and re-use values instead of re-computing this.

Problems

• Can users of the language define their own directives, and how would they do this?
• Syntactic conflict when using # for intrinsic functions and directives. If directives are to be added to the language, then we either have to re-define the syntax for intrinsic functions or use an alternative syntax for intrinsic functions.

[kontheocharis]

I think it might make the most sense to have directives be an alternative syntax for invoking compile-time functions/macros. Specifically, ones that take in structs/functions/enums and modify them in some way, and finally return an equivalent transformed definition (s).

However, given that this is not part of the language yet, it might be better to keep them as internal for now, generally used for debugging purposes or common transformations (serde, memoisation, etc).

[kontheocharis]

Also, should multiple directives be separated by commas, or just spaces? we would require no extra syntax in the latter case, other than precedence rules.

[feds01]

It would probably make sense to use spaces instead of commas because this would make it somewhat cleaner when transforming the directives into an AST

[kontheocharis]

Another thing to note is we might want to support higher order functions here, like #inject(MyService)

[feds01]

Yes this would be very useful, especially in cases where we want to record some kind of data or perform an action when the directive is involved. An obvious use case could be:

let f = #timed(record_time_please) () => { ... };

In this example, the timed directive records the pure execution time of the function and passes the result to record_time_please for example. Does this mean that directives could also be typed?

[kontheocharis]

Directives should definitely be typed. In fact, one could imagine the following:

timed := (timer: Timer) => (Def: const hash.FunctionDefinition) -> Def => {
    return (...args: Def.args_type()) => {
        timer.record_start();
        res := def(...args);
        timer.record_end();
        return res;
    };
};

[feds01]

Yeah this is another great feature that could empower the language

Also, in that example, surely it's the return type of Def instead of just Def?