D issues are now tracked on GitHub. This Bugzilla instance remains as a read-only archive.
Issue 9611 - std.algorithm.nWayUnion(Tuple) too?
Summary: std.algorithm.nWayUnion(Tuple) too?
Status: ASSIGNED
Alias: None
Product: D
Classification: Unclassified
Component: phobos (show other issues)
Version: D2
Hardware: All All
: P4 enhancement
Assignee: Andrei Alexandrescu
URL:
Keywords:
Depends on:
Blocks:
 
Reported: 2013-02-27 15:12 UTC by bearophile_hugs
Modified: 2024-12-01 16:16 UTC (History)
2 users (show)

See Also:

Attachments
Add an attachment (proposed patch, testcase, etc.)

Note You need to log in before you can comment on or make changes to this issue.
Description bearophile_hugs 2013-02-27 15:12:43 UTC 
In some cases I have had to merge ranges of different type. So maybe for such situations it's worth supporting nWayUnion of a Tuple of ranges:


import std.algorithm: nWayUnion, map;
import std.range: iota;
import std.typecons: tuple;
void main() {
    auto a = iota(10);
    auto b = [3, 6, 9];
    auto c = iota(11).map!q{a * a};
    auto r = nWayUnion(tuple(a, b, c));
}


Note: in all such of my usage cases the number of the ranges was limited, 2 or 3. So when the input of nWayUnion is a tuple I think there is no need for nWayUnion to keep the ranges inside with a BinaryHeap.

- - - - - - - - - - - - - -

Current workaround, suggested by Ali Çehreli:

import std.algorithm: nWayUnion, map;
import std.range: iota, InputRange, inputRangeObject;
void main() {
    InputRange!int a = inputRangeObject(iota(10));
    InputRange!int b = inputRangeObject([3, 6, 9]);
    InputRange!int c = inputRangeObject(iota(11).map!q{a * a});
    auto r = nWayUnion([a, b, c]);
}
Comment 1 Chris Cain 2013-02-27 17:13:37 UTC 
(In reply to comment #0)
> Current workaround, suggested by Ali Çehreli:
> 
> import std.algorithm: nWayUnion, map;
> import std.range: iota, InputRange, inputRangeObject;
> void main() {
>     InputRange!int a = inputRangeObject(iota(10));
>     InputRange!int b = inputRangeObject([3, 6, 9]);
>     InputRange!int c = inputRangeObject(iota(11).map!q{a * a});
>     auto r = nWayUnion([a, b, c]);
> }

A function that does the conversion to InputRange!E could easily be created and added to Phobos to handle this type of situation. Ranges such as nWayUnion could call this (currently poorly named) tupWrapper when isTuple!T returns true.

---

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

void main() {
	auto tup = tuple(iota(5), repeat(1).take(3), [5,9,30]);

	foreach(e; tupWrapper(tup).nWayUnion())
		writeln(e);
}

auto tupWrapper(Tup)(Tup tup) {
	alias E = ElementType!(Tup.Types[0]);
	InputRange!E[] arr;
	foreach(T; Tup.Types)
		static assert(is(ElementType!T == E));

	foreach(ref e; tup)
		arr ~= inputRangeObject(e);

	return arr;
}

---

Currently, that solution isn't too robust. Ideally it would figure out the most powerful range type (either InputRange, ForwardRange, ..., RandomAccessRange) that all the types in the Tuple.Types support and it would return that.
Comment 2 bearophile_hugs 2013-02-27 17:24:55 UTC 
(In reply to comment #1)

> A function that does the conversion to InputRange!E could easily be created and
> added to Phobos to handle this type of situation.

I think InputRange and inputRangeObject are not needed to solve this. A "static foreach" on the Tuple fields (that contain ranges) looking for the smallest value seems enough to me.
Comment 3 Andrei Alexandrescu 2013-02-27 17:43:45 UTC 
Yah, this should be added. Suffice to add a one-argument member function to SortedRange.
Comment 4 dlangBugzillaToGithub 2024-12-01 16:16:43 UTC 
THIS ISSUE HAS BEEN MOVED TO GITHUB

https://github.com/dlang/phobos/issues/9957

DO NOT COMMENT HERE ANYMORE, NOBODY WILL SEE IT, THIS ISSUE HAS BEEN MOVED TO GITHUB