Proof of Concept: Implementing Multiple Dispatch in D (need vararg call)
Kirk McDonald
kirklin.mcdonald at gmail.com
Mon Jul 31 16:00:20 PDT 2006
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
More information about the Digitalmars-d-learn
mailing list