Proof of Concept: Implementing Multiple Dispatch in D (need vararg call)

[Kirk McDonald]

Bruno Medeiros wrote:
> I watched some time ago a Google tech about Common Lisp ( 
> http://video.google.com/videoplay?docid=448441135356213813&q=peter+seibel
> ) where the Lispanatic speaker exalts LISP and whines about Java.
> 
> The second part of the talk, talks about the CLOS (Common Lisp Object 
> System) multiple dispatch system (called multimethods on Lisp lingo), 
> and how it can be useful, etc.., and how in Java it all had to be 
> implemented manually and non-generically (i.e., for each particular usage).
> 
> I wondered, how would D fare? I started to think if and how that could 
> be implemented in D, as a proof-of-concept, D testing, and template 
> learning exercise. The first thing needed, I noticed, was a compile time 
> reflection mechanism, for functions at least (to find it's parameter 
> types). With some IFTI incantations this is actually already possible, 
> but with the number of parameters limited (this is what TomS's funcmeta 
> does).
> 
> So I've started out and I got a near complete implementation, but 
> then... I've just noticed I need one more thing: the ability to call a 
> function with a constant but parameterized arguments.
> That is I have a:
> Compile time constant (template param) which is the number of args:
>   N
> The arguments:
>   Object[N] objar;
> An array-like template that provides the (class) type of each argument 
> of the function to be called:
>   funcTypeINFO.arg!( int n )
> And then I would need to call a function like this:
> 
>   dispatchfn(
>     cast(funcTypeINFO.arg!(0)) objar[0],
>     cast(funcTypeINFO.arg!(1)) objar[1],
>     ...
>     cast(funcTypeINFO.arg!(N)) objar[N]
>   );
> 
> Is this possible? I fear this is not possible without entering into 
> ABI-dependent hackery :/ which I would like to avoid (but is better than 
> nothing).
> 

Sounds like you want tuples. Tom S's 'bind' module might do what you're 
looking for. Search digitalmars.D.announce for the thread 'A library 
similar to boost::bind'.

Pyd's function wrapping abillities are vaugely similar to this, too. The 
code isn't very pretty: It's limited to 10 arguments for a given 
function, is annoying to read (there are some bits that don't really 
work that I haven't bothered to remove, yet), and is an eyesore in 
places. It does work, however. :-)

The Pyd source:
http://dsource.org/projects/pyd/browser/trunk/infrastructure/pyd

The function wrapping module itself:
http://dsource.org/projects/pyd/browser/trunk/infrastructure/pyd/func_wrap.d

Pyd's tuple module:
http://dsource.org/projects/pyd/browser/trunk/infrastructure/pyd/tuples.d

-- 
Kirk McDonald
Pyd: Wrapping Python with D
http://dsource.org/projects/pyd/wiki