## digitalmars.D.learn - Adjacent Pairs Range

=?UTF-8?B?Ik5vcmRsw7Z3Ig==?= <per.nordlow gmail.com> writes:
```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)]
```
Sep 12 2015
Bahman Movaqar <Bahman BahmanM.com> writes:
```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
```
Sep 12 2015
=?UTF-8?B?Ik5vcmRsw7Z3Ig==?= <per.nordlow gmail.com> writes:
```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]]

```
Sep 12 2015
Bahman Movaqar <Bahman BahmanM.com> writes:
```On 09/12/2015 03:09 PM, "Nordlöw" wrote:

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
```
Sep 12 2015
Bahman Movaqar <Bahman BahmanM.com> writes:
```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
```
Sep 12 2015
=?UTF-8?B?Ik5vcmRsw7Z3Ig==?= <per.nordlow gmail.com> writes:
```On Saturday, 12 September 2015 at 11:34:03 UTC, Bahman Movaqar
wrote:
On 09/12/2015 03:09 PM, "Nordlöw" wrote:

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

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.
```
Sep 12 2015
=?UTF-8?B?Ik5vcmRsw7Z3Ig==?= <per.nordlow gmail.com> writes:
```On Saturday, 12 September 2015 at 11:46:55 UTC, Nordlöw wrote:

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?
```
Sep 12 2015
deed <none none.none> writes:
```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 .. \$])

?
```
Sep 12 2015
=?UTF-8?B?Tm9yZGzDtnc=?= <per.nordlow gmail.com> writes:
```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)
```
Sep 13 2015
Sebastiaan Koppe <mail skoppe.eu> writes:
```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)]
}
```
```
Sep 13 2015
Per =?UTF-8?B?Tm9yZGzDtnc=?= <per.nordlow gmail.com> writes:
```On Monday, 14 September 2015 at 05:37:05 UTC, Sebastiaan Koppe
wrote:
What about using zip and a slice?

Slicing requires a RandomAccessRange (Array). This is too
restrictive. We want to change operations such as adjacentTuples
with for example map and reduce without the need for temporary
copies of the whole range. This is the thing about D's standard
library.

Read up on D's range concepts.
```
Sep 14 2015
Per =?UTF-8?B?Tm9yZGzDtnc=?= <per.nordlow gmail.com> writes:
```On Monday, 14 September 2015 at 10:45:52 UTC, Per Nordlöw wrote:
restrictive. We want to change operations such as

Correction:

We want to *chain* operations such as...
```
Sep 14 2015
Sebastiaan Koppe <mail skoppe.eu> writes:
```On Monday, 14 September 2015 at 10:45:52 UTC, Per Nordlöw wrote:
On Monday, 14 September 2015 at 05:37:05 UTC, Sebastiaan Koppe
wrote:
What about using zip and a slice?

Slicing requires a RandomAccessRange (Array). This is too
restrictive. We want to change operations such as
adjacentTuples with for example map and reduce without the need
for temporary copies of the whole range. This is the thing