On 07.07.2010 1:11, Philippe Sigaud wrote:
Hi Dmitry,
On Tue, Jul 6, 2010 at 22:22, Dmitry Olshansky <[email protected]
<mailto:[email protected]>> wrote:
Hello there!
Got my TDPL some week ago, being playing with D for a while.
Excited with results I'm porting my personal C++ codebase now.
So far everything was kinda cool - even better (not to mention huge
code savings).
Now I'm messing with metaprograming. Simple task at hand: given
typetuple of types produce typetuple of arrays of corresponding types.
Built in typetuples - great, but here's where some usual (boost
MPL-like) library stuff has gone missing.
First, StaticMap described in phobos docs simply not exists in
typetuple.d (using dmd 2.047), here is my drop-in replacement:
template staticMap(alias F,T...){
static if(T.length > 1){
alias TypeTuple!(F!(T[0]),staticMap!(F,T[1..$])) staticMap;
}else{
alias TypeTuple!(F!(T[0])) staticMap;
}
}
It's in std.typetuple, but it's called staticMap with a small 's'. I
agree it should be called StaticMap (big S), as it becomes a type.
Ops, sorry! I'd beter stop coding at night, at certain point I was sure
it's called StaticMap (following the module logic) and vaguely remember
staticMap haven't worked either (maybe forgot to proper import - damn it).
Trying out now - it's here in typetuple and works fine.
I think you should have a case for T.length == 0. One can map the empty
typetuple, after all, particularly if this tuple is the result of
another template and can be void in some circumstances.
Ah, I see bearophile also said this. Hmm, same time zone, Leonardo :-)
Yes, and also having some simple meta-functors packaged along
couldn't hurt. Something like :
template addArray(T){ alias T[] addArray; }
And isn't that cool that meta-programming (or rather, type manipulation)
is so simple in D?
It well could be one of solid reasons to switch over to D completely.
alias TypeTuple!(int, double, string) Types;
alias StaticMap!(addArray, Types) ArrayTypes; // ArrayTypes is
TypeTuple!(int[], double[], string[])
So the question boils down to: what are you guys using std.typetuple
for metaprograming and what's it's status?
I'm using it a lot, mainly for two reasons:
- 'auto' is still buggy: auto function do not show in documentation
comments and (worse) type deduction through many invocation of 'auto' do
not work, due to forward reference limitation. So I tried to get rid of
auto as much as I could in my code base. It made me code a whole
machinery for type manipulation, to get the correct return types for
deeply nested functions. Templates, meta-templates(!), etc. I gather
I'll get rid of them when the auto propagation will see its bugs squashed.
- for fun, to construct and encode things in types :-) Peano numbers,
trees, etc.
I recall encoding some regex-like parsing into typelists in C++,
horrible mess but did the job )
As for its status, I consider it a pretty solid part of Phobos, if
somewhat obscure. No bugs I know of (well, except the _s/S_taticMap
calling convention), a good example of type manipulation in D. It gave
me lots of ideas.
So am I as of 1 min ago...
I had some fun with this (filtering, folding, takeWhile, ...), here is
the result:
http://svn.dsource.org/projects/dranges/trunk/dranges/docs/typetuple2.html
Thanks, looks very promising!
Uh oh, this page is looking for some documentation. All the fun new
templates I put there are not correctly documented. I will do that.
Philippe
--
Dmitry Olshansky
