Scriptlike v0.9.4 - Perl-like interpolated strings, full examples and more.

[Chad Joan via Digitalmars-d-announce]

On Wednesday, 23 September 2015 at 19:28:03 UTC, Nick Sabalausky 
wrote:
> On 09/23/2015 03:18 PM, Chad Joan wrote:
>>
>> This is why I argued for alternative mixin syntax in D some 
>> ... years?
>> ... ago.
>>
>> It'd be really cool to have a writefln overload that did this:
>>
>> int somevar = 42;
>> writefln#("This is ${somevar}");
>>
>> writefln#("Plus two and you get ${somevar+1}");
>>
>> Which would just be shorthand for
>>
>> int somevar = 42;
>> mixin writefln!("This is ${somevar}");
>>
>> mixin writefln!("Plus two and you get ${somevar+2}");
>>
>>
>> I feel like a bit of syntax sugar could go a long way ;)
>
> Yea, the trouble with string mixins is that they're ugly enough 
> people don't like to use them.
>
> I'd argued in the past for a way to tag a CTFE-able 
> string-returning function as being intended for mixing-in, so 
> you could omit the "mixin(...)" part. But we only ever got it 
> for template mixins. Allowing it for string mixins was too 
> controversial. :(
>
> I dunno, maybe even a string mixin sugar as simple as this 
> would be a big help:
>
> mixin!func(args to func here)
>
> ie:
>
> mixin!interp("Some string here")
>
> But I'm guessing the ship's ling since sailed for anything like 
> that.

I hope not :(

I remember when Walter originally designed mixins, he stated 
something to the effect that he wanted them to be easily 
greppable at all times.

I would argue that they are so centrally important that they 
should be a symbol rather than a keyword.  Still greppable.  But 
also much more useful.

Since D already has the mixin keyword, I suspect it would be more 
practical to just ask people to grep for 'mixin|<mixin symbol>' 
instead of just 'mixin'.

There are similar (but orthogonal) concerns with delegate 
(anonymous function) nesting:

// D notation.
foo ( (x,y) {
     auto z = doSomething(x+y);
     return z*z;
});

vs

// Speculative notation.
foo() : (x,y) {
     auto z = doSomething(x+y);
     return z*z;
}

Current D notation for nesting functions reminds me of C's 
notation for structs...

// C notation.
typedef struct WhatDoIPutHereFoo
{
     int x,y;
} Foo;

// D notation.  (Yay, consistency!)
struct Foo
{
     int x,y;
}

Extra semicolon and syntax noise and such.

I'm still incredibly glad D even has delegates and mixins at this 
point ;)