perl6 -e 'my $c; BEGIN { $c = 1 }; say $c;'
1
[download]

Or you can have:

perl6 -e 'my $c; BEGIN $c = 1; say $c;'
1
[download]

In some cases at least, the BEGIN phaser can be even a simple expression:

perl6 -e 'my $c = BEGIN  3 - 2; say $c;'
1
[download]

perl6 -e 'my $c; say $c; BEGIN $c = 1'
1
[download]

perl6 -ne 'my $c; BEGIN {$c = qw<while say>.Set}; my $line = $_; $line
+.say if $_ (elem) $c for $line.words' while_done.pl6
while True {
    say $line;
say 'Done!';
[download]

perl6 -ne 'my $c = BEGIN qw<while say>.Set; my $line = $_; $line.say i
+f $_ (elem) $c for $line.words' while_done.pl6
[download]

BTW, as already mentioned by Anonymous Monk, note that it is probably better to populate a set within the BEGIN block, rather than an array, because, otherwise, Perl will have to coerce the array into a set for each call to the (elem) operator and this might be inefficient if your input file is large.

the thing you're missing here is that my variables are limited in scope to the curlies that contain them. You can, however, use phasers without curlies, too. that would solve your problem nicely, i expect. other than that, you can have @ids be a state instead of my variable, which lets you get "initialize only once" semantics without using a phaser.

Another problem is that you have a -ne (i.e. run once for every line) but you use the lines sub in your code, which will immediately give you all lines as one list. Then the split method on that will turn it into a string for you (by concatenating all the lines) and then you split by "\t". That means that @F[0] will only contain the very first field of the very first line, and @F.join("\t").say will output the whole file (if the first field of the first line is contained in the patternFile.txt). What you probably wanted was to have my @F = $_.split("\t").

Another thing is that you really want to compute @ids.Set once rather than for every single line. For a Set, however, you have to use either a %-sigiled variable and bind (:=) the Set (because assignment will turn the right-hand side into a Hash for you) or a $-sigiled variable and assign the Set. Binding doesn't work with state variables, though, so you're left with this:

perl6 -ne 'state $ids = "patternFile.txt".IO.lines.Set; my @F = $_.split("\t"); if @F[0] (elem) $ids { @F.join("\t").say }'

Hope that helps!

Another problem is that you have a -ne (i.e. run once for every line) but you use the lines sub in your code, which will immediately give you all lines as one list.

You seem to have missed that the code is using two different files. The OP uses the .lines IO method to read patternFile.txt in the BEGIN block, and the -ne command line option to read searchFile.txt.

i was actually referring to the lines sub, not the lines method. both occur in the code, and the part that uses the sub is the one that is the problem.

Thank You Monks,

I setteled on:

Much as Anonymous Monk suggested but with Laurent_R's use of declaring $ids outside of the BEGIN block / before the BEGIN phaser. I think that Anonymous Monk's original suggestion would have re-read the patternFile on every line which would be inefficient.

In retrospect I clearly had an equivocation in my mental model of what lines does a I used it to pull in all the lines for the first file and then tried to used it a bit like <> from perl5 to read in 1 line at a time from STDIN.

Thanks again!

Since this is a one-liner, you might want to shorten it a bit. Please note that a method call without invocant will be invoked with $_.

So you could change:

my @F=$_.split("\t");
[download]

to

my @F= .split("\t");
[download]

Similarly you appear to be printing the whole line. So, rather than:

{@F.join("\t").say}
[download]

you could have:

{.say}
[download]

I think that Anonymous Monk's original suggestion would have re-read the patternFile on every line which would be inefficient.

Probably not. A state variable is initialized only once. From the documentation (https://docs.perl6.org/syntax/state):

However, initialization happens exactly once the first time the initialization is encountered in the normal flow of execution. Thus, state variables will retain their value across multiple executions of the enclosing block or routine.

But this should probably be confirmed with a test.

Update: added the word "variable" which was missing in one sentence ("A state variable ...")