www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - indexing tuples using strings

reply llee <larry workingwondersus.com> writes:
Is is possible to index the elements within a tuple using strings?
Something similar to the way that associative arrays allow elements to be
indexed using strings.
Dec 01 2008
next sibling parent "Jarrett Billingsley" <jarrett.billingsley gmail.com> writes:
On Mon, Dec 1, 2008 at 4:19 PM, llee <larry workingwondersus.com> wrote:
 Is is possible to index the elements within a tuple using strings?
 Something similar to the way that associative arrays allow elements to be
indexed using strings.

No, because that makes no sense. What does tuple["string"] mean, anyway?
Dec 01 2008
prev sibling next sibling parent reply "Bill Baxter" <wbaxter gmail.com> writes:
On Tue, Dec 2, 2008 at 6:40 AM, Jarrett Billingsley
<jarrett.billingsley gmail.com> wrote:
 On Mon, Dec 1, 2008 at 4:19 PM, llee <larry workingwondersus.com> wrote:
 Is is possible to index the elements within a tuple using strings?
 Something similar to the way that associative arrays allow elements to be
indexed using strings.

No, because that makes no sense. What does tuple["string"] mean, anyway?

Tuples have an annoying "auto-flattening" behavior which means that it's difficult to create very advanced data structures out of them. But you can create a flat tuple a-list with entries like "fred", int, "barney", double, "wilma", ireal Then you can write some template functions that will scan through the list for a particular string and return the following type if there's a match. You will need to use lots of recursive template-fu. --bb
Dec 01 2008
next sibling parent reply Jason House <jason.james.house gmail.com> writes:
Bill Baxter Wrote:

 On Tue, Dec 2, 2008 at 6:40 AM, Jarrett Billingsley
 <jarrett.billingsley gmail.com> wrote:
 On Mon, Dec 1, 2008 at 4:19 PM, llee <larry workingwondersus.com> wrote:
 Is is possible to index the elements within a tuple using strings?
 Something similar to the way that associative arrays allow elements to be
indexed using strings.

No, because that makes no sense. What does tuple["string"] mean, anyway?

Tuples have an annoying "auto-flattening" behavior which means that it's difficult to create very advanced data structures out of them. But you can create a flat tuple a-list with entries like "fred", int, "barney", double, "wilma", ireal Then you can write some template functions that will scan through the list for a particular string and return the following type if there's a match. You will need to use lots of recursive template-fu. --bb

... Or you can just loop over the tuple and return the matching index... No recursive template-foo needed
Dec 01 2008
parent reply BCS <ao pathlink.com> writes:
Reply to Jason,

 Bill Baxter Wrote:
 
 On Tue, Dec 2, 2008 at 6:40 AM, Jarrett Billingsley
 <jarrett.billingsley gmail.com> wrote:
 
 On Mon, Dec 1, 2008 at 4:19 PM, llee <larry workingwondersus.com>
 wrote:
 
 Is is possible to index the elements within a tuple using strings?
 Something similar to the way that associative arrays allow elements
 to be indexed using strings.
 

What does tuple["string"] mean, anyway?

it's difficult to create very advanced data structures out of them. But you can create a flat tuple a-list with entries like "fred", int, "barney", double, "wilma", ireal Then you can write some template functions that will scan through the list for a particular string and return the following type if there's a match. You will need to use lots of recursive template-fu. --bb

index... No recursive template-foo needed

you can't loop over a template outside of a function. OTOH: template IndexOf(char[] str, Strs...) { const int IndexOf = typeof( *{ foreach(int i, char[] s; Strs) { static char[i] r; static if(Strs[i] == str) return &r; } }()).length; } import std.stdio; void main() { writef("%d\n", IndexOf!("hello", "go", "say", "hello", "to", "bob")); } But Gahh!!!
Dec 01 2008
parent Sergey Gromov <snake.scaly gmail.com> writes:
Mon, 1 Dec 2008 22:49:24 +0000 (UTC), BCS wrote:

 Reply to Jason,
 
 No recursive template-foo needed

template IndexOf(char[] str, Strs...) { const int IndexOf = typeof( *{ foreach(int i, char[] s; Strs) { static char[i] r; static if(Strs[i] == str) return &r; } }()).length; } import std.stdio; void main() { writef("%d\n", IndexOf!("hello", "go", "say", "hello", "to", "bob")); }

Master!
Dec 04 2008
prev sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Bill Baxter:
 Tuples have an annoying "auto-flattening" behavior which means that
 it's difficult to create very advanced data structures out of them.

This has to change in D2. Perl shows why that's bad. To replace all the current semantics you can just to add a syntax that performs as an 'apply' (Python uses a * for this, but D probably needs a different syntax). Time ago I have created some machinery to represent arbitrarily nested "arrays" into a tuple, using an encoding that can represent all the lengths of the sub-sub-sub-etc "arrays", but it's complex, and probably uses too much resources during compile-time, so something more native is better. Bye, bearophile
Dec 01 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
Bill Baxter:

What about Perl shows that auto-flattening is bad?<

You can find a note here: http://steve.yegge.googlepages.com/ancient-languages-perl

x = (1, 2, 3, (4, 5)); It automagically turns into (1, 2, 3, 4, 5). < With Google you can find many other pages that about that anti-feature. The new version of Perl, that is in development from some years, fixes this, I think. The ability of creating trees with arbitrary nested tuples/arrays is really handy (I don't know if the variant type of Tango allows to do this. The boxed of Phobos doesn't allow it, I think).
Isn't there an easier way to fake it using structs?<

In my dlibs I've added a Record/record that can be used a little as a Python tuple, the Record can be found here: http://www.fantascienza.net/leonardo/so/dlibs/templates.html Bye, bearophile
Dec 02 2008
parent bearophile <bearophileHUGS lycos.com> writes:
Bill Baxter:
 and I implemented it again this morning.

I presume my version is "better" :-) I have written it along one year of time. Bye, bearophile
Dec 02 2008
prev sibling next sibling parent reply "Bill Baxter" <wbaxter gmail.com> writes:
On Tue, Dec 2, 2008 at 9:39 AM, bearophile <bearophileHUGS lycos.com> wrote:
 Bill Baxter:
 Tuples have an annoying "auto-flattening" behavior which means that
 it's difficult to create very advanced data structures out of them.

This has to change in D2. Perl shows why that's bad.

My Perl is rusty. What about Perl shows that auto-flattening is bad?
 To replace all the current semantics you can just to add a syntax that
performs as an 'apply' (Python uses a * for this, but D probably needs a
different syntax).

Yeh, probably this is the idea that comes to anyone familiar with Python. Preserve the packaging of a tuple by default, require some op to "explode" the contents back out into a list. But then that
 Time ago I have created some machinery to represent arbitrarily nested
"arrays" into a tuple, using an encoding that can represent all the lengths of
the sub-sub-sub-etc "arrays", but it's complex, and probably uses too much
resources during compile-time, so something more native is better.

Isn't there an easier way to fake it using structs? Like template Tuple(T...) { alias T Tuple } struct STuple(T...) { alias T tuple; } alias Tuple!(STuple(int,float), STuple(string,double), int, creal) CantFlattenThis; And you can write flatteners and nesters for that. Seems like fun, maybe I'll waste a few minutes working on that. :-) --bb
Dec 01 2008
next sibling parent BCS <ao pathlink.com> writes:
Reply to Bill,

 Isn't there an easier way to fake it using structs? Like
 template Tuple(T...) { alias T Tuple }
 struct STuple(T...) { alias T tuple; }
 alias Tuple!(STuple(int,float), STuple(string,double), int, creal)
 CantFlattenThis;
 
 And you can write flatteners and nesters for that. Seems like fun,
 maybe I'll waste a few minutes working on that. :-)
 
 --bb
 

Yes, that works well. I make lots of use of that in dparse. I end up with a struct type that contains the whole AST defining the grammar to be parsed. OTOH there is issues (bugs) with aliases when you try to access it under some conditions.
Dec 01 2008
prev sibling parent "Bill Baxter" <wbaxter gmail.com> writes:
On Tue, Dec 2, 2008 at 10:14 AM, BCS <ao pathlink.com> wrote:
 Reply to Bill,

 Isn't there an easier way to fake it using structs? Like
 template Tuple(T...) { alias T Tuple }
 struct STuple(T...) { alias T tuple; }
 alias Tuple!(STuple(int,float), STuple(string,double), int, creal)
 CantFlattenThis;

 And you can write flatteners and nesters for that. Seems like fun,
 maybe I'll waste a few minutes working on that. :-)

 --bb

Yes, that works well. I make lots of use of that in dparse. I end up with a struct type that contains the whole AST defining the grammar to be parsed. OTOH there is issues (bugs) with aliases when you try to access it under some conditions.

I thought I'd seen it somewhere before. But I couldn't resist a little early morning tuple coding challenge. So here it is. template Tuple(T...) { alias T Tuple; } struct STuple(T...) { alias T tuple; } /** This helper is necessary because the check is(T[0].tuple) gives a compiler error */ template Flatten1(T) { static if (is(T.tuple)) { alias T.tuple Flatten1; } else { alias T Flatten1; } } /// Remove STuples from the tuple T template Flatten(T...) { static if (T.length == 0) { alias T Flatten; } else static if (T.length == 1) { alias Flatten1!(T[0]) Flatten; } else { alias Tuple!(Flatten!(T[0]),Flatten!(T[1..$])) Flatten; } } /// Nest each element of T in a STuple template Nest(T...) { static if (T.length == 0) { alias T Nest; } else static if (T.length == 1) { alias STuple!(T) Nest; } else { alias Tuple!(STuple!(T[0]), Nest!(T[1..$])) Nest; } } void main() { alias Tuple!(STuple!(int,float), STuple!(string,double), int, creal) X; pragma(msg,X.stringof); alias Flatten!(X) FlatX; pragma(msg,FlatX.stringof); alias Nest!(FlatX) NestFlatX; pragma(msg, NestFlatX.stringof); } And the output: """ (STuple!(int,float), STuple!(char[],double), int, creal) (int, float, char[], double, int, creal) (STuple!(int), STuple!(float), STuple!(char[]), STuple!(double), STuple!(int), STuple!(creal)) """
Dec 01 2008
prev sibling next sibling parent "Bill Baxter" <wbaxter gmail.com> writes:
On Tue, Dec 2, 2008 at 7:26 PM, bearophile <bearophileHUGS lycos.com> wrote:
 Bill Baxter:

What about Perl shows that auto-flattening is bad?<

You can find a note here: http://steve.yegge.googlepages.com/ancient-languages-perl

x = (1, 2, 3, (4, 5)); It automagically turns into (1, 2, 3, 4, 5). <

Wow, I guess it really has been a long time for me and Perl. Don't recall that little quirk at all.
 The ability of creating trees with arbitrary nested tuples/arrays is really
handy (I don't know if the variant type of Tango allows to do this. The boxed
of Phobos doesn't allow it, I think).

Isn't there an easier way to fake it using structs?<

In my dlibs I've added a Record/record that can be used a little as a Python tuple, the Record can be found here: http://www.fantascienza.net/leonardo/so/dlibs/templates.html

Hmm, but just to play devils advocate here, you've implemented it, BCS implemented, and I implemented it again this morning. That would seem to argue that the current state is fine, the unflattenable tuple type just needs to be in the standard lib(s) so people don't have to keep rolling their own. (Personally I agree non-flattening would be better and argued for it soon after Tuples came out, but somehow I doubt Walter's going to be convinced to break a significant amount of Tuple-using template code without a more ... convincing argument. Something like a demonstration of some of BCS's compile-time parser written with and without auto-flattening tuples showing a dramatic reduction in code for the no-flattening case.) --bb
Dec 02 2008
prev sibling parent "Bill Baxter" <wbaxter gmail.com> writes:
On Tue, Dec 2, 2008 at 10:01 PM, bearophile <bearophileHUGS lycos.com> wrote:
 Bill Baxter:
 and I implemented it again this morning.

I presume my version is "better" :-) I have written it along one year of time.

I'm sure if you have spent that much time on your lib that it can do far more than flatten and unflatten a tuple. But I'm just talking about unflattenable tuples. I can't imagine that your version of the flatten/unflatten routines are that much different from what I wrote. There's only so many ways to skin that cat. --bb
Dec 02 2008