Function std.algorithm.searching.findSplit
These functions find the first occurrence of needle
in haystack
and then
split haystack
as follows.
auto findSplit(alias pred, R1, R2)
(
R1 haystack,
R2 needle
)
if (isForwardRange!R1 && isForwardRange!R2);
findSplit
returns a tuple result
containing three ranges.
result[0]
is the portion ofhaystack
beforeneedle
result[1]
is the portion ofhaystack
that matchesneedle
result[2]
is the portion ofhaystack
after the match.
needle
was not found, result[0]
comprehends haystack
entirely and result[1]
and result[2]
are empty.
findSplitBefore
returns a tuple result
containing two ranges.
result[0]
is the portion ofhaystack
beforeneedle
result[1]
is the balance ofhaystack
starting with the match.
needle
was not found, result[0]
comprehends haystack
entirely and result[1]
is empty.
findSplitAfter
returns a tuple result
containing two ranges.
result[0]
is the portion ofhaystack
up to and including the matchresult[1]
is the balance ofhaystack
starting after the match.
needle
was not found, result[0]
is empty
and result[1]
is haystack
.
In all cases, the concatenation of the returned ranges spans the
entire haystack
.
If haystack
is a random-access range, all three components of the tuple have
the same type as haystack
. Otherwise, haystack
must be a
forward range and
the type of result[0]
(and result[1]
for findSplit
) is the same as
the result of std
.
For more information about pred
see find
.
Parameters
Name | Description |
---|---|
pred | Predicate to compare 2 elements. |
haystack | The forward range to search. |
needle | The forward range to look for. |
Returns
A sub-type of Tuple
of the split portions of haystack
(see above for
details). This sub-type of Tuple
defines opCast!bool
, which
returns true
when the separating needle
was found and false
otherwise.
See Also
Example
Returning a subtype of Tuple
enables
the following convenient idiom:
// findSplit returns a triplet
if (auto split = "dlang-rocks" .findSplit("-"))
{
writeln(split[0]); // "dlang"
writeln(split[1]); // "-"
writeln(split[2]); // "rocks"
}
else assert(0);
// findSplitBefore returns 2 ranges
if (const split = [2, 3, 2, 3, 4, 1] .findSplitBefore!"a > b"([2, 2]))
{
writeln(split[0]); // [2, 3, 2]
// [3, 4] each greater than [2, 2]
writeln(split[1]); // [3, 4, 1]
}
else assert(0);
Example
import std .range .primitives : empty;
auto a = "Carl Sagan Memorial Station";
auto r = findSplit(a, "Velikovsky");
import std .typecons : isTuple;
static assert(isTuple!(typeof(r .asTuple)));
static assert(isTuple!(typeof(r)));
assert(!r);
writeln(r[0]); // a
assert(r[1] .empty);
assert(r[2] .empty);
r = findSplit(a, " ");
writeln(r[0]); // "Carl"
writeln(r[1]); // " "
writeln(r[2]); // "Sagan Memorial Station"
if (const r1 = findSplitBefore(a, "Sagan"))
{
assert(r1);
writeln(r1[0]); // "Carl "
writeln(r1[1]); // "Sagan Memorial Station"
}
if (const r2 = findSplitAfter(a, "Sagan"))
{
assert(r2);
writeln(r2[0]); // "Carl Sagan"
writeln(r2[1]); // " Memorial Station"
}
Example
Use std
to find single elements:
import std .range : only;
writeln([1, 2, 3, 4] .findSplitBefore(only(3))[0]); // [1, 2]