Warning, /frameworks/syntax-highlighting/autotests/input/highlight.raku is written in an unsupported language. File is not indexed.

 #!/usr/bin/perl6
 
 use v6;
 
 if True {
     say "Hello";
 }
 
 if True {
 say "Hello"; # Bad indentation intended
         }
 
 if True { say "Hello" }
 
 if True {say "Hello"}
 
 if True { say "Hello" } else { say "Goodbye" }; say "world";
 
 ## BEGIN Comments
 
 say 1 #`( blah TODO blah
 here? ) 2 ;
 say 1 #`{{ blah TODO blah
 here? }} 2 ;
 say 1 #`[[ blah TODO blah ]
 here? ]] 2 ;
 say 1 #`««« blah TODO blah
 here? »»» 2 ;
 say 1 #` ( blah TODO blah
 2 ;
 
 #`[
   This is another multi-line comment. ]
 my @sorted = @names.sort({ %sets{$_} }).sort({ %matches{$_} }).reverse;
 #`{ So is this, though it's not actually multi-line. }
 
 say 'code again';
 
 #`(  Multiple line comments `( sub-comment )`)`
 
 ## END Comments
 
 #`[
 And this is how a multi would work.
 That says why we do what we do below.
 ]
 
 say "No more";
 
 #`{{a}a}} say ok
 
 say "No more";
 
 say "this is code";
 
 =begin pod
 
 A very simple Pod6 document
 
 =end pod
 
 =begin head1
 Top Level Heading
 =end head1
 
 =head1 Top level heading
 
 =for head1
 Top Level Heading
 
 =cutsdads
 
 =begin pod
 
 =head1 This is a head1 title
 
 This is a paragraph.
 
 =head2 Subsection
 # plop
 Here some text for the subsection.
 
 =end pod
 
 =begin table :caption<My Tasks>
 mow lawn
 take out trash
 =end table
 
 =head1 This is a heading block
 This is an ordinary paragraph.
 Its text will be squeezed and
 short lines filled. It is terminated by
 the first blank line.
 
 =head2 This is another heading block
 This is yet another ordinary paragraph,
 at the first virtual column set by the
 previous directive
 
 #| Base class for magicians
 class Magician {
   has Int $.level;
   has Str @.spells;
 }
 
 #| Fight mechanics
 sub duel(Magician $a, Magician $b) {
 }
 #=«<((
  <Magicians only, no mortals. >
  Magicians only, no mortals.
 ))>»
 
 say Magician.WHY;
 
 #|<< This is an example of stringification:
     * Numbers turn into strings
  >   * Regexes operate on said strings
     * C<with> topicalizes and places result into $_
 >>
 sub search-in-seq( Int $end, Int $number ) {
     with (^$end).grep( /^$number/ ) {
         .say for $_<>;
     }
 }
 #= Uses     * topic    * decont operator
 
 
 =head1 plop
 abc
 
 =head1 plop
 =para
 abc
 
 =head1 plop
  abc
 abc
 
 =head1 plop
 abc
 
 say 1;
 
 =head1 plop
 
 say 1;
 
 =for head1
 plop
 
 =for table :conf[str, 'str', "str", 1, True] :conf(str, 'str', "str", 1, True)
 =for table :conf<str 'str' "str" 1 True>
 =for table :conf{k => str, k=>'str', k=>"str", k=>1, k=>True}
 =for table :a :!b :42k :+s
 abc
 
 say 2;
 
 =begin a
 abc
 =end a
 
 =begin b sa
 =end b
 say 2;
 
 =begin a
 abc
 
 abc
 
 abc
 =end a
 say 0 ;
 =begin a:config{42}
 abc
 
 =head1 The
 Title
 
 abc
 =end ab
 say 1 ;
 
 =begin b sa
 =end b
 =begin a
 abc
 =begin b
 abc
 =end b a
 abc
 
 abc
 =end a
 say 3 ;
 
 =item a
 =item b
 =begin code
  =item a
 =end code
 
 =begin code
  =item a
  b
 =end code d
 =end code
 
 =begin comment
 Here are several
 lines
 of comment
 =end comment
 
 =begin pod
 =head1 acB<<I<a>>>a B<c> U<d> BB<a>
 
 C<my $var = 1; say $var;>
 Perl 6 homepage L<https://perl6.org> L<Perl 6 homepage|https://perl6.org>
 Comments L<#Comments> L<Comments|#Comments>
 Perl 6 is awesome Z<Of course it is!>
 Perl 6 is multi-paradigmatic N<Supporting Procedural, Object Oriented, and Functional programming>
 Enter your name K<John Doe> E<0xBB> characters.
 
 A X<hash|hashes, definition of; associative arrays>
 
 =DISCLAIMER
 P<http://www.MegaGigaTeraPetaCorp.com/std/disclaimer.txt>
 
 A X<hash|hashes, definition of; associative arrays>
 is an unordered collection of scalar values indexed by their
 associated string key.
 
     my @names = <Foo Bar Baz>;
     my @upper-case-names = @names.map: { .uc }    # OUTPUT: [FOO BAR BAZ]
 
 =end pod
 
 =begin table :caption<My Tasks>
 mow lawn
 take out trash
 =end table
 
 =begin table :config{caption => "My Tasks"}
 mow lawn
 take out trash
 =end table
 
 
 say "\c999 \c999999999 \c[LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER B] \c77s \c[77,22]";
 say "\x0 \x00 \x[0] \x[00] \x[f] \xaaa \xfffffff \xffh \x[ffff] \x[fffffff] \x[42,42]";
 say "\o0 \o00 \o[0] \o[00] \o[7] \o333 \o77777777 \o77h \o[333] \o[77777777] \o[42,42]";
 
 say Q[A literal string] ;
 say ｢More plainly.｣ ;
 say Q ^Almost any non-word character can be a delimiter!^ ;
 say Q ｢｢Delimiters can be repeated/nested if they are adjacent.｣｣ ;
 
 say Q (this is fine, because of space after Q) ;
 say Q 'and so is this' ;
 say Q<Make sure you <match> opening and closing delimiters> ;
 say Q{This is still a closing curly brace → \} ;
 
 say Q;yes, this is fine; ;
 say Q('this is a function') ;
 
 say 'Very plain';
 say q[This back\slash stays];
 say q[This back\\slash stays]; # Identical output
 say q{This is not a closing curly brace → \}, but this is → };
 say Q :q $There are no backslashes here, only lots of \$\$\$>!$;
 say '(Just kidding. There\'s no money in that string)';
 say 'No $interpolation {here}!';
 say Q:q!Just a literal "\n" here!;
 say Q:q[a\[]
 say Q[A literal string] ;
 say ｢More plainly.｣ ;
 say Q ^Almost any non-word character can be a delimiter!^ ;
 say Q ｢｢Delimiters can be repeated/nested if they are adjacent.｣｣ ;
 
 say qq[My favorite color is {$n+2}!];
 say qq{My favorite color\- is {$n+2}!};
 say Q:qq{My favorite color\- is {$n+2}!};
 say "My $color[0].uc(
 ) $n+$n.^name favorite color \q[1is] {$n+2}!abc&uc('a')";
 
 say qqww|a|;
 say qq:w:w|a|;
 say q:a:v|a|;
 
 say(qq:to/TERM INATOR/, 1+1);
  blah blah
  TERM INATOR
 
 
 my $don't-do-that = 1;
 my $piece_of_π = 3.14;
 my $駱駝道    = 1;
 my $lexical   = 1;
 my $*dynamic1 = 10;
 my $*dynamic2 = 100;
 
 sub say-all() {
     say "$lexical, $*dynamic1, $*dynamic2";
 }
 
 say-all();
 
 {
     my $lexical   = 2;
     my $*dynamic1 = 11;
     $*dynamic2    = 101;
 }
 
 my $square = 9 ** 2;
 my @array  = 1, 2, 3;   # Array variable with three elements
 my %hash   = London => 'UK', Berlin => 'Germany';
 
 class FailHash is Hash {
     has Bool $!final = False;
     multi method AT-KEY ( ::?CLASS:D: Str:D \key ){
         fail X::OutOfRange.new(:what("Hash key"), :got(key),
           :range(self.keys)) if $!final && !self.EXISTS-KEY(key);
         callsame
     }
 
     method finalize() {
         $!final = True
     }
 }
 
 my %h is FailHash = oranges => "round", bananas => "bendy";
 
 say %h<oranges>;
 %h.finalize;
 say %h<cherry>;
 CATCH { default { put .^name, ': ', .Str } }
 
 my ( @foo, $bar );
 @foo = ($bar) = 42, "str";
 
 say anon class þ {};
 say anon sub þ  { 42 };
 
 sub a {
     state @x;
     state $l = 'A';
     @x.push($l++);
 };
 
 say a for 1..6;
 
 sub foo($x) {
     my $v = @;
     $v[$x] = $x;
     say $v;
 }
 
 foo($_) for ^3;
 
 use MONKEY-TYPING;
 augment class Int {
     method is-answer { self == 42 }
 }
 say 42.is-answer;
 
 my $in = 0;
 
 sub f(*@c) {
     (temp $in)++;
      "<f>\n"
      ~ @c».indent($in).join("\n")
      ~ (+@c ?? "\n" !! "")
      ~ '</f>'
 };
 
 for <ab:c d$e fgh ij*> {
     .say if m/<-alpha>/;
 }
 
 for '.' {
     .Str.say when !.IO.d;
     .IO.dir()».&?BLOCK when .IO.d # lets recurse a little!
 }
 
 use Dog:auth<Somebody>:ver<2.0>;
 
 infix:<+>
 infix:<*>
 infix:«<=»
 
 postfix:<²>
 WOW:That'sAwesome
 WOW:That's<<🆒>>
 party:sweet<16>
 
 infix:<+>
 infix:<<+>>
 infix:«+»
 infix:['+']
 infix:('+')
 
 my $a:b<c>:d<e> = 100;
 my $a:d<e>:b<c> = 200;
 say $a:b<c>:d<e>;
 
 use Test; plan 1; constant &term:<👍> = &ok.assuming(True);
 👍
 
 my $x = do if True { 42 };
 
 say 1000000, 1_000_000, 10_00000, 100_00_00;
 say -2, 12345, 0xBEEF, 0o755, :3<1201>;
 say 1.0, 3.14159, -2.5, :3<21.0012>;
 say 1e0, 6.022e23, 1e-9, -2e48, 2e2i, .42;
 say 2.e2, .2, 0o39, 0xfF3u, 0oi, 0xi, :3<>, :23<gg ; # error
 
 
 for $size «[r/]« (2**60, 2**50, 2**40, 2**30, 2**20, 2**10)
           Z      <EB     PB     TB     GB     MB     KB> -> [\v,\suffix]
 
 my $a = 32;
 $a += 10;
 $a -= 2;
 $a = 3;
 $a min= 5;
 $s ~= 'b';
 
 sub infix:<space-concat> ($a, $b) { $a ~ " " ~ $b };
 my $a = 'word1';
 $a space-concat= 'word2';
 
 my Real $a = 1/2;
 $a = 3.14;
 $a .= round;
 
 my $a = True;
 say so $a != True;
 my $i = 10;
 
 my $release = Date.new(:2015year, :12month, :24day);
 my $today = Date.today;
 say so $release !before $today;
 
 say 4 R/ 12;
 say [R/] 2, 4, 16;
 say [RZ~] <1 2 3>,<4 5 6>
 
 say (1, 2, 3) »*» 2;
 say (1, 2, 3, 4) »~» <a b>;
 say (1, 2, 3) »+« (4, 5, 6);
 say (&sin, &cos, &sqrt)».(0.5);
 
 say @a »+=» 1;
 my ($a, $b, $c);
 (($a, $b), $c) «=» ((1, 2), 3);
 
 say !« @wisdom;
 @a»++;
 say -« [[1, 2], 3];
 
 @slops».?this-method-may-not-exist();
 
 my %outer = 1, 2, 3 Z=> <a b c>;
 my %inner = 1, 2 Z=> <x z>;
 say %outer «~» %inner;
 
 say $neighbors »>>+<<» ($p, *);
 
 sub plus { $^a + $^b };
 say [[&plus]] 1, 2, 3;
 
 my @n = [\~] 1..*;
 say @n[^5];
 
 @l = <a b c d> Z~ 1, 2, *;
 say so 1 S& 2 S& 3;
 @a X[+=] @b;
 multi sub postfix:<++>($x is rw) is assoc<non>
 say $filename++ for 1..3;
 $x % $y == $x - floor($x / $y) * $y
 say <a a b c a d> ⊍ bag(<a a b c c>);
 say -« <1 2 3>
 
 # This is wrong: creates a Hash of Mixes, not Mix:
 my Mix %mix;
 # Works with $ sigil:
 my Mix $mix;
 # Can be typed:
 my Mix[Int] $mix-of-ints;
 
 my $x;
 my $x = 7;
 my Int $x = 7;
 my Int:D $x = 7;
 ndef)
 my Int $x where { $_ > 3 } = 7;
 my Int $x where * > 3 = 7;
 
 $str ~~ tr:d:c!dol!wne!;
 $str ~~ TR:c/dol/wne/;
 $str ~~ s!foo!fox!;
 $str ~~ /foo/bar/;
 $str ~~ ///;
 $str ~~ rx/foo/bar/;
 $str ~~ Q :regex /foo/;
 $str ~~ s{b(.)r} = " d$0n";
 $str ~~ regex{fox}; # error
 $str ~~ regex {fox};
 rx/ ^ab /;
 / ^ ab /;
 rx/ \d ** 2/;
 $str ~~ tr:d:c!dol!wne!;
 $str ~~ TR:c/dol/wne/;
 $str ~~ s!foo!fox!;
 $str ~~ rx/foo/;
 $str ~~ regex:ds {fox};
 $str ~~ regex{fox};
 my a = /a/;
 rx/ ^ab /;
 a = / ^ ab 'a' "$a" \d \n\n <:L :Script<Latin>> <:Block('Basic Latin')>  /;
 //;
  rx:sigspace.\d+ < :Script +:Block "Basic Latin" + :L> #plop
 '-'.;
 rx/ \d ** 2 <[\d a d]+[\x233..\] " \c[dsds]]>/;
 say $str ~~ m:g/[(<[ACGT]> **: 3) \s*]+ \s+ (<[A..Z a a..z \s]>+)/;
 say '$333' ~~ m/^^ <?[$]> . \d+ /;
 say '/foo/o/bar/' ~~ /\/.**!{1..10}\//;
 rx(a);
 rx (a);
 $str ~~ regex {fox};
 $str ~~ s{b(.)r} = " d$0n";
 if 'abc' ~~ / [a||b] (c) / {
     say ~$0;                # OUTPUT: «c␤»
 }
 if 'abc' ~~ / $<myname> = [ \w+ ] / {
     say ~$<myname>      # OUTPUT: «abc␤»
 }
 say 'abc' ~~ / a <( b )> c/;
 say 'abc' ~~ / <(a <( b )> c)>/;
 say "abc" ~~ /a. | ab { print "win" } /;
 
 so 'hello world' ~~ m:Perl5/^hello (world)/;   # OUTPUT: «True␤»
 so 'hello world' ~~ m/^hello (world)/;         # OUTPUT: «False␤»
 so 'hello world' ~~ m/^ 'hello ' ('world')/;   # OUTPUT: «True␤»
 
 say "Abra abra CADABRA" ~~ m:exhaustive/:i a \w+ a/;
 
 my regex ipv4-octet { \d ** 1..3 <?{ $/.Int <= 255 && $/.Int >= 0 }> }
 my regex ipv4-octet { \d ** 1..3 <?{ True }> }
 say 'abc' ~~ / <?before a> && . /;
 say 'abcdefg' ~~ rx{ abc <[email protected]ending_letters> };
 s:g[\d+ <?before \s* @units>] = 5 * $/;
 
 
 sub walk(\thing, *@keys) is rw {
     my $current := thing;
     for @keys -> $k {
         if $k ~~ Int {
             $current := $current[$k];
         }
         else {
             $current := $current{$k};
         }
     }
     $current;
 }
 
 my %hash;
 walk(%hash, 'some', 'key', 1, 2) = 'autovivified';
 
 say %hash.perl;
 
 class X::WithoutLineNumber is X::AdHoc {
     multi method gist(X::WithoutLineNumber:D:) {
         $.payload
     }
 }
 die X::WithoutLineNumber.new(payload => "message")
 
 { return; CATCH { default { $*ERR.say: .^name, ': ', .Str } } }
 
 multi sub trait_mod:<is>(Routine $r, :$export!)
 
 react {
     whenever signal(SIGINT) {
         say "goodbye";
         done
     }
 }
 
 signal(SIGINT).tap: { say "bye"; exit }; loop {}
 
 method base-repeating(Rational:D: Int:D() $base = 10)
 
 multi sub prefix:<-->($x is rw) is assoc<non>
 
 
 multi MAIN(Bool :$man) {
     run $*EXECUTABLE, '--doc', $*PROGRAM;
 }
 
 for $file.lines -> $line {
     next unless $line; # ignore any empty lines
 
     my ($pairing, $result) = $line.split(' | ');
     my ($p1, $p2)          = $pairing.words;
     my ($r1, $r2)          = $result.split(':');
 
     %sets{$p1} += $r1;
     %sets{$p2} += $r2;
 
     if $r1 > $r2 {
         %matches{$p1}++;
     } else {
         %matches{$p2}++;
     }
 }
 
 for @sorted -> $n {
     my $match-noun = %matches{$n} == 1 ?? 'match' !! 'matches';
     my $set-noun   = %sets{$n} == 1 ?? 'set' !! 'sets';
     say "$n has won %matches{$n} $match-noun and %sets{$n} $set-noun";
 }
 
 say "Math: { 1 + 2 }";
 
 my @people = <Luke Matthew Mark>;
 say "The synoptics are: {@people}";
 
 say "{%sets}";
 say "we have @flavors[0]";
 say "we have @flavors[]";
 say "we have @flavors.sort()";
 say "we have @flavors.sort.join(', ')";
 
 my @valid-players = $file.get.words;
 
 for $file.lines -> $line {
     my ($pairing, $result) = $line.split(' | ');
     my ($p1, $p2)          = $pairing.split(' ');
     if $p1 ∉ @valid-players {
         say "Warning: '$p1' is not on our list!";
     }
     if $p2 ∉ @valid-players {
         say "Warning: '$p2' is not on our list!";
     }
 }
 
 my @array = [ 'x', 'xx', 'xxx', 'o', 'oo', 'X', 'Y', 'Z' ];
 my @array = <  x    xx    xxx    o    oo    X    Y    Z  >;
 
 sub plus { $^a + $^b };
 say [[&plus]] 1, 2, 3;
 
 say [X~] (1, 2), <a b>;
 
 my @n = [\~] 1..*;
 say @n[^5];
 
 my @l = <a b c d> Z~ ':' xx *;
    @l = <a b c d> Z~ 1, 2, *;
 
 say so 1 S& 2 S& 3;
 
 say %color«cherry "$fruit"».raku
 say $a.:<++>;
 
 say 2 !(elem) (1, 2, 3);
 
 say $_ if /A/ ^ff^ /C/ for @list
 
 my @result;
 <people of earth>
     ==> map({ .tc })
     ==> my @caps; @caps   # also could wrap in parentheses instead
     ==> grep /<[PE]>/
     ==> sort()
     ==> @result;
 
 my @result
     <== sort()
     <== grep({ /<[PE]>/ })
     <== my @caps            # unlike ==>, there's no need for additional statement
     <== map({ .tc })
     <== <people of earth>;
 
 False and do { 42.say };
 3, do if 1 { 2 }  ;
 if 0 { say "no" } elsif False { say "NO" } else { say "yes" }
 $_ = 1; unless False -> $a { $a.say } ;
 when so $a { say 'a' }
 
 for 1..100 {
     when * %% 15 { say 'FizzBuzz' }
     when * %% 3  { say 'Fizz' }
     when * %% 5  { say 'Buzz' }
     default      { say $_ }
 }
 
 multi sub grab(**@a) { "grab $_".say for @a }
 multi sub grab(\a) {
     a ~~ Iterable and a.VAR !~~ Scalar ?? nextwith(|a) !! nextwith(a,)
 }
 
 for '.' {
     .Str.say when !.IO.d;
     .IO.dir()».&?BLOCK when .IO.d # lets recurse a little!
 }
 
 say a».(0.5); say a>>.(0.5); a.:<sa> ; a. sa :!False
 func <a b>
 
 
 if 'abc-abc-abc' ~~ / $<string>=( [ $<part>=[abc] ]* % '-' ) / {
     say ~$<string>;          # OUTPUT: «abc-abc-abc␤»
     say ~$<string><part>;    # OUTPUT: «abc abc abc␤»
     say ~$<string><part>[0]; # OUTPUT: «abc␤»
 }
 
 [«[«[«[+]»]»]»] <1 2 3 4>