The use of flip-flop operator in Perl 6 - raku

Question

I see the use of flip-flop in doc.perl6.org, see the code below :
my $excerpt = q:to/END/;
Here's some unimportant text.
=begin code
This code block is what we're after.
We'll use 'ff' to get it.
=end code
More unimportant text.
=begin code
I want this line.
and this line as well.
HaHa
=end code
More unimport text.
=begin code
Let's to go home.
=end code
END
my #codelines = gather for $excerpt.lines {
take $_ if "=begin code" ff "=end code"
}
# this will print four lines, starting with "=begin code" and ending with
# "=end code"
.say for #codelines;
=begin code
This code block is what we're after.
We'll use 'ff' to get it.
=end code
=begin code
I want this line.
and this line as well.
HaHa
=end code
=begin code
Let's to go home.
=end code
I want to save the lines between =begin code and =end code into separate arrays, such as this:
['This code block is what we're after.', 'We'll use 'ff' to get it.']
['I want this line.', 'and this line as well.', 'HaHa']
['Let's to go home.']
I know grammar can do this, but I want to know if there is a beter way?

Answer 1

You need to specify that you want the matched values to not be included. You do this by adding ^ to the side of the operator you want excluded. In this case it is both sides of the operator.
You also need to collect the values up to have the grouped together. The simplest way in this case is to put that off between matches.
(If you wanted the endpoints included it would require more thought to get it right)
my #codelines = gather {
my #current;
for $excerpt.lines {
if "=begin code" ^ff^ "=end code" {
# collect the values between matches
push #current, $_;
} else {
# take the next value between matches
# don't bother if there wasn't any values matched
if #current {
# you must do something so that you aren't
# returning the same instance of the array
take #current.List;
#current = ();
}
}
}
}
If you need the result to be an array of arrays (mutable).
if #current {
take #current;
#current := []; # bind it to a new array
}
An alternative would be to use do for with sequences that share the same iterator.
This works because for is more eager than map would be.
my $iterator = $excerpt.lines.iterator;
my #codelines = do for Seq.new($iterator) {
when "=begin code" {
do for Seq.new($iterator) {
last when "=end code";
$_<> # make sure it is decontainerized
}
}
# add this because `when` will return False if it doesn't match
default { Empty }
}
map takes one sequence and turns it into another, but doesn't do anything until you try to get the next value from the sequence.
for starts iterating immediately, only stopping when you tell it to.
So map would cause race conditions even when running on a single thread, but for won't.

Answer 2

You can also use good old regular expressions:
say ( $excerpt ~~ m:s:g{\=begin code\s+(.+?)\s+\=end code} ).map( *.[0] ).join("\n\n")
s for significant whitespace (not really needed), g for extracting all matches (not the first one), .map goes through the returned Match object and extracts the first element (it's a data structure that contains the whole matched code). This creates a List that is ultimatelly printed with every element separated by two CRs.

Answer 3

another answer in reddit by bobthecimmerian, i copy it here for completeness:
my $excerpt = q:to/END/;
Here's some unimportant text.
=begin code
This code block is what we're after.
We'll use 'ff' to get it.
=end code
More unimportant text.
=begin code
I want this line.
and this line as well.
HaHa
=end code
More unimport text.
=begin code
Let's to go home.
=end code
END
sub doSomething(Iterator $iter) {
my #lines = [];
my $item := $iter.pull-one;
until ($item =:= IterationEnd || $item.Str ~~ / '=end code' /) {
#lines.push($item);
$item := $iter.pull-one;
}
say "Got #lines[]";
}
my Iterator $iter = $excerpt.lines.iterator;
my $item := $iter.pull-one;
until ($item =:= IterationEnd) {
if ($item.Str ~~ / '=begin code' /) {
doSomething($iter);
}
$item := $iter.pull-one;
}
the output is:
Got This code block is what we're after. We'll use 'ff' to get it.
Got I want this line. and this line as well. HaHa
Got Let's to go home.

Answer 4

use grammar:
#use Grammar::Tracer;
#use Grammar::Debugger;
my $excerpt = q:to/END/;
Here's some unimportant text.
=begin code
This code block is what we're after.
We'll use 'ff' to get it.
=end code
More unimportant text.
=begin code
I want this line.
and this line as well.
HaHa
=end code
More unimport text.
=begin code
Let's to go home.
=end code
END
grammar ExtractSection {
rule TOP { ^ <section>+ %% <.comment> $ }
token section { <line>+ % <.ws> }
token line { <?!before <comment>> \N+ \n }
token comment { ['=begin code' | '=end code' ] \n }
}
class ExtractSectionAction {
method TOP($/) { make $/.values».ast }
method section($/) { make ~$/.trim }
method line($/) { make ~$/.trim }
method comment($/) { make Empty }
}
my $em = ExtractSection.parse($excerpt, :actions(ExtractSectionAction)).ast;
for #$em -> $line {
say $line;
say '-' x 35;
}
Output:
Here's some unimportant text.
-----------------------------------
This code block is what we're after.
We'll use 'ff' to get it.
-----------------------------------
More unimportant text.
-----------------------------------
I want this line.
and this line as well.
HaHa
-----------------------------------
More unimport text.
-----------------------------------
Let's to go home.
-----------------------------------
But it included unrelated lines, based on #Brad Gilbert's solution, I updated the above answer as follows(and thanks again):
#use Grammar::Tracer;
#use Grammar::Debugger;
my $excerpt = q:to/END/;
Here's some unimportant text.
=begin code
This code block is what we're after.
We'll use 'ff' to get it.
=end code
More unimportant text.
=begin code
I want this line.
and this line as well.
HaHa
=end code
More unimport text.
=begin code
Let's to go home.
=end code
END
grammar ExtractSection {
token start { ^^ '=begin code' \n }
token finish { ^^ '=end code' \n }
token line { ^^ \N+)> \n }
token section { <start> ~ <finish> <line>+? }
token comment { ^^\N+ \n }
token TOP { [<section> || <comment>]+ }
}
class ExtractSectionAction {
method TOP($/) { make #<section>».ast.List }
method section($/) { make ~«#<line>.List }
method line($/) { make ~$/.trim }
method comment($/) { make Empty }
}
my $em = ExtractSection.parse($excerpt, :actions(ExtractSectionAction)).ast;
for #$em -> $line {
say $line.perl;
say '-' x 35;
}
Output is:
$("This code block is what we're after.", "We'll use 'ff' to get it.")
-----------------------------------
$("I want this line.", "and this line as well.", "HaHa")
-----------------------------------
$("Let's to go home.",)
-----------------------------------
So it works as expected.

Answer 5

It could be another solution, use rotor
my $excerpt = q:to/END/;
Here's some unimportant text.
=begin code
This code block is what we're after.
We'll use 'ff' to get it.
=end code
More unimportant text.
=begin code
I want this line.
and this line as well.
HaHa
=end code
More unimport text.
=begin code
Let's to go home.
=end code
END
my #sections =
gather for $excerpt.lines -> $line {
if $line ~~ /'=begin code'/ ff $line ~~ /'end code'/ {
take $line.trim;
}
}
my #idx = # gather take the indices of every `=begin code` and `=end code`
gather for #sections.kv -> $k, $v {
if $v ~~ /'=begin code'/ or $v ~~ /'end code'/ {
take $k;
}
}
my #r = # gather take the lines except every line of `=begin code` and `=end code`
gather for #sections.kv -> $k, $v {
if $v !~~ /'=begin code' | '=end code'/ {
take $v;
}
}
my #counts = #idx.rotor(2)».minmax».elems »-» 2;
say #r.rotor(|#counts).perl;
Output:
(("This code block is what we're after.", "We'll use 'ff' to get it."), ("I want this line.", "and this line as well.", "HaHa"), ("Let's to go home.",)).Seq

Answer 6

Another answer:
my $excerpt = q:to/END/;
Here's some unimportant text.
=begin code
This code block is what we're after.
We'll use 'ff' to get it.
=end code
More unimportant text.
=begin code
I want this line.
and this line as well.
HaHa
=end code
More unimport text.
=begin code
Let's to go home.
=end code
END
for $excerpt.comb(/'=begin code' \s* <( .+? )> \s+ '=end code' /) -> $c {
say $c;
say '-' x 15;
}

Answer 7

use the comb operator:
my $str = q:to/EOS/;
Here's some unimportant text.
=begin code
This code block is what we're after.
We'll use 'ff' to get it.
=end code
More unimportant text.
=begin code
I want this line.
and this line as well.
HaHa.
=end code
More unimport text.
=begin code
Let's go home.
=end code
EOS
my token separator { '=begin code' \n | '=end code' \n }
my token lines { [<!separator> .]+ }
say $str.comb(
/
<lines> # match lines that not start with
# =begin code or =end code
<separator> # match lines that start with
# =begin code or =end code
<( # start capture
<lines>+ # match lines between
# =begin code and =end code
)> # end capture
<separator> # match lines that start with
# =begin code or =end code
/).raku;
Output:
("This code block is what we're after.\nWe'll use 'ff' to get it.\n", "I want this line.\nand this line as well.\nHaHa.\n", "Let's go home.\n").Seq