Safer casts

[Sean Kelly]

== Quote from Dee Girl (deegirl at noreply.com)'s article
> Sean Kelly Wrote:
> > == Quote from Dee Girl (deegirl at noreply.com)'s article
> > > Yigal Chripun Wrote:
> > > > Dee Girl wrote:
> > > > <snip>
> > > > maybe I still didn't explain myself properly. I've used the term
> > > > "sort-with-delegates" meaning a specific instance of sort when given a
> > > > delegate as input. I thought this was clear enough, otherwise I would
> > > > have simply said "sort".
> > > > before you start sending me assembly code, let's go over it again and
> > > > make sure we both understand each other:
> > > > you take the sort template, stick in a delegate, mix for five minutes
> > > > let is simmer for one more and viola: you got the exact same thing if
> > > > you would have written sort as a regular function which receives a
> > > > delegate parameter.
> > > > the template takes the symbol it receives (the delegate name) and
> > > > "embeds" it in the sort instance.
> > > > both ways you get:
> > > > 1) a call to sort
> > > > 2) a call to the delegate
> > > > the only difference is the number of parameters the sort function
> > > > receives when called.
> > > > the regular sort function can run different delegates at runtime (this
> > > > is what you call "dynamic". the template has the call to the specific
> > > > delegate embedded so for different delegates you need different sort
> > > > instances.
> > > Good. I think I understand. I want to be very sure, so I have a question from this code.
> > > int array[] = [1, 2, 3];
> > > int x = 5;
> > > sort!((int a, int b) { return a + x < b + x; })(array);
> > > Two questions not one ^_^
> > > 1. Is the code inside sort!() as powerful as delegate?
> >
> > It depends what you mean by "powerful."  Passing a comparator as a template parameter,
> > as with sort!(), means that the choice of comparator must be made at compile-time rather
> > than run-time.  This may be problematic in some instances.
> Maybe you did not read previous discussion. Choice of comparator can be made at runtime. sort!(dg)
works for a dynamic delegate dg. Just try it! It was hard to believe for me. The way D compiler
insantiates sort is ingenious. This makes sort very powerful because it works with both static and
dynamic code at the same time! I never found that in a language.

So you're saying I could do this:

void myfunc( bool delegate(int,int) dg )
{
    int[] buf = [1,2,3,4,5].dup;
    sort!(dg)( buf );
}

I thought alias parameters had to be resolvable at compile-time.  Interesting.

> > > 2. Is the call inside sort direct or indirect? Thank you, Dee Girl
> >
> > Do you mean inline or not inline?  It's hard to say.  DMD's inlining mechanism is a bit
> > quirky, so it could go either way.  For example, I've had struct member functions which
> > would be inlined if static and not inlined if not static, and other member functions which
> > were the reverse.  I haven't found any way to be sure other than trying it out and examining
> > the ASM from the object file.
> Question was not about inlining. It was about indirect call with a pointer to function or a regular call.
The regular call could be inlined but the pointer call is much harder. The answer is deterministic and
very interesting. I think I undestand now how the D compiler generates functions from templates.
Thank you, Dee Girl

Harder but still possible.  DMD doesn't do this right now, but Walter has said it may in the future.


Sean