Split string at given positions - raku

Question

How do i nicely/idiomatically split a string at a list of positions?
What I have:
.say for split-at( "0019ABX26002", (3, 4, 8) );
sub split-at( $s, #positions )
{
my $done = 0;
gather
{
for #positions -> $p
{
take $s.substr($done, $p - $done );
$done = $p;
}
take $s.substr( $done, * );
}
}
which is reasonable. I am puzzled by the lack of language support for this though. If "split on" is a thing, why isn't "split at" too? I think this should be a core operation. I should be able to write
.say for "0019ABX26002".split( :at(3, 4, 8) );
Or maybe I am overlooking something?
Edit: A little Benchmark of what we have so far
O------------O---------O------------O--------O-------O-------O
| | Rate | array-push | holli | raiph | simon |
O============O=========O============O========O=======O=======O
| array-push | 15907/s | -- | -59% | -100% | -91% |
| holli | 9858/s | 142% | -- | -100% | -79% |
| raiph | 72.8/s | 50185% | 20720% | -- | 4335% |
| simon | 2901/s | 1034% | 369% | -98% | -- |
O------------O---------O------------O--------O-------O-------O
Code:
use Bench;
my $s = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbccccddddddddddddddddddddddddddddddddddddefggggggggggggggggggg";
my #p = 29, 65, 69, 105, 106, 107;
Bench.new.cmpthese(1000, {
holli => sub { my # = holli($s, #p); },
simon => sub { my # = simon($s, #p); },
raiph => sub { my # = raiph($s, #p); },
array-push => sub { my # = array-push($s, #p); },
});
#say user($s, #p);
sub simon($str, *#idxs ) {
my #rotors = #idxs.map( { state $l = 0; my $o = $_ - $l; $l = $_; $o } );
$str.comb("").rotor( |#rotors,* ).map(*.join(""));
}
sub raiph($s, #p) {
$s.split( / <?{$/.pos == any(#p)}> / )
}
sub holli( $s, #positions )
{
my $done = 0;
gather
{
for #positions -> $p
{
take $s.substr($done, $p - $done );
$done = $p;
}
take $s.substr( $done, * );
}
}
sub array-push( $s, #positions )
{
my $done = 0;
my #result;
for #positions -> $p
{
#result.push: $s.substr($done, $p - $done );
$done = $p;
}
#result.push: $s.substr( $done, * );
#result;
}

Answer 1

Personally I'd split it into a list, use rotor to divide the list up and join the result :
"0019ABX26002".comb().rotor(3,1,4,*).map(*.join)
If you want a split at function (using the indexes given) :
sub split-at( $str, *#idxs ) {
my #rotors = #idxs.map( { state $l = 0; my $o = $_ - $l; $l = $_; $o } );
$str.comb("").rotor( |#rotors,* ).map(*.join(""));
}
Basically if I want to do list type stuff I use a list.
I came up with another version that I really like from a functional programming sense :
sub split-at( $str, *#idxs ) {
(|#idxs, $str.codes)
==> map( { state $s = 0;my $e = $_ - $s;my $o = [$s,$e]; $s = $_; $o } )
==> map( { $str.substr(|$_) } );
}
It works out to be slightly slower than the other one.

Answer 2

One way:
.say for "0019ABX26002" .split: / <?{ $/.pos ∈ (3,4,8) }> /
displays:
001
9
ABX2
6002

Answer 3

Because each substring does not depend on the other, hyper becomes an option.
method split-at(\p) {
do hyper for (0,|p) Z (|p,self.chars) {
self.substr: .head, .tail - .head
}
}
Or in sub form:
sub split-at(\s, \p) {
do hyper for (0,|p) Z (|p,s.chars) {
s.substr: .head, .tail - .head
}
}
But the overhead involved is not worth it unless the number of elements requested is extreme — in my tests it's about ten times slower than the naïve form.

Answer 4

Here's the solution I would use:
my method break (Str \s: *#i where .all ~~ Int) {
gather for #i Z [\+] 0,|#i -> ($length, $start) {
take s.substr: $start, $length
}
}
say "abcdefghi".&break(2,3,4) # "ab","cde","fghi"
The gather/take lets it be lazy if you ultimately don't need to use all of them. The loop takes #i (2,3,4 in the example) and zips it up with the cascading addition reducer [\+], which would normally produce 2,5,9, but we insert a 0 to make it 0,2,5,9 to mark the starting indexes of each one. This lets the actual take be a simple substr operation.
By making it a method instead of a sub, you can use it just like you would (you could even name it split if you want, the addition of the & sigil means Raku won't be confused whether you want the built in or custom made one.
You could, even, add it directly to Str:
use MONKEY-TYPING; # enable augment
augment class Str {
multi method split (Str \s: *#i where .all ~~ Int) {
gather for #i Z [\+] 0,|#i -> ($length, $start) {
take s.substr: $start, $length
}
}
}
say "abcdefghi".split(2,3,4)
In this case, it needs to be defined as multi method since there are already various split methods. The nice thing is since none of those are defined by only Int arguments, it's easy to ensure our augmented one gets used.
That said, calling it using the sigiled version in a lexical method is definitely the better one.