On Saturday, 5 December 2015 at 01:03:05 UTC, Andrei Alexandrescu
wrote:
What exactly doesn't work?
Forward ranges.
I see; retro requires a bidirectional range.
I was thinking about
void main()
{
import std.algorithm : count;
import std.range : drop;
import
On Friday, 4 December 2015 at 16:37:36 UTC, Andrei Alexandrescu
wrote:
Takers?
https://github.com/D-Programming-Language/phobos/pull/3855
On 2015-12-04 23:33, Andrei Alexandrescu wrote:
retro + take?
Try it! -- Andrei
One would need another "retro" as well. But I see now that you have
replied it doesn't work for forward ranges.
--
/Jacob Carlborg
On 12/05/2015 11:22 AM, Sebastiaan Koppe wrote:
What about using a rangified circular buffer of the same size you want
the tail to be, and lazily fill it?
That's O(n) space :o). -- Andrei
On Saturday, 5 December 2015 at 20:52:23 UTC, Andrei Alexandrescu
wrote:
On 12/05/2015 11:22 AM, Sebastiaan Koppe wrote:
What about using a rangified circular buffer of the same size
you want
the tail to be, and lazily fill it?
That's O(n) space :o). -- Andrei
I know, but it makes half
Like "tail" in Unix. Given a range R r and a number size_t n, return a
TakeExactly!R that's r at no more than n steps from its end:
TakeExactly!R advanceWithin(R)(R r, size_t n)
if (isForwardRange!R);
Invariant:
assert(r.advanceWithin(n).length <= n);
Implementation would send a scout range
On Friday, 4 December 2015 at 22:53:01 UTC, Andrei Alexandrescu
wrote:
Doesn't work. Try it!
void main()
{
import std.range : retro, take;
import std.stdio : writeln;
assert([1,2,3,4,5].retro.take(3).retro == [3,4,5]);
}
What exactly doesn't work?
On 2015-12-04 17:37, Andrei Alexandrescu wrote:
Like "tail" in Unix. Given a range R r and a number size_t n, return a
TakeExactly!R that's r at no more than n steps from its end:
TakeExactly!R advanceWithin(R)(R r, size_t n)
if (isForwardRange!R);
Invariant:
assert(r.advanceWithin(n).length
On Friday, 4 December 2015 at 20:01:10 UTC, Jacob Carlborg wrote:
On 2015-12-04 17:37, Andrei Alexandrescu wrote:
Like "tail" in Unix. Given a range R r and a number size_t n,
return a
TakeExactly!R that's r at no more than n steps from its end:
TakeExactly!R advanceWithin(R)(R r, size_t n)
On 12/04/2015 03:01 PM, Jacob Carlborg wrote:
On 2015-12-04 17:37, Andrei Alexandrescu wrote:
Like "tail" in Unix. Given a range R r and a number size_t n, return a
TakeExactly!R that's r at no more than n steps from its end:
TakeExactly!R advanceWithin(R)(R r, size_t n)
if (isForwardRange!R);
On 12/04/2015 04:26 PM, wobbles wrote:
r.retro.take(n).retro seems like the easiest fit.
Doesn't work. Try it!
The right solution is to send a scout range ahead. Once the scout got n
steps ahead the initial range, advance both until the scout reaches the
end. Then return the initial range.
On 12/04/2015 06:09 PM, Sebastiaan Koppe wrote:
On Friday, 4 December 2015 at 22:53:01 UTC, Andrei Alexandrescu wrote:
Doesn't work. Try it!
void main()
{
import std.range : retro, take;
import std.stdio : writeln;
assert([1,2,3,4,5].retro.take(3).retro == [3,4,5]);
}
What
12 matches
Mail list logo
