How do I most elegantly iterate all the adjacent pairs in an `InputRange` using Phobos?

Something like

    [1,2,3,4] => [(1,2), (2,3), (3,4)]

On 09/12/2015 02:47 PM, "Nordlöw" wrote:
> How do I most elegantly iterate all the adjacent pairs in an `InputRange` using Phobos?
> 
> Something like
> 
>     [1,2,3,4] => [(1,2), (2,3), (3,4)]

That's call `collate`ing IIRC.
A quick solution would be using `std.range.transposed`:

auto a = [1,2,3,4];
auto ll = [a, a[1..$]];
transpose(ll); // returns [[1, 2], [2, 3], [3, 4], [4]]

Though you have to take care of the dangling last element yourself.

-- 
Bahman Movaqar

On Saturday, 12 September 2015 at 10:35:41 UTC, Bahman Movaqar wrote:
> On 09/12/2015 02:47 PM, "Nordlöw" wrote:
>> How do I most elegantly iterate all the adjacent pairs in an `InputRange` using Phobos?
>> 
>> Something like
>> 
>>     [1,2,3,4] => [(1,2), (2,3), (3,4)]
>
> That's call `collate`ing IIRC.
> A quick solution would be using `std.range.transposed`:
>
> auto a = [1,2,3,4];
> auto ll = [a, a[1..$]];
> transpose(ll); // returns [[1, 2], [2, 3], [3, 4], [4]]

InputRange please, not RandomAccessRanges ;)

On 09/12/2015 03:09 PM, "Nordlöw" wrote:
> InputRange please, not RandomAccessRanges ;)

Oops!  Here's one using only `InputRange` interface:

    T[][] collate(T)(T[] a)
    {
      alias CollateResult = Tuple!(T[][], "result", T, "tlHd");
      CollateResult _collate(CollateResult collres)
      {
        if (!a.empty) {
          auto newTlHd = a.front;
          a.popFront();
          return _collate(
            CollateResult(
              collres.result ~ [collres.tlHd, newTlHd],
              newTlHd
            )
          );
        } else {
          return collres;
        }
      }

      if (!a.empty) {
        auto tlHd = a.front;
        a.popFront();
        return _collate(
          CollateResult([], tlHd)
        ).result;
      } else {
        return [];
      }
    }

    unittest {
      writeln([10, 20, 30].collate!int);
    }


-- 
Bahman Movaqar

On 09/12/2015 04:04 PM, Bahman Movaqar wrote:
> Oops!  Here's one using only `InputRange` interface:

I believe I need to warn you that I'm just learning D; so take my solution at your own risk :-)

-- 
Bahman Movaqar

On Saturday, 12 September 2015 at 11:34:03 UTC, Bahman Movaqar wrote:
> On 09/12/2015 03:09 PM, "Nordlöw" wrote:
>> InputRange please, not RandomAccessRanges ;)
>
> Oops!  Here's one using only `InputRange` interface:

I wrote my own as adjacentTuples and adjacentPairs:

https://github.com/nordlow/justd/blob/master/range_ex.d#L702

Note: No yet extended to N > 2.

An alternative naming would be overlappingTuples/Pairs.

On Saturday, 12 September 2015 at 11:46:55 UTC, Nordlöw wrote:
> I wrote my own as adjacentTuples and adjacentPairs:
>
> https://github.com/nordlow/justd/blob/master/range_ex.d#L702
>
> Note: No yet extended to N > 2.
>
> An alternative naming would be overlappingTuples/Pairs.

Should this go into Phobos?

On Saturday, 12 September 2015 at 10:17:19 UTC, Nordlöw wrote:
> How do I most elegantly iterate all the adjacent pairs in an `InputRange` using Phobos?
>
> Something like
>
>     [1,2,3,4] => [(1,2), (2,3), (3,4)]

Why not just:

zip(arr[0 .. $-1], arr[1 .. $])

?

On Sunday, 13 September 2015 at 01:49:56 UTC, deed wrote:
> zip(arr[0 .. $-1], arr[1 .. $])
>
> ?

Assumes arrays. Better is

    zip(arr.dropOne, arr)

On Saturday, 12 September 2015 at 10:17:19 UTC, Nordlöw wrote:
> How do I most elegantly iterate all the adjacent pairs in an `InputRange` using Phobos?
>
> Something like
>
>     [1,2,3,4] => [(1,2), (2,3), (3,4)]

What about using zip and a slice?

```
void main()
{
	auto a = [1,2,3,4];
	import std.range : zip;
	import std.stdio;
	writeln(a.zip(a[1..$])); // [Tuple!(int, int)(1, 2), Tuple!(int, int)(2, 3), Tuple!(int, int)(3, 4)]
}
```