rx/pattern/;          # an anonymous Regex object; 'rx' stands for 'regex' 
/pattern/;            # an anonymous Regex object; shorthand for 'rx/.../' 
 
regex { pattern };    # keyword-declared anonymous regex; this form is 
                      # intended for defining named regexes and is discussed 
                      # in that context in the next section

rx{ '/tmp/'.* };      # the use of curly braces as delimiters makes this first 
rx/ '/tmp/'.* /;      # definition somewhat easier on the eyes than the second

rx:r:s/pattern/;            # :r (:ratchet) and :s (:sigspace) adverbs, defining 
                            # a ratcheting regex in which whitespace is significant 
rx/:r:s pattern/;           # Same, but possibly less readable

my $regex = / R \w+ /;
say "Zen Buddhists like Raku too" ~~ $regex; # OUTPUT: «｢Raku｣␤» 
 
my $regex = /pottery/;
"Japanese pottery rocks!" ~~ / <$regex> /;  # Interpolation of $regex into /.../ 
say $/;                                     # OUTPUT: «｢pottery｣␤»

regex R { pattern };        # a named Regex object, named 'R'

my sub   S { /pattern/ };   # definition of Sub object (returning a Regex) 
my regex R {  pattern  };   # definition of Regex object

&S ~~ Code;                 # OUTPUT: «True␤» 
 
&R ~~ Code;                 # OUTPUT: «True␤» 
&R ~~ Method;               # OUTPUT: «True␤»   (A Regex is really a Method!) 

regex R { :i pattern };     # :i (:ignorecase), renders pattern case insensitive

regex R { :r pattern };     # apply :r (:ratchet) to entire pattern 

token R { pattern };        # same thing: 'token' implies ':r' 

regex R { :r :s pattern };  # apply :r (:ratchet) and :s (:sigspace) to pattern 

rule  R { pattern };        # same thing: 'rule' implies ':r:s' 

my $regex =  rx/ \d ** 4            #`(match the year YYYY) 
                 '-'
                 \d ** 2            # ...the month MM 
                 '-'
                 \d ** 2 /;         # ...and the day DD 
 
say '2015-12-25'.match($regex);     # OUTPUT: «｢2015-12-25｣␤»

/Cześć/;           # "Hello" in Polish 
/こんばんは/;        # "Good afternoon" in Japanese 
/Καλησπέρα/;       # "Good evening" in Greek

/ \# /;             # matches the hash metacharacter literally 
/ \w /;             # turns literal 'w' into a character class (see below) 
/Hallelujah\!/;     # matches string 'Hallelujah!' incl. exclamation mark

/ \, /;             # matches a literal comma ','

/ ,  /;             # !! error: an as-yet meaningless/unrecognized metacharacter 
                    # does not automatically match literally 

/ "abc" /;          # quoting literals does not make them more literal 
/ "Hallelujah!" /;  # yet, this form is generally preferred over /Hallelujah\!/ 
 
/ "two words" /;    # quoting a space renders it significant, so this matches 
                    # the string 'two words' including the intermediate space 
 
/ '#!:@' /;         # this regex matches the string of metacharacters '#!:@'

/ '\\\'' /;          # matches a backslash followed by a single quote: \' 
/ ｢\'｣ /;       # also matches a backslash followed by a single quote 
my $x = 'Hi';
/ "$x there!" /;     # matches the string 'Hi there!' 
 
/ "1 + 1 = {1+1}" /; # matches the string '1 + 1 = 2'

/ '\' /;             # !! error: this is NOT the way to literally match a 
                     # backslash because now it escapes the second quote 
 
/"Price tag $0.50"/; # !! error: "$0" is interpreted as the first positional 
                     # capture (which is Nil), not as '$0' 

if 'Life, the Universe and Everything' ~~ / and / {
    say ~$/;            # OUTPUT: «and␤» 
    say $/.prematch;    # OUTPUT: «Life, the Universe ␤» 
    say $/.postmatch;   # OUTPUT: « Everything␤» 
    say $/.from;        # OUTPUT: «19␤» 
    say $/.to;          # OUTPUT: «22␤» 
};

'raku' ~~ /rak./;       # matches the whole string 
'raku' ~~ / rak . /;    # the same; whitespace is ignored 
'raku' ~~ / ra.u /;     # the . matches the k 
'raker' ~~ / rak. /;    # the . matches the e

'raku' ~~ / . rak /;

my $text = qq:to/END/ 
  Although I am a
  multi-line text,
  I can be matched
  with /.*/.
  END
  ;
 
say $text ~~ / .* /;
# OUTPUT: «｢Although I am a␤multi-line text,␤I can be matched␤with /.*/.␤｣»

U+0020 SPACE
U+00A0 NO-BREAK SPACE
U+0009 CHARACTER TABULATION
U+2001 EM QUAD

U+000A LINE FEED
U+000B VERTICAL TABULATION
U+000C FORM FEED
U+000D CARRIAGE RETURN
U+0085 NEXT LINE
U+2028 LINE SEPARATOR
U+2029 PARAGRAPH SEPARATOR

say $/.prematch if 'Match the first word.' ~~ / \s+ /;
# OUTPUT: «Match␤»

'ab42' ~~ /\d/ and say ~$/;     # OUTPUT: «4␤» 
'ab42' ~~ /\D/ and say ~$/;     # OUTPUT: «a␤»

U+0035 5 DIGIT FIVE
U+0BEB ௫ TAMIL DIGIT FIVE
U+0E53 ๓ THAI DIGIT THREE
U+17E5 ៥ KHMER DIGIT FIVE

U+2464 ⑤ CIRCLED DIGIT FIVE
U+2476 ⑶ PARENTHESIZED DIGIT THREE
U+2083 ₃ SUBSCRIPT THREE

say '⑤' ~~ /<:N>/ # OUTPUT: «｢⑤｣␤»

0041 A LATIN CAPITAL LETTER A
0031 1 DIGIT ONE
03B4 δ GREEK SMALL LETTER DELTA
03F3 ϳ GREEK LETTER YOT
0409 Љ CYRILLIC CAPITAL LETTER LJE

'a.b' ~~ /\c[FULL STOP]/ and say ~$/;    # OUTPUT: «.␤»

say "u\x[0308]" ~~ /\c[LATIN SMALL LETTER U]/;    # OUTPUT: «Nil␤»

'a.b' ~~ /\x[2E]/ and say ~$/;    # OUTPUT: «.␤»

/\x2e/ and /\x002e/ and /\x00002e/

"a".uniprop('Script');                 # OUTPUT: «Latin␤» 
"a" ~~ / <:Script<Latin>> /;           # OUTPUT: «｢a｣␤» 
"a".uniprop('Block');                  # OUTPUT: «Basic Latin␤» 
"a" ~~ / <:Block('Basic Latin')> /;    # OUTPUT: «｢a｣␤»

say $0 if 'raku9' ~~ /\w+(<:Ll+:N>)/ # OUTPUT: «｢9｣␤»

"abacabadabacaba" ~~ / <[ a .. c 1 2 3 ]>* /;
# Unicode hex codepoint range 
"ÀÁÂÃÄÅÆ" ~~ / <[ \x[00C0] .. \x[00C6] ]>* /;
# Unicode named codepoint range 
"αβγ" ~~ /<[\c[GREEK SMALL LETTER ALPHA]..\c[GREEK SMALL LETTER GAMMA]]>*/;
# Non-alphanumeric 
'$@%!' ~~ /<[ ! @ $ % ]>+/  # OUTPUT: «｢$@%!｣␤»

say "[ hey ]" ~~ /<-[ \] \[ \s ]>+/; # OUTPUT: «｢hey｣␤»

/ <[\d] - [13579]> /;
# starts with \d and removes odd ASCII digits, but not quite the same as 
/ <[02468]> /;
# because the first one also contains "weird" unicodey digits

/<:Zs + [\x9] - [\xA0] - [\x202F] >/
# Any character with "Zs" property, or a tab, but not a "no-break space" or "narrow no-break space"

say 'no quotes' ~~ /  <-[ " ]> + /;  # <-["]> matches any character except "

say '"in quotes"' ~~ / '"' <-[ " ]> * '"'/;

/ <+[123]> /  # same as <[123]>

/ \w+ '=' \w+ /

/ a \s* b /

/ dogs? /

say 'abcdefg' ~~ /\w ** 4/;      # OUTPUT: «｢abcd｣␤» 
say 'a'       ~~ /\w **  2..5/;  # OUTPUT: «Nil␤» 
say 'abc'     ~~ /\w **  2..5/;  # OUTPUT: «｢abc｣␤» 
say 'abcdefg' ~~ /\w **  2..5/;  # OUTPUT: «｢abcde｣␤» 
say 'abcdefg' ~~ /\w ** 2^..^5/; # OUTPUT: «｢abcd｣␤» 
say 'abcdefg' ~~ /\w ** ^3/;     # OUTPUT: «｢ab｣␤» 
say 'abcdefg' ~~ /\w ** 1..*/;   # OUTPUT: «｢abcdefg｣␤» 

my $start = 3;
say 'abcdefg' ~~ /\w ** {$start .. $start+2}/; # OUTPUT: «｢abcde｣␤» 
say 'abcdefg' ~~ /\w ** {π.Int}/;              # OUTPUT: «｢abc｣␤» 

say 'abcdefg' ~~ /\w ** {-Inf}/;     # OUTPUT: «｢｣␤» 
say 'abcdefg' ~~ /\w ** {-42}/;      # OUTPUT: «｢｣␤» 
say 'abcdefg' ~~ /\w ** {-10..-42}/; # OUTPUT: «｢｣␤» 
say 'abcdefg' ~~ /\w ** {-42..-10}/; # OUTPUT: «｢｣␤» 

(try say 'abcdefg' ~~ /\w ** {42..10}/  )
    orelse say ($!.^name, $!.empty-range);
    # OUTPUT: «(X::Syntax::Regex::QuantifierValue True)␤» 
(try say 'abcdefg' ~~ /\w ** {Inf..Inf}/)
    orelse say ($!.^name, $!.inf);
    # OUTPUT: «(X::Syntax::Regex::QuantifierValue True)␤» 
(try say 'abcdefg' ~~ /\w ** {NaN..42}/ )
    orelse say ($!.^name, $!.non-numeric-range);
    # OUTPUT: «(X::Syntax::Regex::QuantifierValue True)␤» 
(try say 'abcdefg' ~~ /\w ** {"a".."c"}/)
    orelse say ($!.^name, $!.non-numeric-range);
    # OUTPUT: «(X::Syntax::Regex::QuantifierValue True)␤» 
(try say 'abcdefg' ~~ /\w ** {Inf}/)
    orelse say ($!.^name, $!.inf);
    # OUTPUT: «(X::Syntax::Regex::QuantifierValue True)␤» 
(try say 'abcdefg' ~~ /\w ** {NaN}/)
    orelse say ($!.^name, $!.non-numeric);
    # OUTPUT: «(X::Syntax::Regex::QuantifierValue True)␤» 

say so 'abc,def' ~~ / ^ [\w+] ** 1 % ',' $ /;  # OUTPUT: «False␤» 
say so 'abc,def' ~~ / ^ [\w+] ** 2 % ',' $ /;  # OUTPUT: «True␤» 

my $str = "ACG GCT ACT An interesting chain";
say $str ~~ /<[ACGT\s]>+ \s+ (<[A..Z a..z \s]>+)/;
# OUTPUT: «｢ACG GCT ACT An interesting chain｣␤ 0 => ｢An interesting chain｣␤» 
say $str ~~ /<[ACGT\s]>+: \s+ (<[A..Z a..z \s]>+)/;
# OUTPUT: «Nil␤» 

say $str ~~ m:g/[(<[ACGT]> **: 3) \s*]+ \s+ (<[A..Z a..z \s]>+)/;
# OUTPUT: 
# «(｢ACG GCT ACT An interesting chain｣ 
# «0 => ｢ACG｣␤» 
# «0 => ｢GCT｣␤» 
# «0 => ｢ACT｣␤» 
# «1 => ｢An interesting chain｣)␤» 

$_ = "ACG GCT ACT IDAQT";
say  m:g/[(\w+:) \s*]+ (\w+) $$/;
# OUTPUT: 
# «(｢ACG GCT ACT IDAQT｣␤» 
# «0 => ｢ACG｣␤» 
# «0 => ｢GCT｣␤» 
# «0 => ｢ACT｣␤» 
# «1 => ｢IDAQT｣)␤»

'abababa' ~~ /a .* a/ && say ~$/;   # OUTPUT: «abababa␤» 

'abababa' ~~ /a .*? a/ && say ~$/;   # OUTPUT: «aba␤» 

say '/foo/o/bar/' ~~ /\/.**?{1..10}\//;  # OUTPUT: «｢/foo/｣␤» 
say '/foo/o/bar/' ~~ /\/.**!{1..10}\//;  # OUTPUT: «｢/foo/o/bar/｣␤»

[section]
key = value

/ '[' \w+ ']' || \S+ \s* '=' \s* \S* /

/
|| '[' \w+ ']'
|| \S+ \s* '=' \s* \S*
/

say "abc" ~~ /ab | a.* /;                 # OUTPUT: «⌜abc⌟␤» 
say "abc" ~~ /ab | a {} .* /;             # OUTPUT: «⌜ab⌟␤» 
say "if else" ~~ / if | if <.ws> else /;  # OUTPUT: «｢if｣␤» 
say "if else" ~~ / if | if \s+   else /;  # OUTPUT: «｢if else｣␤»

say "abc" ~~ /a. | ab { print "win" } /;  # OUTPUT: «win｢ab｣␤»

say "abc" ~~ /a\w| a. { print "lose" } /; # OUTPUT: «⌜ab⌟␤»

say 'food' ~~ /< f fo foo food >/;      # OUTPUT: «｢food｣␤»

say 'food' ~~ / f | fo | foo | food /;  # OUTPUT: «｢food｣␤»

/
| f
| fo
| foo
| food
/

my @increasingly-edible = <f fo foo food>;
say 'food' ~~ /@increasingly-edible/;   # OUTPUT: «｢food｣␤»

say 'abc' ~~ / <?before a> && . /;    # OUTPUT: «Nil␤» 
say 'abc' ~~ / <?before a> . && . /;  # OUTPUT: «｢a｣␤» 
say 'abc' ~~ / <?before a> . /;       # OUTPUT: «｢a｣␤» 
say 'abc' ~~ / <?before a> .. /;      # OUTPUT: «｢ab｣␤» 

say so 'karakul'  ~~ /  raku/;    # OUTPUT: «True␤» 
say so 'karakul'  ~~ /^ raku/;    # OUTPUT: «False␤» 
say so 'rakuy'    ~~ /^ raku/;    # OUTPUT: «True␤» 
say so 'raku'     ~~ /^ raku/;    # OUTPUT: «True␤»

say so 'use raku' ~~ /  raku  /;   # OUTPUT: «True␤» 
say so 'use raku' ~~ /  raku $/;   # OUTPUT: «True␤» 
say so 'rakuy'    ~~ /  raku $/;   # OUTPUT: «False␤»

say so 'use raku' ~~ /^ raku $/;   # OUTPUT: «False␤» 
say so 'raku'     ~~ /^ raku $/;   # OUTPUT: «True␤»

my $str = chomp q:to/EOS/; 
   Keep it secret
   and keep it safe
   EOS
 
# 'safe' is at the end of the string 
say so $str ~~ /safe   $/;   # OUTPUT: «True␤» 
 
# 'secret' is at the end of a line, not the string 
say so $str ~~ /secret $/;   # OUTPUT: «False␤» 
 
# 'Keep' is at the start of the string 
say so $str ~~ /^Keep   /;   # OUTPUT: «True␤» 
 
# 'and' is at the start of a line -- not the string 
say so $str ~~ /^and    /;   # OUTPUT: «False␤»

my $str = q:to/EOS/; 
    There was a young man of Japan
    Whose limericks never would scan.
      When asked why this was,
      He replied "It's because I always try to fit
    as many syllables into the last line as ever I possibly can."
    EOS
 
# 'There' is at the start of string 
say so $str ~~ /^^ There/;        # OUTPUT: «True␤» 
 
# 'limericks' is not at the start of a line 
say so $str ~~ /^^ limericks/;    # OUTPUT: «False␤» 
 
# 'as' is at start of the last line 
say so $str ~~ /^^ as/;            # OUTPUT: «True␤» 
 
# there are blanks between start of line and the "When" 
say so $str ~~ /^^ When/;         # OUTPUT: «False␤» 
 
# 'Japan' is at end of first line 
say so $str ~~ / Japan $$/;       # OUTPUT: «True␤» 
 
# there's a . between "scan" and the end of line 
say so $str ~~ / scan $$/;        # OUTPUT: «False␤» 
 
# matched at the last line 
say so $str ~~ / '."' $$/;        # OUTPUT: «True␤»

say "two-words" ~~ / two<|w>\-<|w>words /;    # OUTPUT: «｢two-words｣␤» 
say "twowords" ~~ / two<!|w><!|w>words /;     # OUTPUT: «｢twowords｣␤»

my $str = 'The quick brown fox';
say so ' ' ~~ /\W/;               # OUTPUT: «True␤» 
say so $str ~~ /br/;              # OUTPUT: «True␤» 
say so $str ~~ /<< br/;           # OUTPUT: «True␤» 
say so $str ~~ /br >>/;           # OUTPUT: «False␤» 
say so $str ~~ /own/;             # OUTPUT: «True␤» 
say so $str ~~ /<< own/;          # OUTPUT: «False␤» 
say so $str ~~ /own >>/;          # OUTPUT: «True␤» 
say so $str ~~ /<< The/;          # OUTPUT: «True␤» 
say so $str ~~ /fox >>/;          # OUTPUT: «True␤»

my $str = 'The quick brown fox';
say so $str ~~ /« own/;          # OUTPUT: «False␤» 
say so $str ~~ /own »/;          # OUTPUT: «True␤»

say "stuff here!!!".subst(:g, />>/, '|');   # OUTPUT: «stuff| here|!!!␤» 
say "stuff here!!!".subst(:g, /<</, '|');   # OUTPUT: «|stuff |here!!!␤» 
say "stuff here!!!".subst(:g, /<|w>/, '|'); # OUTPUT: «|stuff| |here|!!!␤»

my regex key {^^ <![#-]> \d+ }
say "333" ~~ &key;                  # OUTPUT: «｢333｣␤» 
say '333$' ~~ m/ \d+ <?[$]>/;       # OUTPUT: «｢333｣␤» 
say '$333' ~~ m/^^ <?[$]> . \d+ /;  # OUTPUT: «｢$333｣␤»