Dynamic language

[Adam D. Ruppe]

On Friday, 16 March 2012 at 09:12:57 UTC, F i L wrote:
> Alright I give up dammit! How do you use opCall() to make 
> a.cool() work?

I was a little unclear... but you'll have to modify
std.variant and/or wrap it.

Here's a solution that wraps it:

==

import std.traits;
import std.variant;

// we want to give a common interface to all functions,
// which is what this wrapper tries to do.

// note it is kinda buggy; this is just a quick example,
// not a finished product
Variant delegate(Variant[]) wrap(alias t)() {
   return delegate Variant(Variant[] args) {
     ParameterTypeTuple!(typeof(t)) ptt;
     foreach(i, param; ptt) {
       if(i == args.length)
         break; // or throw if you want strictness
       // BTW, you can do default params and names too,
       // but it takes a fair amount of code. Check
       // out my web.d generateWrapper() for this if
       // you are interested.

           // or get for strictness
       ptt[i] = args[i].coerce!(typeof(param));
     }

     Variant returned;
     static if(is(ReturnType!(typeof(t)) == void))
       t(ptt);
     else
       returned = t(ptt);

     return returned;
   };
}

// here's our variant wrapper...
struct MyVariant {
   Variant delegate(Variant[]) callable;
   Variant value;

   alias value this;

   // the main trick here is when we construct or assign,
   // we have compile time info about the function. So, we
   // use this opportunity to build a delegate to call it 
dynamically.
   this(T)(T t) {
     value = t;
     static if(isCallable!T) {
       callable = wrap!(t)();
     } else {
       callable = null;
     }
   }

   // and here, we use the delegate made above
   Variant opCall(T...)(T t) {
     if(!callable)
       throw new Exception("not callable");
     Variant[] args;
     foreach(i, v; t)
       args ~= Variant(v);
     return callable(args);
   }

   MyVariant opAssign(T)(T t) {
     // FIXME: copy/paste from constructor because otherwise it
     // tries to call a simple delegate instead of passing the 
delegate itself..
     value = t;
     static if(isCallable!T) {
       callable = wrap!(t)();
     } else {
       callable = null;
     }
     return this;
   }
}


// let's test it
import std.stdio;

void main () {
   MyVariant v = 10;
   //v(); // would throw

   v = { writefln("Hello, world!"); };
   v(); // says hello!
}
==




One of the big bugs is that the compile conflates
instance opCall, static opCall, and constructors in
such a way that it sometimes calls the wrong one.

This makes calling things with parameters a pain
in the ass, and I hope dmd eventually fixes this.


For instance, add this to the end:


         v = function(int a) { writeln("whoa: ", a); };
         v(10);



And the stupid compiler thinks v(10) is calling the
struct's constructor again.

Why would you /ever/ want that on an instance?


It also complains if you declare opCall and static opCall
separately. Why?



You can work around this by making MyVariant a class. No
constructor (that apparently doesn't work right either. This
is bug city!), just opAssign.

Then you can do:
==
         auto v = new MyVariant();

         v = { writefln("Hello, world!"); };
         v(); // says hello

         v = function(int a) { writeln("whoa: ", a); };
         v(10); // says whoa: 10


         // look, a std.variant bug too while we're at it
         // fix this in std.variant tho, and it will work too
         // v("12"); //  Type immutable(char)[] does not convert 
to int
==


This isn't something I use every day, but even in bug city,
it isn't /too/ hard to make it work in D, including weak
typing and variable argument lists, just like Javascript if
we want to. Or, we can go tougher with minor changes.


D rox despite bugs.