Overloading relational operators separately; thoughts?

[Jacob Carlborg via Digitalmars-d]

On 2016-09-29 14:57, rikki cattermole wrote:
> Me and Cauterite were toying with the idea of AST macros but in a
> completely new form a while ago.
>
> Below is the usage of it.
>
> Something you'll notice about it is that it could turn the asm block
> into a library solution (which is clearly what we'd want anyway). Not to
> mention Linq style queries.
>
> In theory it shouldn't be too complex to implement since you are only
> doing basic checks to determine if to parse the given statement / block
> to a rewriter function.
>
> ```D
> void main() {
>     // \/ parsed by iasm.c by matches {}'s and sending contents to it
>     asm {
>         ...
>     }
>
>     import linq;
>     @Linq
>     DataSource source = ...;
>     Tree[] trees = source.trees.where(name = "abc").limit(20);
>
>     import Assembly_x86;
>
>     asm {
>         ...
>     }
> }
>
> struct Linq {
>     string __ast(OnType, ExpectedType)(string statement) {
>         assert(statement == "source.trees.where(name = "abc").limit(20);");
>         static assert(OnType == DataSource);
>         static assert(ExpectedType == Tree[]);
>     }
> }
>
> // Assembly_x86.d
>
> struct X86 {}
> struct ASM {
>
>     string __ast(OnType, ExpectedType)(string statement) {
>         assert(statement == "asm {\n        ...\n    };");
>         static assert(OnType == X86);
>         static assert(ExpectedType == void);
>     }
> }
>
> @ASM
> X86 asm;
> ```

Hmm, I find this to be somewhat difficult to follow. You get the AST as 
a string? Which means you need to implement a parser. How will the macro 
invocation be transformed? Return a string from the macro which will be 
reparsed by the compiler and inserted at the call site?

-- 
/Jacob Carlborg