On Friday, 3 October 2014 at 17:06:41 UTC, Nordlöw wrote:
On Friday, 3 October 2014 at 16:32:24 UTC, monarch_dodra wrote:
If anything, I'd have expected you to provide something
returns the popped element. What you do pops an element, and
then returns the *next* one. What good is that?
My mistake. It's fixed now.
Well, yes and no. You are still providing a moveFront that does
not conform to what the range interface expects. EG:
auto app = appender();
auto myRange = slidingSplitter([1, 2, 3]);
for ( ; !myRange.empty ; myRange.popFront() )
app.put(myRange.moveFront());
As you can see from this code snippet, moveFront is not expected
to pop. At all. As a matter of fact, this will error out during
runtime, as the loop will attempt a pop on an empty range.
IMO, you should just leave it out.
Also, what you want to check is "hasSlicing", which is more
powerful than "isRA". Speaking of which, if you don't have
"isRA", it looks like your range errors out (no "front").
Ok. Fixed know.
There's still the issue that if you don't have slicing, then your
range doesn't have "front" at all. You might as well just make it
a general template restriction.
Your sliding splitter does not handle narrow strings. I'd have
thought that was the original goal. Well, it is better to not
support it at all of course, rather than doing it wrong :)
That's part of episode 2, for now ;)
Cool.
More things I saw:
Don't make opIndex const. You have no guarantee R.opindex is
const.
Also, "opSlice()" is not a range primitive. You can implement it,
it's basically just a no-op. The one that's important is
"opSlice(lhs, rhs)".
Also, no point in returning an "auto ref" from "slidingSplitter",
you *know* it's an rvalue.
If your implementation use two ranges that you slice "on the
fly", then you can trivially support strings, thanks to popFront.
I threw this together. I left out checks for infinity in favor of
brevity:
//----
import std.range, std.stdio;
import std.typecons: Tuple, tuple;
struct SlidingSplitter(R)
if (hasSlicing!R || isSomeString!R)
{
this(R)(R data)
{
_original = data;
_right = data.save;
}
auto front() @property
{
return tuple(_original[0 .. $ - _right.length], _right);
}
void popFront()
{
if (_right.empty)
_original = _right;
else
_right.popFront();
}
bool empty() const { return _original.empty; }
static if (hasSlicing!R)
{
auto opIndex(size_t i)
{
return tuple(
_original[0 .. i + $ - _right.length],
_right[i .. $]);
}
size_t length() { return _right.length + 1; }
}
private R _original;
private R _right;
}
auto slidingSplitter(R)(R data)
{
return SlidingSplitter!R(data);
}
void main()
{
{
auto r = slidingSplitter([1, 2, 3]);
writefln("r.length: %s", r.length);
writefln("r[1]: %s", r[1]);
writefln("r[2]: %s", r[2]);
}
{
writefln("%(%s\n%)", slidingSplitter("Nordlöw"));
}
}
//----
Output:
r.length: 4
r[1]: Tuple!(int[], int[])([1], [2, 3])
r[2]: Tuple!(int[], int[])([1, 2], [3])
Tuple!(string, string)("", "Nordlöw")
Tuple!(string, string)("N", "ordlöw")
Tuple!(string, string)("No", "rdlöw")
Tuple!(string, string)("Nor", "dlöw")
Tuple!(string, string)("Nord", "löw")
Tuple!(string, string)("Nordl", "öw")
Tuple!(string, string)("Nordlö", "w")
Tuple!(string, string)("Nordlöw", "")
