ref tuples

[Artur Skawina]

On 07/03/13 19:10, Brad Anderson wrote:
> On Wednesday, 3 July 2013 at 16:35:18 UTC, Artur Skawina wrote:
>> On 07/03/13 18:29, Brad Anderson wrote:
>>> On Wednesday, 3 July 2013 at 11:54:39 UTC, Artur Skawina wrote:
>>>> On 07/03/13 02:22, Brad Anderson wrote:
>>>>> C++11's std::tuple includes a function std::tie that takes references to the arguments and returns a tuple that maintains the references to the arguments.
>>>>>
>>>>> Along with the usual cases where you'd want reference semantics it also enables this interesting construct for unpacking tuples.
>>>>>
>>>>> int a, b;
>>>>> tie(a, b) = make_tuple(1, 2);
>>>>>
>>>>> assert(a == 1 && b == 2);
>>>>>
>>>>> Is there any way to do something similar with std.typecons.Tuple?
>>>>
>>>> Well, aliases can be used to get a similar effect.
>>>>
>>>>    template tie(A...) { alias tie = A; }
>>>>    tie!(a, b) = tuple(1, 2);
>>>
>>> That won't work.  a and b aren't held as references (also you passed them as type parameters :P).
>>
>> Try it...
>>
>> And, yes, the fact that 'A...' template parms accept symbols
>> is not exactly obvious. But it's much more useful that way.
>>
>> artur
> 
> Huh, I had no idea you could do something like that. I stand corrected. Thanks.
> 
> That does get tie = working but doesn't work if you want to pass it around which is actually more at the heart of what I'm interested in.
> 
> To get straight to the point, I was playing around with implementing bearophile's enumerate() feature request (something I've wanted myself).  Both his posted solution [1] and my own quick testing hack (auto enumerate(Range)(Range r) { return zip(sequence!"n"(), r); }) lose the ability to do ref elements in foreach that can modify the source range:
> 
> ---
> auto a = ["a", "b", "c"];
> foreach(i, ref item; a.enumerate())
>   item = to!string(i);
> 
> assert(a == ["0", "1", "2"]); // fails, a is still ["a", "b", "c"]
> ---
> 
> They don't work because both the tuples he returns from front and the tuples zip creates aren't references to the originals so you are just changing the copy stored in the tuple.
> 
> Something like "alias RefIntTuple = Tuple!(ref int, ref int);" gives a compiler error (Error: expression expected, not 'ref').
> 
> 1. http://d.puremagic.com/issues/show_bug.cgi?id=5550#c2

D does not yet have proper ref types, which means a lot of things
are not possible, at least not directly. And a lot of hacks are
required to achieve certain effects. Anyway, the following seems
to work - it's bearophiles code from the mentioned bugzilla entry
with some tweaks.

It's dirty enough, so I shouldn't be posting this on a 'learn'
ML... It's meant more as an illustration of the language deficiencies.
Please do not use anything like this. :)


   import std.stdio, std.algorithm, std.range, std.typecons, std.traits, std.array;

   struct RefHack(T) {
      T* ptr;
      ref get() @property { return *ptr; }
      alias get this;
   }
   auto refHack(T)(ref T a) { return RefHack!T(&a); }

   struct Enumerate(R) {
       R r;
       int i;

       @property bool empty() { return r.empty; }

       @property Tuple!(typeof(this.i), typeof(refHack(r.front))) front() {
           return typeof(return)(i, refHack(r.front));
       }

       void popFront() {
           this.r.popFront();
           this.i++;
       }
   }

   Enumerate!R enumerate(R)(R range, int start=0) if (isInputRange!R) {
       return Enumerate!R(range, start);
   }

   void main() {
       auto flags = [0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1];

       flags.enumerate(2).filter!q{!a[1]}().map!q{a[0]}().writeln();

       {
          import std.conv;
          auto a = ["a", "b", "c"];

          foreach(i, ref item; a.enumerate())
             item = to!string(i);

          assert(a == ["0", "1", "2"]);
       }
   }


artur