Synopsis 5：正規表現とルール
Damian Conway <damian@conway.org> Allison Randal <al@shadowed.net> Patrick Michaud <pmichaud@pobox.com> Larry Wall <larry@wall.org> Moritz Lenz <moritz@faui2k3.org>
Created: 24 Jun 2002 Last Modified: 25 Sep 2011 Version: 149
このドキュメントは Apocalypse 5を要約する、そしてそれは新しい正規表現構文についてだ。 それらが長い間（今まで）正規表現じゃなかったから、我々は今「正規表現」よりむしろそれら正規表現を呼び出そうとする、そして我々が正確な意味で、専門的な項になることについて、人気が高い項「正規表現」がプロセスでだと思うの : 「あなたがまあ正規表現のように、マッチしているパターンをする何か」。 他方、デザイン変更の目的の1つが我々のパターンの部分を伝統的な正規表現とパーサー意味規則の下で分析にいっそう受けることが出来させることだ、そしてそれはそれの間に我々のパターンの一部と文法は宣言部分、そしてどの部分かとして手続き上であるとして扱われることである注意深い特質を作ることを必然的に必要とする。
何ででもケースに入れろ、文法の中で再帰的パターンを参照するとき、項規則とトークンは一般に正規表現より好まれる。
本質的に、 Perl 6 はネイティブで正規表現表記法の拡張としての Parsing Expression Grammars （PEGs）を実装する。 PEGs はあなたがあいまいな解析結果に「序列」を提供することを要求する。 Perl 6 の序列はテストを結びつき - 壊しているマルチレベルによって決定される：
1) Longest token matching: food\s+ beats foo by 2 or more positions 2) Longest literal prefix: food\w* beats foo\w* by 1 position 3) Declaration from most-derived grammar beats less-derived 4) Within a given compilation unit, earlier declaration wins 5) Declaration with least number of 'uses' wins
文法がもう1つのコンパイル単位から猿によってパッチを当てられたときだけ、タイブレーク # 5が起こることができることに注意を払え。 # 3のように、それは遠いものよりも局所宣言を優遇する。
この序列のほかに、もし何かが下に選択されて裁決するなら、ついばむことはバックトラックする、次の最も良い統治は選択される。 すなわち、序列は候補者リストを決定して；ただ1人の候補者が選ばれるからといって残りが離れてスローされることを意味しない。 それらが、しかしながら、明示的に（時々あなたがいくらをカットすることを望むかに依存して「カットされた」演算子、しかし Perl6 がそれらのいく人かを持っている、と呼ばれる）適切なバックトラックしているコントロールによって離れてスローされるかもしれない。
原因となっているマッチオブジェクトは今利用可能であるとして$/
暗黙のうちにレキシカルスコープなである変数。 それがそれのように見えないときでさえ、最も最近のマッチへのすべてのユーザアクセスがこの変数を通してだ。 個別のキャプチャ変数（そんなものけれども$0$1など）ただ要素であrno$/.
ところで、 Perl 5 、変数が今始まるナンバーが付けられたキャプチャの場合と異なり$0 代わりに$1. 下を見ろ。
次の正規表現特徴は Perl 5 にと同じ構文を使う：
取り込むこと： （．．．）
繰り返し限定記号： * 、 ＋ と ?
代替物：|
バックスラッシュエスケープ：\
最小のマッチしている接尾辞： ?? 、 * - ＋ ？
構文である間にの| 変化しない、デフォルト意味規則は少し変更をする。 我々が両方とものベストを持っていることができるように、我々は宣言部分の楽しい混合と手続き上のマッチングを仕組もうと試みている。 要するに、 Perl があなたのためのものを書くであろうから、あなたは文法のためにあなた自身の tokener を書く必要がない。 「マッチしている Longest - トークン」で下のセクションを見ろ。
伝統的な正規表現と異なり、 Perl 6 はあなたにメタキャラクタの任意のリストを記憶するように要求しない。 その代わりにそれは単純な規則によって文字を分類する。 そのベース文字がいずれか、アンダースコア、であるすべてのグリフ（書記素）（_）あるいは正規表現で（すなわち英字）あるいは「N」（すなわち数）がそうである「L」から始まる Unicode 分類を常にリテラルであるようにする（すなわち self - 似合うこと）. それらがエスケープされなくちゃならない\ （欧数字をシングルにするどの訴訟がそれ自身メタ構文であるかについて、すぐに欧数字ではないの後に続く何以外でも）それらをメタ構文にするために。
－ 空白文字を含めて － 他のすべてのグリフは正確に反対：それらが（すなわち非 self - マッチして）常にメタ構文であると見なされるということであって、そしてエスケープされるか、あるいはそれらをリテラルにするために引用されなくちゃならない。 伝統的であるように、それらが個々にエスケープされるかもしれない\しかしそれらが同じく引用されるかもしれない Perl 6 に続く.
1つ以上のいずれかの型のグリフ（まったくすなわちどんなグリフでも）の連続が、一つのクォートの中にそれらを置くことによって、リテラルにされるかもしれない。 （二重のクォートが、正規表現がレキシカルに埋め込みである現在の言語と同じ補間された意味規則で、同じく許される。） クォートが間、それほど、量化可能なアトムを創造する
moose*
ただ「e」だけを数量化して、そして、言って、「【ムース】」とマッチする
'moose'*
文字列全体を数量化する、そして「moosemoose」とマッチするだろう。
ここに特質を要約するテーブルがある：
Alphanumerics Non-alphanumerics Mixed
Literal glyphs a 1 _ \* \$ \. \\ \' K\-9\!
Metasyntax \a \1 \_ * $ . \ ' \K-\9!
Quoted glyphs 'a' '1' '_' '*' '$' '.' '\\' '\'' 'K-9!'
言い換えれば、識別子グリフはリテラルだ（あるいはエスケープされるとき、メタ構文だ）、非識別子のグリフはメタ構文だ（あるいはエスケープされるとき、リテラルだ）、そして一つのクォートがそれらの中のすべてをリテラルにする。
しかしながら、すべての非識別子のグリフが Perl 6 正規表現でメタ構文として現在有意義であるわけじゃないとは注意しろ（例えば。 \1 \_ -
!）. すべての unescapedな非識別子のグリフが可能性があるメタ構文で、そして未来の使用に対して遠慮がちだと言うことはいっそう正確だ。
もしあなたがこのようなシーケンスを使う、あなたがクォートにあるいは必要とするエラーが指し示して表示される助けになるコンパイル時がシーケンスを使うなら、あるいはそれを認識するために新しい演算子を定義しろ。
セミコロン文字は有意義でないメタキャラクタとして特に遠慮がちだ；もし unquotedなセミコロンが見られるなら、コンパイラは正規表現がそのターミネータがいないのを淋しく思っていると不平を言うだろう。
延長された構文（/x）もう必要とされない．．．それはデフォルトだ.
（実際、それはおおかた管理 － 戻る唯一の方法をから構文がそれと一緒の古いものへの － だ:Perl5/ :P5 修飾子。）
そこ（に・で）ノーだ/s あるいは/m 修飾子（メタ文字のリプレイスそれらに対する変更－下を参照）。
ノーがある/e その代わりに使用置換の上の評価修飾子：
s/pattern/{ doit() }/
あるいは：
s[pattern] = doit()
代わりに/ee 言え：
s/pattern/{ eval doit() }/
あるいは：
s[pattern] = eval doit()
変換機が今副詞としてマッチ / 置換のスタートに置かれる：
m:g:i/\s* (\w*) \s* ,?/;
すべての修飾子がそれ自身のコロンで始まらなくちゃならない。 もしそれがさもなければ（もし次の文字が左小括弧である場合に限り、そしてその場合には必ず、真である）前の修飾子に引数と考えられるであろうなら、区切り文字は空白文字によって最終の修飾子から分離されなくちゃならない
一つの文字の修飾子は同じくもっと長期の版を持っている：
:i :ignorecase
:m :ignoremark
:g :global
:i （あるいは:ignorecase）修飾子が、そのダイナミックスコープでではなく、そのレキシカルスコープでケース特質を無視されさせる. すなわち、サブルールが常に（彼・それ）ら自身のケース設定を使う。 折り畳めている場合の量は現在のコンテキストに依存する。 バイトと符号位置モードで、（TR18 セクション2.4で定義されるように）、折り畳めているレベル1収納ケースが必要とされる。 書記素モードでレベル2は必要とされる。
:ii （あるいは:samecase）変形が置換に代用された文字列を合われた文字列と同じケースパターンに変えるために使われるかもしれない.
もしパターンがなしにマッチされるなら:sigspace 修飾子、ケースインフォメーションが文字基礎によって文字に横切って振る舞われる。 もし右の文字列が左のもの、審問より長いなら、決勝戦について文字が複製される。 もし可能であるなら、タイトルケースが、結果として生じている英字が単語の始まりにあるかどうかにかかわらず横切って振る舞われる；もし利用可能なタイトルケース文字がないなら、対応する大文字文字は使われる。 （このポリシーは指定された言語の orthographic ルールに従ってタイトルケースを代用するために言語依存の Unicode 宣言によってレキシカルスコープの中で修正されることができる。） 文字種情報を振る舞わない文字が（彼・それ）らの対応する取り換え文字を変化していないままにしておく。
もしパターンがマッチされるならで:sigspaceそれぞれのマッチされた言葉の上に同一の大文字化ポリシーがあるかどうか決定しようと試みて、そして同じポリシーをそれぞれの取り換え言葉に適用する、それから、少しよりスマートなアルゴリズムが使われる。 もし左手の同一のポリシー、知らせがもし必要なら複製した知らせが、最後のパターンで、一語一語上に振る舞われるそれぞれのためのポリシーがあるように思われないなら。 もし単語が識別可能なポリシーを持つように思われないなら、取り換え単語は非 sigspace ケースのように文字のために翻訳された文字だ。
認められたポリシーが次のものを含む：
lc() uc() ucfirst(lc()) lcfirst(uc()) capitalize()
何ででも場合、ただパターンの公式に一致された文字列部分だけがマッチしているではないが分析に含めた何でもソートするように先読みのか、あるいは文脈上のカウントとマッチする。
:m （あるいは:ignoremark）スコープが正確に好きである修飾子:ignorecase
それ以外それは場合の代わりにマーク（アクセントとそんなもの）を無視する。 それは（ターゲットとパターン両方で）それぞれの書記素をとることに等しい、共に（最大で腐敗した） NFD に変換することと、2つのベース文字（Unicode の非マークの文字）を比較することは、何でも先行されているのを無視している間に、文字を記録を残す。 マーク文字はただ、アサーションの真実を決定する目的で、無視される；マッチされた実際のテキストは、最終のベース文字の後に続く何でも含めて、すべての無視された文字を含む。
:mm （あるいは:samemark）変形が置換に代用された文字列を合われた文字列と同じマーク / アクセントパターンに変えるために使われるかもしれない.
マークインフォメーションが文字基礎によって文字に横切って振る舞われる。 もし右の文字列が左の（の・もの・人）より長いなら、文字がそうである残ることは何なしででも修正を代用した。 （Perl がそれを書記素モードに要約するから、 NFD / NFC特質が通常重要じゃないとは、注意しろ。）
下に:sigspace 前のルールは一語一語適用されている。
:c （あるいは:continue）修飾子がパターンを起こす、から指定されたポジションから走査し続けろ（デフォルティングそうすること($/ ?? $/.to !! 0)）：
m:c($p)/ pattern / # start scanning at position $p
これがスタートの場所に自動的にパターンを固定しないとは、注意しろ。 （使用:p それのために。） あなたが供給するパターンをそうすることsplit
暗黙を持つ:c 修飾子。
文字列ポジションは型の（こと・もの）だStrPos そして一般に不透明であるとして扱われるべきだ。
:p （あるいは:pos）修飾子がパターンをマッチしようとさせる、ただ指定された文字列ポジションで：
m:pos($p)/ pattern / # match at position $p
もし引数が除かれるなら、そうすることは義務を怠る($/ ?? $/.to !! 0). （Perl 5 の場合と異なり、文字列はそれ自身その最後のマッチがどこ（で・に）終わったか分からない。）
サブルールがその人とマッチするすべては暗黙のうちにパスするそれら開始位置だ。
同じく、あなたが Perl マクロのに供給するパターンis parsed
トレイトが暗黙を持っている:p 修飾子。
それに注意しろ
m:c($p)/pattern/
乱暴に匹敵するものはそうするはずだ
m:p($p)/.*? <( pattern )> /
新しい（人たち・もの）:s （:sigspace）修飾子が空白文字の連続を起こす、そうであることは見なした、「仮数部」；それらが空白文字のマッチしている規則によって置き換えられる、<.ws>. すなわち、
m:s/ next cmd '=' <condition>/
同じであるけれども :
m/ <.ws> next <.ws> cmd <.ws> '=' <.ws> <condition>/
効果的に同じであるけれども :
m/ \s* next \s+ cmd \s* '=' \s* <condition>/
しかしケースでの
m:s{(a|\*) (b|\+)}
あるいは等しく、
m { (a|\*) <.ws> (b|\+) }
<.ws> それがデータを見るまで、何をするべきか決めることができない。
それはまだ正しいことをする。 もしそうでなければ、あなた自身のものを定義しろws
そして:sigspace それを使うだろう。
一般にあなたは使う必要がない:sigspace 文法の中でパーサールールがあなたのために自動的に空白文字ポリシーを扱うから。
このコンテキストで、文法がどのようにその空白文字規則を定義することに決めるかについて、空白文字がしばしば、依存して、コメントを含む。 デフォルトであるけれども<.ws> サブルールがコメント構造を識別しない、文法が無料の何でも規則をオーバーライドする。 <.ws> 規則ではないがどこでも同じことを意味するつもりだった。
それは同じく引数をパスすることが可能だ:sigspace 志願するために完全に異なったサブルールを指定する。 これは何も支配するということであり得る、それは空白文字とマッチしなくてもよい。 この修飾子を論じるとき、重要な空白文字をパターンで合われている「空白文字」から区別することは重要だ、それで我々はパターンの空白文字 sigspace を呼び出して、そして一体何かを示すために一般に空白文字を予約するだろう<.ws> 現在の文法でマッチする。 sigspace と空白文字の間の連絡は主に比喩的だ、そしてそれは連絡が共に有用で、そして（潜在的に）紛らわしい理由だ。
:ss （あるいは:samespace）変形が置換にスマートなスペースマッピングをするために使われるかもしれない. それぞれの sigspace によって引き起こされた呼び出しがそうするように<ws>
左手に、スペース置換が切望されるところはどこ（で・に）でも置換文字列での一つの空白文字文字によって表されるように、合われた空白文字は右手に対応するスロットにコピーされる。
もし右手に左より多くの空白文字のスロットがあるなら、それらの righthand 文字は（彼・それ）ら自身残留する。 もし右手にマッチからすべての利用可能な空白文字のスロットをマップするのに十分な空白文字のスロットがない、アルゴリズムが、ランダムに「共通」を継ぐことによって、情報損失を最小にしようとするなら空白文字のリストから空白文字文字。 から最も少なく貴重である大部分まで、序列はそうだ：
spaces tabs all other horizontal whitespace, including Unicode newlines (including crlf as a unit) all other vertical whitespace, including Unicode
置換であるとき、ルールがフォーマット崩壊を最小にするはずであるこれらの主要な意志はラインの境界とそんなものを越えて起きる。 もちろん、結果が正確に人がするであろうことであろうという保証がない。
:s 修飾子がそのマッチ十分に重要であると見なされる、変形がそれらのために定義される：
ms/match some words/ # same as m:sigspace ss/match some words/replace those words/ # same as s:samespace
それに注意しろss/// 定義されることに関して:ssそれで :
$_ = "a b\nc\td"; ss/b c d/x y z/;
値で終わrno「a x\ny\tz」.
新しい修飾子が Unicode レベルを指定する：
m:bytes / .**2 / # match two bytes m:codes / .**2 / # match two codepoints m:graphs / .**2 / # match two language-independent graphemes m:chars / .**2 / # match two characters at current max level
デフォルトにこれらのレベルに、対応するプラグマがある。 それに注意する:chars ドットが常に範囲で最もレベルが高い許可で文字とマッチするから、修飾子は常に冗長だ。 この最高レベルはレベル、あるいはそれが（それより）いっそう特定であるかもしれない他の3の1つとまったく同じであるかもしれない:graphs 特定の言語が文字ルールであるときで使用中だ。 あなたがあなたがどの言語の上に依存しているか明示しないでプロセスして言語依存の文字を指定しないかもしれないことに注意を払え。
［推測：:chars 修飾子がこのマッチのためにどの言語のルールを使うべきか明示している引数をとることができた。］
新しい（人たち・もの）:Perl5/ :P5 修飾子が Perl 5 正規表現構文がその代わりに使われることを可能にする。 （それはあなたにあなたの修飾子を終わりに置くことを許すほど遠くに行かない。） 例えば、
m:P5/(?mi)^(?:[a-z]|\d){1,2}(?=\s)/
Perl 6 構文と等しい：
m/ :i ^^ [ <[a..z]> || \d ] ** 1..2 <?before \s> /
Any 整数修飾子が計算を指定する。 どんな種類のカウントかは続く文字によって決定される。
もし通り過ぎて後に続かれるならxそれ反復を意味する. 使用:x(4) 汎用書式のために。 それで
s:4x [ (<.ident>) '=' (\N+) $$] = "$0 => $1";
同じであるけれども :
s:x(4) [ (<.ident>) '=' (\N+) $$] = "$0 => $1";
ほとんど同じがどちらとしてか：
s:c[ (<.ident>) '=' (\N+) $$] = "$0 => $1" for 1..4;
それ以外、すべての4つのマッチが見いだされない限り、文字列は変化していない。
しかしながら、レンジが許される、それであなたは言うことができる:x(1..4) どこでも1（人・つ）から変化するために、から4がマッチする。
もし数が通り過ぎて後に続かれるならstndrdあるいはthそれが Nth 発生を見いだすことを意味する. 使用:nth(3) 汎用書式のために。 それで
s:3rd/(\d+)/@data[$0]/;
同じであるけれども
s:nth(3)/(\d+)/@data[$0]/;
同じがどちらとしてか：
m/(\d+)/ && m:c/(\d+)/ && s:c/(\d+)/@data[$0]/;
そうするための引数:nth 整数のリストであることを可能にされる、しかしこのようなリストは monotically に増加しているべきだ。 （前の値かそれ以下の値が無視されるだろう。） それで：
:nth(2,4,6...*) # return only even matches :nth(1,1,*+*...*) # match only at 1,2,3,5,8,13...
このオプションはもうスマートマッチをサポートすることを必要とされない。 もしあなたが本当にその能力を必要とするなら、あなたは整数のリストを grep することができる：
:nth(grep *.oracle, 1..*)
もし両方ともであるなら:nth そして:x 現在、ルーチンがそれと一緒マッチするサブマッチを探すマッチングだ:nth. もし nth 後のマッチの数が中に制約と両立できるなら:x、マッチ全体サブマッチの最も高い可能な数が首尾良く行く。 組み合わせの:nth そして:x 典型的にただ感覚もしを作るだけだ:nth ただ一（人・つ）のもスカラーじゃない。
新しい（人たち・もの）と一緒に:ov （:overlap）修飾子、ポジション（重複を含めて）と復帰がすべてリストコンテキスト、あるいは論理和でマッチする正規表現がすべての可能な文字においてマッチするであろう流れは項目コンテキストでマッチする. 最初のマッチ何においてでもポジションが返される。
マッチはスタートのポジションに関して左から右のオーダーで返されることを保証される。
$str = "abracadabra";
if $str ~~ m:overlap/ a (.*) a / {
@substrings = slice @(); # bracadabr cadabr dabr br
}
新しい（人たち・もの）と一緒に:ex （:exhaustive）修飾子、正規表現がすべての可能な方法で（重複を含めて）マッチするであろう流れとすべてのリストがマッチする復帰.
マッチはスタートのポジションに関して左から右のオーダーで返されることを保証される。 ではないが保証して、そして依存するかもしれないそれぞれの開始位置、パターンとマッチしているエンジン両方の性質、の中のオーダー。 （推測：あるいは我々はバックトラックしているエンジン意味規則を実施することができた。 あるいは、パターン前方一致じゃないなら、我々はまったく命令を保証することができなかった「: :」あるいは DFAish 溶液を隠す何かそのようなもの。）
$str = "abracadabra";
if $str ~~ m:exhaustive/ a (.*?) a / {
say "@()"; # br brac bracad bracadabr c cad cadabr d dabr br
}
それに注意する~~ 上に、最初のマッチが見いだされ、そしてマッチの残りがいい加減に通り過ぎて行なわれるかもしれないとすぐに、戻ることができる@().
新しい（人たち・もの）:rw 修飾子がこの正規表現を copy-on-write 意味規則を仮定するよりむしろ修正のために現在の文字列を主張させる。
すべてのキャプチャが入っている$/ 文字列、そんなものの中にもしあなたが変更されるなら、言う左辺値になる、$1場所とすべての他のフィールドのポジションがそれに応じて（それが何を意味するとしても）変更した文字列が修正されるオリジナル。 この修飾子（特にもしそれがまだ実装されないか、あるいは決して実装されないなら）、すべて作品がないときにはの$/ もし読み取り専用じゃないなら、 copy-on-write だと見なされる。
［推測：これは本当にパターンを文字列変数と結び付けるべきだ、（多分不変の）文字列値じゃない。］
新しい（人たち・もの）:ratchet 修飾子がこの正規表現をデフォルトまでにバックトラックさせない。
（一般にあなたは直接この修飾子を使わない、なぜならそれは通り過ぎて暗黙だからtoken そしてrule 宣言。） 修飾子が暗示するはずであるこれの影響: すべてのアトム、の後に含むがそれに限定されず*+そして? 交代と同様、限定記号。 修飾子後にバックトラックすることがアトム、そんなものを数量化した明示**意志オーバライドこれ.
（注意しろ：最も長いトークンの分析の適用を受けるパターンの、部分のために:
必要にバックトラックすることはできないだろうときからのどんな場合ででも無視される。）
:i:s:Perl5そして修飾子が中に置かれることができる Unicode - レベル正規表現（そしてレキシカルスコープなだ）：
m/:s alignment '=' [:i left|right|cent[er|re]] /
修飾子と同じように外に、ただ括弧だけが副詞に引数の間正当な括弧として認知される。 特に：
m/:foo[xxx]/ Parses as :foo [xxx]
m/:foo{xxx}/ Parses as :foo {xxx}
m/:foo<xxx>/ Parses as :foo <xxx>
ユーザー定義の修飾子は可能だろう：
m:fuzzy/pattern/;
ユーザー定義の修飾子が同じく引数、をとることができる、しかし括弧でだけ：
m:fuzzy('bare')/pattern/;
あなたが分離しなければならないあなたの区切り文字のために括弧を使うために：
m:fuzzy (pattern);
あるいはあなたは終わるだろうで :
m:fuzzy(fuzzyargs); pattern ;
Any 文法正規表現は本当にただ一種のメソッドに過ぎない、そしてあなたは Perl6 文法によって非常に何によってでも後に続かれたコロンを使っているルーチンに変数を宣言するかもしれないので、範囲宣言詞が解析をした、それは下記を含むmyourstateそしてconstant. （準宣言子として、temp
そしてlet 同じく認められている。） 一つの文が（上へ終結しているセミコロンを通して）標準の Perl 6 コードと解析される：
token prove-nondeterministic-parsing {
:my $threshold = rand;
'maybe' \s+ <it($threshold)>
}
このような宣言はマッチして最も長い － トークンを － 終えない、それで、変化しないで次のパターンがどのようにマッチするかについて、さもなければ無用の宣言が副作用をハングさせるために掛けくぎとして使用されるかもしれない：
rule breaker {
:state $ = say "got here at least once";
...
}
若干の修飾子がそれらのすべて以外のすべての修飾子が存在することができるわけじゃない可能な場所で許される。
一般に、コンパイルに影響を与える修飾子が正規表現の（好む:i）コンパイル時間に知られているければならな. ただ呼び出している（人たち・もの）だけに影響を与える修飾子がそれ自身正規表現ではなく、行動で（eg 。 :pos:overlap:x(4)）ただ呼び出しを巻き込むだけである構造に現われるかもしれない（好むm// そしてs///）、そして上にではなくrx//. 最終的に重なり合うことは、修正に影響を与える副詞である間に、置換に拒否される（eg . :samecase）ただ置換に入ることを許される.
次のことの原理結果が支配するこれら：
:ignorecase:ignoremark:sigspace:ratchet そして:Perl5
短いフォームがどこでも許される修飾子とそれら：正規表現の中に、そして上にm//rx// そしてs/// 構造。 実装がそれを必要とするかもしれない、値が知られているそれらが時間をコンパイルして、そして、もしそれがケースじゃないなら、コンパイル時エラーメッセージを与える。
rx:i/ hello / # OK rx:i(1) /hello/ # OK my $i = 1; rx:i($i) /hello/ # may error out at compile time
:samecase:samespace そして:samemark 修飾子がそうである修飾子（そして（彼・それ）らの短いフォーム）がただ置換を乗せた（s/// そしてs[] = ...）.
:overlap そして:exhaustive 修飾子（そして（彼・それ）らの短いフォーム）がただマッチに入ることを許されるだけである（すなわちm//）、上にではなく置換あるいは正規表現クォート.
:pos:continue:x そして:nth 修飾子とそれら別名がただ例えば即刻の呼び出しを巻き込むだけである構造の上で許される。 m// そしてs///
（けれども上にではなくrx//）.
:dba 副詞がただ正規表現の中に入るのを許されるだけだ。
ドット. 今が改行を含めてどんな文字とでもマッチする。 （/s
修飾子はなくなっている。）
^ そして$ 今常に古いもののように、文字列のスタート / 終わりとマッチする\A そして\z.（/m 修飾子はなくなっている。） 曜日で指定右辺の埋め込み~~ あるいは!~~ そのサブマッチが論理的に別個の文字列として扱われているから、演算子それらが常に示されたサブマッチのスタート / 終わりとマッチする。
A$ もう前のオプションとマッチしない\n それで言うことは必要だ\n?$ もしそれがあなたが意味することであるなら。
\n 今公正じゃない論理名（プラットホーム独立）改行とマッチする\x0a. 論理的な改行のリストのために TR18 のセクション 1.6 を見ろ。
\A\Zそして\z メタキャラクタはなくなっている。
から/x デフォルトだ：
unquoted # 今が常にコメントを開始する。 もし backtick と括弧開始文字によって後に続かれるなら、それは終わりの括弧で終わる埋め込みのコメントを開始する。 さもなければコメントは改行において終わる。
空白文字がレイアウトのためにだけ使われて、そして文字通りに合われなくて今、すなわち、常にメタ構文である（しかし見ろ:sigspace 上記の修飾子）.
^^ そして$$ ライン初期と終末とマッチする。 （/m
修飾子はなくなっている。） それらは両方のゼロ幅アサーションだ。 $$
前に何とでもマッチする\n （論理的な改行）と同じく指定期間の末、文字列、もし最終の文字はそうじゃなかった\n. ^^ 常に文字列のそして何の後の始まりともマッチする\n そのではない、文字列での決勝戦文字。
. マッチする何も、他方\N マッチする何何も除外する\n マッチする。 （/s 修飾子はなくなっている。） 特に、\N キャリッジ・リターンとラインフィードのいずれもとマッチしない。
新しい（人たち・もの）& メタキャラクタが conjunctive 項を分離する。 両側でのパターンは同じ始まりと末端でマッチするに違いない。
注意しろ：もしあなたがあなたの2つの項が同じポイントで終了することを望まないなら、あなたは本当にその代わりに先読みを使うことを望む。
離接と同じように| そして||両方とものなった接続詞& そして&& フォーム。 & フォームが手続き上であるよりむしろ叙述であると見なされる；それはコンパイラそして／あるいは実行時システムが最初にどの部分を評価するべきか決めることを可能にする、そしていずれかのオーダーが首尾一貫して起きると想定することは誤っている。 &&
形式が左から右のオーダーを保証する、そしてバックトラックすることは右の引数を左より速く変化させる。 言い換えれば、&& そして|| シーケンスポイントを確立しろ。 左側はそうであるかもしれないバックトラックすることは構造全体に入れられる時に入ってバックトラックする.
& 演算子はリスト結合性のようだ|けれども、少しもっときつい優先を持つ。 同じく&& 少しもっときつい優先を持つより||. 標準の junctional と同じように、そしてショート演算子、& そして| 共にもっときついより&& そして||.
~~ そして!~~ 演算子がサブマッチを、一体何が左手に変数あるいはアトムによって合われたかについて、行なわれるようにする。 文字列アンカーが文字列全体であるためにそのサブマッチを見なす。 それで、例えば、あなたは単語「ムース」を含んでいないどんな識別子とでもマッチすることを頼むことができる：
<ident> !~~ 'moose'
それと対照的に
<ident> !~~ ^ 'moose' $
（サブストリングとして「ムース」を含んでいるどんな識別子でも含めて）識別子としてが次と等しくない「ムース」全体と同じぐらい長い間何にでも識別子を許すだろう。 （それがマッチ全体であるかのように、サブマッチを識別子の始まりと終わりに付けるアンカーに注意しろ。） より長いマッチの一部として使用されるとき、明快さのために余分の括弧を使うことは良いかもしれない：
[ <ident> !~~ ^ 'moose' $ ]
優先の~~ そして!~~ 論理的な演算子についてそれが標準の Perl 展開式でするのとちょうど同じ（ように・時に） junctional と連続的なバージョンの間に適合する（S03 参照）。 従って
<ident> !~~ 'moose' | 'squirrel'
として解析をする
<ident> !~~ [ 'moose' | 'squirrel' ]
間
<ident> !~~ 'moose' || 'squirrel'
として解析をする
[ <ident> !~~ 'moose' ] || 'squirrel'
~ 演算子は特定のターミネータをゴールとしてマッチしているネストされたサブルールのためにヘルパーだ。 それは、そうであると同じように、開会と右大括弧の間に置かれるよう意図される：
'(' ~ ')' <expression>
しかしながら、それは主として左の引数を無視して、そして（数量化されるかもしれない）次の2つのアトムに作用する。 それらの次の2つのアトムの上のその演算はそれらを「もてあそぶ」はずだ、それでそれらが存在することは逆順で実際にマッチした。 従って上の展開式は賛成で、一見したとき、ただ速記に過ぎない：
'(' <expression> ')'
けれどもそれを越えて、それがアトムを書き直すとき、それは同じく必要とされる終わりのアトムにターミネータを認識して、そして、もし内部の展開式が終わらないなら、適切なエラーメッセージを作成するために内部の展開式を準備するであろう機構を挿入する。 それでそれは本当に同様に左大括弧に注意を払う、そしてそれは実際にさらに多くが好きである何かへの我々の例を書き直す：
$<OPEN> = '(' <SETGOAL: ')'> <expression> [ $GOAL || <FAILGOAL> ]
あなたがこの構造を、括弧開始がないときでさえ、期待を終わりの構造のために設けるために使うことができるとは、注意しろ
<?> ~ ')' \d+
ここで <?> が最初の空の文字列に真に戻る。
デフォルトまでにエラーメッセージはその時点で現在の規則の名前をパーサーの抽象的なゴールの指標として使う。 しかしながら、しばしばたいへん教育的なこのではない、ユーザーに意味をなさないであろうルールが、内部の案によれば、名指されるとき、特に。
:dba("doing business as") 副詞が次のコードが解析しようとしていることのいっそう教育的な名前を決めるために使われるかもしれない：
token postfix:sym<[ ]> {
:dba('array subscript')
'[' ~ ']' <expression>
}
それからメッセージを受けとる代わりに、好む：
Unable to parse expression in postfix:sym<[ ]>; couldn't find final ']'
あなたはメッセージ同種のものを得るだろう：
Unable to parse expression in array subscript; couldn't find final ']'
（:dba 副詞が同じくレクサーがもっと良いエラーメッセージを与えるのを手伝う交代と代替物に名前を与えるために使われるかもしれない。）
(...) まだ取り込んでいるグループを区切る。 しかしながら、これらのグループの秩序は線であるよりむしろ階層的だ。 ネストされたサブパターンキャプチャを見ろ。
[...] もう文字クラスじゃない。
それは今取り込まないグループを区切る。
文字クラスが今指定された使用方法だ<[...]>. 同じく拡張可能なメタ構文を見ろ。
{...} もう繰り返し修飾名じゃない。
それは今埋め込みのクロージャを区切る。 それは常に宣言部分よりむしろ手続き上であると見なされる；それは前に来ることと後から来ることの間にシーケンスポイントを確立する。 （この使用を避けるために<?{...}> その代わりにアサーション構文。） 正規表現の中のクロージャがそれ自身のレキシカルスコープを確立する。
権限：が、クロージャを使うことによって、正規表現マッチの一部として Perl コードを呼び出す。 埋め込みのコードが通常マッチに影響を与えない － それはただ副作用のために使われるだけだ：
/ (\S+) { print "string not blank\n"; $text = $0; }
\s+ { print "but does contain whitespace\n" }
/
明示的な縮小使用方法make 関数がこのマッチのためにアブストラクト構文ツリーオブジェクト（短くして抽象的対象あるいは ast）を生み出す：
/ (\d) { make $0.sqrt } Remainder /;
これは、文字列の代わりに、 numifiedな文字列の平方根を獲得する効果を持っている。 Remainder 参加が別れるように合われて、そして返されるのMatch 抽象的なオブジェクトについて、別れるように、返されたオブジェクトしかしではない。 アブストラクトオブジェクトが通常抽象構文ツリーの最上位ノードを表すから、オブジェクトが抽出されるかもしれないアブストラクトMatch 用途によってのオブジェクトの.ast メソッド。
そうする2番目の呼び出しmake そうするためのどんな前の呼び出しでもオーバーライドするmake.
クロージャ、捜索の中のポジションが示される瞬間的な（人たち・もの）の中で$¢.pos メソッド。
すべての文字列ポジションで、あなたがあなたがどの単位を取り扱っているかについて非常に注意深くないなら、あなたがそれを数として取り扱ってはならない（とき・から・につれて・ように）。
Cursor オブジェクトが同じく我々がマッチしている；これが入手可能なオリジナルの項目を返すことができる.orig メソッド。
クロージャは同じくで始まる項目に保証される$/ Match これまでのところマッチを表しているオブジェクト。 しかしながら、もしクロージャがマッチしているそれ自身の内部をするならそ$/ 変数は埋め込みのクロージャの終わりまでそのマッチの結果に再境界だろう。 （マッチは実際に現在の値で続くだろうの$¢ クロージャの後のオブジェクト。 $/ そして$¢ ただあなたのクロージャで同じことで始まる。）
もしそれが電話をするなら、それはマッチに影響を与えることができるfail：
/ (\d+) { $0 < 256 or fail } /
なぜならクロージャが、たとえ、それらがマッチすることができなかった後、オプティマイザがその何かだと判明することができたとしても、規準的な時にシーケンスポイント、それらが呼び出されることを保証されることを確定するから。 （しかしながら、何でも前にかっこうの的だ。 特に、クロージャがしばしば最も長いトークンのパターンのターミネータとして勤める。）
総合的な繰り返し指定子は今、だ** 最大のマッチングのために、文通することで**? なぜなら最小のマッチしている。 （すべてのそのような修飾名修飾子が直接後で今動く**.） スペースが完全な修飾名のどちらかかの側に入ることを許される。 このスペースは下に重要であると見なされる:sigspaceそして意志どちらかの端にではなく、マッチのすべての要素の間に呼び出しとして <.ws>に配られる.
左手のパターンがマッチするに違いないトークンが何度拘束する次の（人たち・もの）。
もし次のことが整数であるなら、それは正確なカウントあるいはレンジと同じぐらいあるいは解析される：
. ** 42 # match exactly 42 times <item> ** 3..* # match 3 or more times
この形式は declarational だと見なされる。
もしあなたがクロージャを供給するなら、それは同様戻るべきであるInt あるいはRange オブジェクト。
'x' ** {$m} # exact count returned from closure
<foo> ** {$m..$n} # range returned from closure
/ value was (\d **? {1..6}) with ([ <alpha>\w* ]**{$m..$n}) /
リストを返すことは非合法だ、それでこの容易なミスは失敗する：
/ [foo] ** {1,3} /
クロージャ形式は常に手続き上であると見なされる、それでそれが修正している項目は決して最も長いトークンの一部だと見なされない。
値が許される否定的なレンジ、けれどもただリバーシブルなパターンを修正しているいつ（そんなものけれどもafter マッチすることができた）. 例えば、「ドット」によって定義されるように、200の文字を囲むことを検索するために、あなたは言うことができた：
/ . ** -100..100 <element> /
Similarly 、あなた容器50の文字を後退させろ：
/ . ** -50 <element> /
［推測：否定的な修飾名が構造に declarational よりむしろ手続き上であると見なされることを強いる。］
Any の数量化されたアトムが左側の繰り返しの間に探すべきセパレータを指定する追加の制約によって変更されるかもしれない。
これは使用によって示されるの% 修飾名とセパレータの間に。 ただセパレータが項目の間に見られる場合に限り、最初の条項は反復される：
<alt>+ % '|' # repetition controlled by presence of character <addend>+ % <addop> # repetition controlled by presence of subrule <item>+ % [ \!?'==' ] # repetition controlled by presence of operator <file>+%\h+ # repetition controlled by presence of whitespace
Any 修飾名がそれほど修正されるかもしれない：
<a>* % ',' # 0 or more comma-separated elements <a>+ % ',' # 1 or more <a>? % ',' # 0 or 1 (but ',' never used!?!) <a> ** 2..* % ',' # 2 or more
% 修飾子がただ修飾名で使われるかもしれない；何でもそれがそのままの項にもたらすであろう使用に解析エラー（我々が選択するハッシュ表記法が Perl 6 正規表現でサポートする何とでも一緒の可能な混乱を最小にするために、）を試みる。
成功したマッチの% 構造が一般に「中央で」終わるで%すなわち、最初の事柄の後にしかし次のセパレータの前に。
そのために
/ <ident>+ % ',' /
マッチすることができる
foo foo,bar foo,bar,baz
ただ決して
foo, foo,bar,
このようなマッチが中央で終わらない唯一の時間は、もし左側が0回マッチすることができる（そしてそうする）なら、だ、その場合構造全体は空の文字列とマッチする。
'' ~~ / <ident>* % ',' / # matches because of the *
もしあなたがいずれかの側、使用の後にマッチが終わることを可能にすることを望むなら%% その代わりに。
そのために
/ <ident>+ %% ',' /
マッチ何でも缶詰めにしろ
foo foo, foo,bar foo,bar, foo,bar,baz foo,bar,baz,
もしあなたが個々に左手にそれぞれのマッチを数量化することを望むなら、あなたはそれを括弧に置かなくちゃならない：
[<a>*]+ % ','
それはセパレータが、左手のパターンがそれぞれの繰り返しの上に進行する限り、ゼロ幅であるために正当だ：
.+ % <?same> # match sequence of identical characters
セパレータは決して次の項目とは無関係にマッチしない；もしセパレータがマッチする、しかし次の項目が失敗するなら、それはセパレータを通して戻る間じゅうバックトラックする。 同じく、セパレータのこのマッチングは下に「進歩」として扱われない:ratchet 次の品目が成功しないなら意味規則。
重要なスペースが下に使われるとき:sigspaceそれ、それほど、セパレータの両側を用いて応募する
ms/<element>+ % ','/ ms/<element>+% ','/ ms/<element>+ %','/
すべてはこのようなセパレータの周りに空白文字を許す：
/ <element>[<.ws>','<.ws><element>]* /
間
ms/<element>+%','/
このようにすべての重要な空白文字を除外する：
/ <element>[','<element>]* /
もちろん、あなたは明示的にもし必要なら常に空白文字とマッチすることができる、それでコンマの後にしかし前にではなく空白文字を許すために、あなたは言うことができる：
/ <element>+%[','\s*] /
<...> 今拡張可能なメタ構文区切り文字だあるいはアサーション（すなわちそれらリプレイス Perl 5 の crufty (?...) 構文）.
Perl 6 正規表現で、変数が補間挿入されない。
その代わりにそれらがそれらを扱うためにそれからどのようにか決めることができる正規表現エンジンに生で通過する（下にいっそうそれの上の）。
スカラーがそれとマッチするはずであるエンジンが文字列を扱うデフォルト方法'...' 定数（すなわちそれは補間挿入された文字列をサブパターンとして取り扱わない）。 言い換えれば、 Perl 6 ：
/ $var /
Perl 5 のようだ：
/ \Q$var\E /
しかしながら、もし$var 部分一致Regex オブジェクト、変換しようと試みる代わりに、それは文字列、それに、あなたが言うかのように、サブルールとして、呼び出される<$var>. （下にアサーションを見ろ。） この形式はキャプチャではなくする、そしてそれはもしに失敗する$var 傷つけられている。
もし$var 未定義だ、警告が表示される、そしてマッチは失敗する。
［推測しろ： 我々が上に型マッチをしている型が非文字列に対してマッチしていることを可能にするとき、カレントノードは、そのままの変数だけじゃなく、埋め込みのシグネチャーの構文を必要とするだろう、それで変数が型を含んでいる訳を説明する必要がない、オブジェクト、それは定義上未定義であって、そして従って上記の規則によってマッチし損ねる。］
しかしながら、変数がマッチしている賛成の使われた演算子ではないをエイリアスの左側あるいはサブマッチとして使用した。
$x = <.ident> $0 ~~ <.ident>
もしあなたがマッチすることを望むなら$0 再び、そしてそれからそれをサブマッチとして使え、あなたは二重のクォートを使ってマッチに持ち込むことができる：
"$0" ~~ <.ident>
他方、それは変数じゃない何かにエリアスに途方もない：
"$0" = <.ident> # ERROR $0 = <.ident> # okay $x = <.ident> # okay, temporary capture $<x> = <.ident> # okay, persistent capture <x=.ident> # same thing
キャプチャ別名で宣言された変数はレキシカルスコープな正規表現の残りへだ。 あなたはこの用途を混乱させるべきじゃないの= 普通の割り当てあるいは普通のバインディングで。 あなたは読むべきである= 標準の割り当てのようにより宣言詞の擬似割り当てのようにもっと。 それはいっそう普通の（人たち・もの）のようだ:= 演算子、レベルで正規表現が働くから、文字列は不変だ、それでキャプチャは本当にただ前もって計算された substr 値に過ぎない。 にもかかわらず、あなたが独立して最終的に値を使うとき、 substr はコピーされるかもしれない、そして次に、それが元来割り当てであるかのように、それはさらに多くだ。
形式のキャプチャ変数$<ident> 中にレキシカルスコープを越えて固執するかもしれなくて；もしマッチがそれらを継承するなら覚えていられるMatch オブジェクトは、キーが変数名の識別子に対応するという状態で、ハッシュだ。 同じく数の変数が固執する境界$0など.
通り過ぎて行なわれたキャプチャ= もしそれがすでに現在のレキシカルスコープに存在しないなら、新しい語彙の変数を作る。 あなたが供給しなくちゃならない外の語彙の変数へのキャプチャにOUTER:: 名前の一部として、あるいはクロージャの中から割り当てを行なえ。
$x = [...] # capture to our own lexical $x
$OUTER::x = [...] # capture to existing lexical $x
[...] -> $tmp { let $x = $tmp } # capture to existing lexical $x
注意するしかしながらそれlet （そしてtemp）共有された変数の上にスレッドにとって安全であることを保証されなくて、それほどそれをする.
補間挿入された配列：
/ @cmds /
それがその要素の交代であるかのように、合われる。 通常それは junctive 意味規則を使ってマッチする：
/ [ @cmds[0] | @cmds[1] | @cmds[2] | ... ] /
しかしながら、それが直接のメンバーであるもし|| 傾け、それは連続的なマッチしている意味規則を使う、それさえリストの唯一のメンバーだ。 好都合に、あなた置かれた容器|| 交代の最初のメンバーの前に、従って
/ || @cmds /
匹敵するものはそうするはずだ
/ [ @cmds[0] || @cmds[1] || @cmds[2] || ... ] /
あるいは勢いよく流れろ、あなたは同じくそうすることができる
/ | @cmds /
明確であるために、あなたが junctive 意味規則を意味すること。
スカラー変数で、それがたまたまそうじゃないなら、それぞれの要素がリテラルとして合われる（とき・から・につれて・ように）Regex オブジェクト、サブルールとしてそれがどちらのケースに一致されるか。 スカラーサブルールと同じように、傷つけられたサブルールが常に失敗する。
文字列値が流れに注意を払うすべて:ignorecase
そして:ignoremark 環境、他方Regex 値が（彼・それ）ら自身のものを使う:ignorecase そして:ignoremark 環境。
あなたが書くことがもう嫌になるとき：
token sigil { '$' | '@' | '%' | '&' | '::' }
あなたが書くことができる：
token sigil { < $ @ % & :: > }
あなたが、それがサブルールとして解釈されないであろうように、最初の角度の後にスペースを置くように気を使う限り。 スペースと共にそれは普通の Perl 6 に角クォートのように解析されて、そしてリテラルの配列値として取り扱われる。
代わりに、もしあなたが proto 正規表現を前もって宣言するなら、あなたは、記号それらマッチによってだけ区別されて、同じカテゴリーのために多数の正規表現を書くことができる。 シンボルは「ロングネーム」の一部として明示される。 それは同じく規則使用方法の中で一致されるかもしれない<sym>これのようだ：
proto token sigil {*}
multi token sigil:sym<$> { <sym> }
multi token sigil:sym<@> { <sym> }
multi token sigil:sym<%> { <sym> }
multi token sigil:sym<&> { <sym> }
multi token sigil:sym<::> { <sym> }
（multi オプションで、そして一般に、文法で除かれる。）
それがマッチしてシグネチャーよりむしろマッチしている最も長いトークンに基づいていること以外、これはある形式の多数のディスパッチだと見なされることができる。 このようにそれを書くことについての利点は得られた文法で同じカテゴリーに追加のルールを加えることが容易であるということだ。 あなたがマッチしようとするとき、それらのすべてが並列に合われるだろう/<sigil>/.
もしまだマッチしているマルチ正規表現のメソッドの上に仮パラメータがあるなら最初に最も長いトークンルールとしての収益。 もしそれが絆をもたらすなら、標準の多数のディスパッチが、それらが型によって区別されることができると想定して、残っている変形に引数を使って作られている。
proto それが見るとき、 subdispatcher に立ち寄る* それは修飾名であるはずがなくて、そしてそのブロックの中の唯一のものだ。 そのためにあなたは、パットすることによって、項目を subdispatch の前に置くことができる* カーリーの中に：
proto token foo { <prestuff> {*} <poststuff> }
これは proto でだけ働く。 の意味規則の論議のために S06 を見ろ{*}. （proto sub 、正規表現が自動的に帰りの値を覚えている proto と異なり、{*} なぜならそれらがマッチカーソルとともに振る舞われて存在するから。）
パターンでのハッシュ変数の使用は遠慮がちだ。
もし変数が定数を表すことが知られている場合に限り、そしてその場合には必ず、 Variable マッチが宣言部分だと見なされる、さもなければそれらは手続き上だ。
ロールパラメータ（もし読み取り専用）が明示の欠如にもかかわらずこの目的で不変の宣言だと見なされることに注意を払えconstant ロールが不変の値で構成されるとき、（彼・それ）ら自身不変であって、そして多分パラメータを置き換えているだろう（もし値がパスしたなら定数だ）ときからの宣言詞。 定数でインスタンスを作られたマクロが宣言部分取り扱いのために同じくそれらの定数を適格にするだろう。
<...>）両方とも< そして> メタキャラクタであって、そして通常（しかし常にではなく）整合ペアで使われる。 （独立型のトークンとこれらとしての若干のメタキャラクタ関数の組み合わせが角を含むかもしれない。 これらは下に記述される。） たいていのアサーションが宣言部分だと見なされる；手続き上のアサーションは例外として記録されるだろう。
なぜなら整合ペア、後で最初の文字< 決定、アサーションの性質：
もし最初の文字が空白文字であるなら、角はリテラルの普通の「クォート単語」配列として取り扱われる。
< adam & eve > # equivalent to [ 'adam' | '&' | 'eve' ]
最終の ＞ の前のスペースがオプションである、そしてそのために <adam & イブ>が受容できるであろうことに注意を払え。
先行するアルファベット文字がそれが取り込んでいる文法的なアサーション（すなわちサブルールあるいは名指されたキャラクタークラス－下を参照）であることを意味する：
/ <sign>? <mantissa> <exponent>? /
識別子の後の最初の文字は終わりの角度の前にテキストの残りの取り扱いを決定する。 原因となっている意味規則は関数あるいはメソッド呼び出しのそれだ、それでもし最初であるなら、文字は左だ、括弧、本当はそれはメソッドあるいは関数に呼び出しだ：
<foo('bar')>
もし識別子の後の最初の文字がそうであるなら=それから、識別子は別名として続くものだと思い込まれる。 特に、
<foo=bar>
ただ速記が賛成だ
$<foo> = <bar>
このエイリアシングがオリジナルの（人たち・もの）を修正しないことに注意を払え<bar>
キャプチャ。 オリジナルの名前を使ってなしに遺伝するメソッドキャプチャを改名するために、あなたが隠すことを望むキャプチャで下記のドット書式を使え。 すなわち、
<foo=.bar>
desugars 値：
$<foo> = <.bar>
同じく、明示的に、使用レキシカルにスコープ宣言された正規表現を改名すること&
形式が下を記述した。 すなわち、
<foo=&bar>
desugars 値：
$<foo> = <&bar>
多数の別名は許可されていて、そうだ
<foo=pub=bar>
賛成で短い
$<foo> = $<pub> = <bar>
もし識別子の後の最初の文字が空白文字であるなら、次のテキスト（何の後にでも空白文字）は正規表現として通過して、そうだ：
<foo bar>
さらに多くあるいはより少ない同等物はそうするはずだ
<foo(/bar/)>
パスするために、あなたが使わなくちゃならない先行する空白文字、括弧で括られた形式、を持っている正規表現。
もし最初の文字が空白文字によって後に続かれたコロンであるなら、テキストの残りが、ただ普通の Perl 構文のように、メソッドへの引数の傾きと思われる。 それでこれらは同じことを意味する：
<foo('foo', $bar, 42)>
<foo: 'foo', $bar, 42>
他のどのような文字も最初の識別子の後に許されない。
サブルールマッチが宣言部分だと見なされたサブルールの前部がそうであるという程度それ自身への宣言部分だと見なされる。 もしサブルールがシーケンスポイントを含むなら、それからサブルールマッチもそうする。 マッチしている Longest - トークンが例えばこのようなサブルールを過ぎて進まない。
それが関数であるかのように、この形式は常にレキシカルにスコープ宣言された正規表現宣言に優先を、直接それにディスパッチングを与える。 もし範囲にこのようなどのも語彙の正規表現（あるいは語彙のメソッド）がないなら、呼び出しは、1（人・つ）があると想定して、現在の文法にディスパッチされる。 すなわち、もしあるならmy regex foo それから、現在のレキシカルスコープから目に見える
<foo(1,2,3)>
同じを意味するけれども
<foo=&foo(1,2,3)>
しかしながら、もしノーがあるなら、そんなものがレキシカルに正規表現（そしてデフォルトまでに語彙のエイリアスを持っていないメソッドとして文法の中で、正規表現がインストールされていることに注意を払え）をスコープ宣言した、それから呼び出しは電流の上に標準のメソッドとしてディスパッチされるCursor （それは、もしあなたが現在文法の中でいないなら、失敗するだろう）。 それでこのような場合：
<foo(1,2,3)>
同じを意味するけれども :
<foo=.foo(1,2,3)>
そうするための呼び出し<foo> 失敗するだろうもしいずれもない、何でもレキシカルにそれが呼び出すことができるその名前のルーチンをスコープ宣言した、そしてその名前のどんなメソッドでもも同様である、それは届かれるメソッドディスパッチとして. （どのディスパッチャーを使うべきかについての決断はコンパイル時間にされる、ランタイム；メソッド呼び出しではないにバックアップメカニズムじゃない。）
A leading . サブルール；頭文字ではない英数字が同じく名指されたアサーションを起こすという事実として明示的にメソッドを呼び出すからそれがマッチするものをとらえるな（サブルールキャプチャを見ろ。 例：
/ <ident> <ws> / # $/<ident> and $/<ws> both captured / <.ident> <ws> / # only $/<ws> captured / <.ident> <.ws> / # nothing captured
アサーションはさもなければ、識別子から始まるアサーションに、同じく解析される、ドットが識別子であった後、次のものを供給した。 識別子フォーム、何ででもマッチしているエンジンに関しての余分の引数が暗黙としての引数リストに自動的に供給される（とき・から・につれて・ように）Cursor インボカント。
もし現在のクラス / 文法がないなら、あるいはではないが生じた現在のクラスCursor呼び出しが多分失敗するためにである.
もし識別子によって後に続かれたドットではない、それが間接的なメソッドのような、若干の型の「ドットのある」後尾辞と解析されるなら、呼び出せ：
<.$indirect(@args)>
マッチしているすべての正規表現、流れと同じように、ステートとマッチする（いずれかのデリバティブのCursor）この場合ただメソッドのインボカントである最初の引数とパスされる. メソッドは新しいマッチステートオブジェクトのいい加減なリストを返すために期待される、あるいはNil もしマッチが完全に失敗するなら。 Ratchetedなルーチンが典型的にたった1つのマッチを含んでいるリストを返すだろう。
のに対して前置. 明瞭にメソッド、前置を呼び出す&
その代わりに明瞭にルーチンを呼び出す。 ルーチンが宣言されなくちゃならないほど正規表現（あるいは輸入された）でmy あるいはour 有効範囲規則が、デフォルトまでに正規表現名が、ただ普通のメソッドと同じように、ただ現在のクラスのメタオブジェクトの例にインストールされているから、その名前をレキシカルスコープに見えさせる。 ルーチンは一種の私的なサブメソッドの役をして、そして継承のどんな思いやりもなしで呼び出される。
それはまだ付かなくちゃならないCursor その最初として（それが、もしそれが好むならインボカントであると考えることができる）引数と不可欠がカーソルオブジェクトとして新しいマッチステートを下す。 従って、
<&foo(1,2,3)>
何かのために構文糖である同種のもの：
<.gather { take foo($¢,1,2,3) }>
どこ（で・に）か$¢ 現在の入ってくるマッチステートを表す、そしてルーチンは戻らなくちゃならないNil 失敗のために、あるいはマッチが明記する1つ以上のいい加減なリスト（Cursor－ オブジェクトを得た）成功したマッチのために.
と同じように. フォーム、明示& キャプチャを隠す。
それほどすべて標準に注意しろRegex オブジェクトは本当にこのような変装した定常課程だ。
あなたが言うとき：
rx/stuff/
あなたは本当に匿名のメソッド、何かが好むと宣言している：
my $internal = anon regex :: ($¢: ) { stuff }
そして次に離れて間接的にそれを呼び出すであろうほかの誰かにそのオブジェクトをパスする。 この場合、メソッドはクラスへともそしてレキシカルスコープの中にもインストールされていない、しかし値がどうにかして生の状態でいる限り、それはまだ間接的に呼び出されることができる（下参照）。
A leading $ 間接的なサブルール呼び出しを示す。 変数はいずれかを含んでいなくちゃならないRegex オブジェクト（本当は － が上に見る匿名のメソッド）、あるいは正規表現としてコンパイルされる文字列。 文字列は決して文字通りに合われない。
もし文字列形式のコンパイルが失敗するなら、エラーメッセージは警告に変換される、そしてアサーションは失敗する。
間接的なサブルールアサーションではないは取り込んだ。 （先行する句読点を持っているアサーションがデフォルトによってとらえられない。） あなたは常に、もちろん、明示的にそれをとらえてもよい：
/ <name=$rx> /
間接的なサブルールが常に手続き上であると見なされて、そしてマッチして最も長いトークンに関与しないかもしれない。
A leading :: 象徴的な間接的なサブルールを示す：
/ <::($somename)> /
変数はサブルールの名を含んでいなくちゃならない。 一つのメソッドディスパッチのルールによってこれは現在の文法とその先祖で最初に捜される。 もしこの捜索が失敗するなら、試みが MMD としてのディスパッチにされる、そしてその場合それはサブルールがメソッドよりむしろ multis と定義されているのを見いだすことができる。 デフォルトによって取り込まれたこの書式ではない。 それは常に手続き上であると見なされる、宣言部分じゃない。
A leading @ マッチがそれぞれの要素がサブルールとして扱われること以外そのままの配列のようだ（文字列あるいはRegex オブジェクト）リテラルとしてよりむしろ.
すなわち、文字列が、文字通りに合われる代わりに、サブルールとしてコンパイルされることを強いられる。 （賛成の相違がないRegex オブジェクト。）
このアサーションではないは自動的に取り込んだ。
アサーションとしてのハッシュの使用は遠慮がちだ。
A leading { サブルールとしてその時点でパターンの中に補間挿入されるために正規表現を作り出すコードを示す：
/ (<.ident>) <{ %cache{$0} //= get_body_for($0) }> /
クロージャは規準的な時に動かされることを保証される；それはシーケンスポイントを宣言して、そして手続き上であると見なされる。
正規表現補間について、もし値がたまたますでにそうであるなら何ででも場合Regex ではないがリコンパイルしたオブジェクト、それ。 もしそれが文字列であるなら、それがそうじゃないように、コンパイルされたフォームは、文字列が変化しないなら、次にあなたがそれを使うとき、リコンパイルされて文字列でキャッシュされる。 （けれども Any 外部語彙変数名は毎回再境界に違いない。） サブルールが不平衝をかっこでくくることで間にはさまれないかもしれない。 補間挿入されたサブルールがそれ自身の内面的なマッチ結果を一つの項目として保持する、それでその括弧は決して組分けを外の正規表現とみなさない。 （言い換えれば、括弧ナンバリングが常にレキシカルスコープなだ。）
A leading ?{ あるいは!{ コードアサーションを示す：
/ (\d**1..3) <?{ $0 < 256 }> /
/ (\d**1..3) <!{ $0 < 256 }> /
類似の値：
/ (\d**1..3) { $0 < 256 or fail } /
/ (\d**1..3) { $0 < 256 and fail } /
クロージャと異なり、もしオプティマイザが何かが後にマッチすることができないことを証明することができるなら、宣言部分；それらがそうであるアサーションがだと見なされるコードが規準的な時に失点であることを約束した。 それであなたはそのように規準的でないクロージャに呼び出しをこっそり持ち込むことができる：
token { foo .* <?{ do { say "Got here!" } or 1 }> .* bar }
do 文字列後方一致じゃないなら、ブロックが走ることがありそうもない「bar」.
A leading [ 列挙された文字クラスを示す。 クラスが一緒に示される列挙された文字でのレンジ「.." rather than " -」.
/ <[a..z_]>* /
空白文字が正方形の括弧の中で無視されて存在する：
/ <[ a .. z _ ]>* /
反転させられたレンジが非合法だ。 直接コンパイルされたコードで言うことはコンパイル時エラーだ
/ <[ z .. a ]> / # Reversed range is not allowed
間接的にコンパイルされたコードで、類似の警告が表示される、そしてアサーションは失敗する：
$rx = '<[ z .. a ]>'; / <$rx> /; # warns and never matches
A leading - 補完された文字クラスを示す：
/ <-[a..z_]> <-alpha> / / <- [a..z_]> <- alpha> / # whitespace allowed after -
これは本質的に否定的な先読みとドットを使うことと同じだ：
/ <![a..z_]> . <!alpha> . /
空白文字がイニシャルの後に無視される-.
A leading + 次のキャラクタークラスが肯定的な感覚で合われるはずであることを示すために同じく供給されるかもしれない。
/ <+[a..z_]>* / / <+[ a..z _ ]>* / / <+ [ a .. z _ ] >* / # whitespace allowed after +
文字クラスが角括弧の一つのセットの中で（付加的に、あるいは subtractively に）結合されることができる。 空白文字が無視される。 例：
/ <[a..z] - [aeiou] + xdigit> / # consonant or hex digit
クラスがそれ自身使われるかもしれない名指された文字：
<alpha>
しかしながら、あなたが一緒に名指されたキャラクタークラスを前接続しなくちゃならないクラスを結合するために+ あるいは-. 空白文字が何の前にでも必要とされる- それは識別子エクステンダとして間違えて解析されるだろう。
Unicode プロパティが標準の規則名前：の代わりにペア表記の使用によって示される
<:Letter> # a letter <:!Letter> # a non-letter
引数と一緒のプロパティが引数として二人にパスされる：
<:East_Asian_Width<Narrow>> <:!Blk<ASCII>>
ペア値は Unicode データベースで値に対してスマートマッチされる。
<:Nv(0 ^..^ 1)> # the char has a proper fractional value
スマートマッチの特定の訴訟として、 TR18 セクション2.6は引数としてパターンに満足している：
<:name(/^LATIN LETTER.*P$/)>
これらの項の Multiple は pluses とマイナスと組み合わせられるかもしれない：
<+ :HexDigit - :Upper >
項が同じく使って結合されるかもしれない& セット論理積のために、|
セット連合のために、そして^ 対称のセット差で。 括弧が集まるために使われるかもしれない。 （Square 括弧が常にリテラルの文字（バックスラッシュされたリテラルのフォームを含めて）を引用して、そして TR18 のセクション 1.3 で、示唆された表記法と異なり、ネストされないかもしれない。） 演算子の優先は、それらがいくぶん異なった意味規則を持っているけれども、 S03 で、演算子優先で相応して名指された演算子と同じだ。
余分の長い文字がそれらを引用することによってそして論理積としてのそれらを含めて入られるかもしれない。 Any によって引用された文字が、適切であるとき、「最も長いトークン」として扱われるだろう。 ここがそうするだろう」、「l」に対する優先で：識別されるだろう
/ <[ a..z ] | 'ñ' | 'ch' | 'll' | 'rr'>
特別なアサーション<.> （キャラクタシーケンスを結合している Unicode を含めて）どんな論理的な書記素とでもマッチする：
/ seekto = <.> / # Maybe a combined char
として同じ :
/ seekto = [:graphs .] /
A leading ! 否定された意味（常にゼロ幅アサーション）を示す：
/ <!before _ > / # We aren't before an _
それに注意しろ<!alpha> 異なったから<-alpha>.
/<-alpha>/ 補完されたキャラクタークラス同等物がそうするはずだ/<!before <alpha>> ./のに対して、<!alpha> ゼロ幅アサーション同等物がそうするはずである/<!before <alpha>>/ アサーション。
同じくそれをメタキャラクタと注意しろ! 続くものは何の構文解析規則も変える（、例えばと異なり+ あるいは-）.
A leading ? 正ゼロ - 幅アサーションが示す、そして好む!
回帰的にただアサーションの残りを再び解析するかのように?
そこになかった。 強制力ゼロ幅のほかに、それは同じくキャプチャという名前の何でも隠す：
<alpha> # match a letter and capture to $alpha (eventually $<alpha>) <.alpha> # match a letter, don't capture <?alpha> # match null before a letter, don't capture
特別な名指されたアサーションは次のものを含む：
/ <?before pattern> / # lookahead
/ <?after pattern> / # lookbehind
/ <?same> / # true between two identical characters
/ <.ws> / # match "whitespace":
# \s+ if it's between two \w characters,
# \s* otherwise
/ <?at($pos)> / # match only at a particular StrPos
# short for <?{ .pos === $pos }>
# (considered declarative until $pos changes)
それは、前部において句読点を省略することによって、これらのアサーションの何でも名指されたキャプチャとして使用するために正当だ。 しかしながら、キャプチャが記憶と計算両方で若干の間接費を必要とする、それで一般にあなたはあなたが維持することに興味を持っていないデータに対するそれを隠すことを望む。
after アサーションが構文の木を無効にして通り過ぎて後読みを実装する、そして左に行っている反対の命令の中のものを探す。
反転させられることができないパターンに関して後読みをすることは非合法だ。
注意しろ：レベルが達成されることができるトップでの前進的な走査の後読みの効果：
/ .*? prestuff <( mainpat )> /
A leading * 次のパターンが部分的なマッチを許すことを示す。 できる限り多くの文字とマッチした後で、それは常に成功する。 （ゼロ幅が0文字をなら、マッチすることはそうじゃない。）
例えば、あなたが何でも書くかもしれない省略、の数とマッチするために：
s/ ^ G<*n|enesis> $ /gen/ or
s/ ^ Ex<*odus> $ /ex/ or
s/ ^ L<*v|eviticus> $ /lev/ or
s/ ^ N<*m|umbers> $ /num/ or
s/ ^ D<*t|euteronomy> $ /deut/ or
...
/ (<* <foo bar baz> >) /
/ <short=*@abbrev> / and return %long{$<short>} || $<short>;
パターンは宣言部分に制限される、それが書き直されることができるフォームがオプションをネストした、文字がマッチする。 連続情報が、文字の後に続くすべてをオプションにしている間に、捨てられないかもしれない。 すなわち、それは書き直すに十分じゃない：
<*xyz>
けれども :
x? y? z? # bad, would allow xz
その代わりに、それは実装されなくちゃならないけれども :
[x [y z?]?]? # allow only x, xy, xyz (and '')
限定記号がそうである明示がこれが単一文字の上で、そうであることを可能にした：
<* a b+ c | ax*>
何かとして書き直される同種のもの：
[a [b+ c?]?]? | [a x*]?
後の例で我々は DFA トークン照合回路がいずれにしても我々に最も長いマッチを与えるだろうと想定している。 数量化された多文字の連続が回帰的に再マップされることができることは同じく可能だ：
<* 'ab'+> # match a, ab, ababa, etc. (but not aab!) ==> [ 'ab'* <*ab> ] ==> [ 'ab'* [a b?]? ]
［推測：どのように我々が得る思いつき、我々がそうするかもしれない（あるいはそうしないかもしれない）かに依存して、あいまい性を自動的に検出することが可能であれ<*@abbrev> そして、（たとえより長い省略の接頭辞であるとしても、正確なマッチがより短い abbrev について常に許されるべきであるけれども）、あいまいな省略を生成することを拒否しろ。 もしそれができないなら、ユーザーはマッチの後にあいまい性を調べなければならないだろう。 同じく配列形式が配列がしばしば変化しないと想定していることに注意を払え。 もしそれがそうするなら、最も長いトークンの照合回路は計算し直されなければならない、そしてそれは高価になることができた。］
A leading ~~ 現在の統治のいくらかあるいはすべてに戻ってリカーシブコールを示す。 オプションの引数がどのサブパターンを再利用するべきかを示して、そしてもし供給されるなら一つのサブパターンに確認しなくちゃならない。
もし除かれるなら、パターン全体は回帰的に呼び出される：
<~~> # call myself recursively <~~0> # match according to $0's pattern <~~foo> # match according to $foo's pattern
この再一致、文字列ではなく、名前と結び付けられるパターン、がマッチしたことに注意を払え。 それで
$_ = "foodbard" / ( foo | bar ) d $0 / # fails; doesn't match "foo" literally / ( foo | bar ) d <$0> / # fails; doesn't match /foo/ as subrule / ( foo | bar ) d <~~0> / # matches using rule associated with $0
最後のものが同等であるそうすること
/ ( foo | bar ) d ( foo | bar ) /
それほど「self」的な呼び出しに注意しろ
/ <term> <operator> <~~> /
これに戻ってサブルールとしての匿名の統治を呼び出して、そして暗黙のうちに固定されるから他のサブルールがであろう何としての演算子の終わりも。 外の規則が文字列を走査するにもかかわらず、それへの内部の呼び出しはそうしない。
あなたが同じく得る前のセクションの結果がそうである注目
<!~~>
ただで、もし現在の規則がこの場所で再びマッチするであろうなら、それは失敗する。
A leading | 数種類のゼロ幅の境界を示す。
<|w> word boundary <|g> grapheme boundary (always matches in grapheme mode) <|c> codepoint boundary (always matches in grapheme/codepoint mode)
次のトークンは角を含む、しかしバランスをとるように要求されない：
A<( 文通することである間に、トークンがマッチの全体的なキャプチャの始めを示す)> トークンがその末端を示す。 合われるとき、これらは常に真のアサーションとして振る舞うが、環境の副作用を持つ.from そして.to マッチオブジェクトの属性。 すなわち、：
/ foo <( \d+ )> bar /
同等の値：だ
/ <?after foo> \d+ <?before bar> /
それ以外賛成のスキャン「foo」アサーションが多分走査するであろう後読みである間に、順方向で終わり得る\d+ そして次にマッチ「foo」後ろ向き. 使用の<(...)> ただ始まることとマッチを終わらせることのポジションだけに影響を与える、そして何でもそれらのポジションに基づいて計算した。 上のマッチの後の、例えば$() ただ合われた数値だけを含んでいるそして$/.to 数値の後にポインティングはそうするはずか。
（名指されているか、あるいはナンバーが付けられた）他のキャプチャは擦れていなくて、そして完全にアクセスされるかもしれない$/.
トークンがそうであるこれらは見なした、宣言部分が、けれども、バックトラックしている振る舞いを強制するかもしれない。
A« あるいは<< トークンが左のワード境界を示す。 A» あるいは>> トークンが右のワード境界を示す。 （トークンを分離するように、これらはバランスがとれている必要がない。） Perl 5 の\b 通り過ぎて置き換えられる<|w>
「ワード境界」アサーション、他方\B なる<!|w>. （これらのいずれも定義に依存しないの<.ws>しかしただ上に\w
「単語」文字の定義。 前の文字の単語プロパティを計算することにおいて、ノースペースマーク文字が無視される。 TR18 1.4 を見ろ。）
これらはどんな文法あるいは正規表現のためにでも前もって定められたサブルールだ：
識別子とマッチする。
一つの大文字文字とマッチする。
一つの小文字文字とマッチする。
一つのアルファベット文字とマッチする。
一つの数値とマッチする。
一つの16進法の数値とマッチする。
一つのプリント可能な文字とマッチする。
一つの「写実的な」文字とマッチする。
一つの「コントロール」文字とマッチする。 コントロール文字は通常実際のアウトプットを産み出さない（の・もの・人）だ、しかしその代わりにどうにかして最終の（人たち・もの）：例えば改行とバックスペースがそうであるコントロールが文字をコントロールする。 127（DEL）の ord () 値と一緒の文字であるように、 ord () 32以下を持っている文字が通常分類されているすべては（ASCII 、 ISO Latin 文字セットと Unicode を想定している）文字をコントロールする。
一つの句読点文字とマッチする。
一つの英数字の文字とマッチする。 これは ＜ ＋ アルファ ＋ 数値 ＞ と等しい。
ワード境界において真のゼロ幅マッチを返す。 ワード境界が、文字列の始まりと終わりをマッチしている「\W」として勘定に入れて、他の側に（いずれかのオーダーで）片側と「\W」の「\w」を持っているスポットだ。
2単語文字（ゼロ幅マッチ）の間にマッチする。
2単語文字の間の必要とされる空白文字、違っているオプションの空白文字とマッチする。 これは乱暴に同等であるそうすること<!ww> \s*
（ws 使うように要求されないww サブルール）.
一つの空白文字文字とマッチする（同じけれども \s ）.
一つの「ブランク」文字とマッチする － たいていのロケールで、これはスペースとタブに対応する。
pattern
先読みを行なえ － すなわち、もし我々がどこ（で・に）ポジションにいるなら、調べろpattern マッチする。 ゼロ幅を返すMatch 成功の上のオブジェクト。
pattern
後読みを行なえ － すなわち、現在の位置の前の文字列が（終わりに固定された） <パターン>とマッチするかどうか調べろ。
ゼロ幅を返すMatch 成功の上のオブジェクト。
マッチ空の文字列が、すなわち、常に真に戻る
<?> の Inverse が、すなわち、常に偽に戻る。
\p そして\P なられた本質的な文法がそんなものを支配するプロパティ（<alpha> そして<-alpha>）. それらは前述の文字クラス表記法を使って合わせてであるかもしれない：<[_]+alpha+digit>. もっとレベルが高い文字 class name にかかわらず、低レベルの Unicode プロパティは角括弧の中で、すなわち、ペア表記法で、コロンの接頭辞で常に利用可能だ。
従って、<+:Lu+:Lt> 匹敵するものはそうするはずだ<+upper+title>.
\L...\E\U...\Eそして\Q...\E 連続はなくなっている。 あなたが使うことができるそれらを必要とするまれなケースで<{ lc $regex }> など.
\G 順序はなくなっている。 使用:p その代わりに。 （注意する、しかしながら、使うことが意味をなさないこと:p パターンの中で、すべての内部からパターンが現在の位置に暗黙のうちに固定される。）
見るat 下のアサーション。
Backreferences （例えば。 \1\2など）なくなった；$0$1など、変数がもう補間挿入されないから、その代わりに使われることができる.
数の変数が毎回を変えると考えられて、そして従って、標準の変数と異なり、手続き上であると見なされる。
新しいバックスラッシュの連続、\h そして\vそれぞれ Unicode を含めて、マッチ水平線と垂直の空白文字。 水平空白がマッチしている何とでも定義される\s それは同じくマッチしない\v. 空白文字が何としてでも定義される Vertical ：
U+000A LINE FEED (LF) U+000B LINE TABULATION U+000C FORM FEED (FF) U+000D CARRIAGE RETURN (CR) U+0085 NEXT LINE (NEL) U+2028 LINE SEPARATOR U+2029 PARAGRAPH SEPARATOR
それがただ水平に「乗り物」を動かすだけであるにもかかわらず、そのU ＋ 000D CARRIAGE RETURN （クレッセント）が垂直の空白文字だと見なされることに注意を払え。
\s 今がどんな Unicode 空白文字とでもマッチする。
新しいバックスラッシュの連続\N それが否定である論理的な改行；以外の何とでもマッチする\n.
他の新首都バックスラッシュの連続は同じくそれら小文字対応物の否定だ：
\H 水平空白以外なら何とでもマッチする。
\V 垂直の空白文字以外なら何とでもマッチする。
\T タブ以外なら何とでもマッチする。
\R 復帰以外なら何とでもマッチする。
\F formfeed 以外なら何とでもマッチする。
\E エスケープ以外なら何とでもマッチする。
\X... （16進数で指定された）指定文字以外なら何とでもマッチする。
Perl 5qr/pattern/ 正規表現コンストラクタはなくなっている。
Perl 6 同等物はそうだ：
regex { pattern } # always takes {...} as delimiters
rx / pattern / # can take (almost) any chars as delimiters
あなたは区切り文字のために空白文字あるいは英数字を使ってはならない。 引数あるいは関数括弧を修飾子から区別するために必要とされないなら、スペースはオプションだ。 あなたが括弧を使うかもしれないようにけれどもあなたrx 区切り文字、けれどもあなたが空白文字に挿入する場合に限り：
rx ( pattern ) # okay rx( 1,2,3 ) # tries to call rx function
（これは Perl 6 にすべての quotelike 構造のために真だ。）
rx 形式がどこでも直接パターンとして使われるかもしれない正常// マッチの容器。
regex 形は本当はメソッド定義であって、そしてそれが使われるはずである文法クラスが外見上明白であるような方法で使われなくちゃならない。
もしいずれかのフォームが修飾子を必要とするなら、それらが冒頭の区切り文字に先行する：
$regex = regex :s:i { my name is (.*) };
$regex = rx:s:i / my name is (.*) /; # same thing
もしあなたが区切り文字のために文字をかっこでくくっている何でも使うなら、スペースは最終の修飾子の後に必要だ。 （さもなければそれは修飾子に引数と考えられるだろう。）
あなたは区切り文字のためにコロンを使ってはならない。 スペースが修飾子の間に許される：
$regex = rx :s :i / my name is (.*) /;
コンストラクタの名前は変えられたからqr なぜならそれはもう補間挿入されているクォートのような演算子じゃないから。 rx （それらが存在するときを除いて、正規表現と混同されないために）、正規表現の省略だ。
構文が示すように、そうすることは今いっそうしっかりと類似しているsub {...}
コンストラクタ。 実際、その類似は Perl 6 に非常に深くなる。
ただ as a 生{...} 同じく、それほど、今は常に（ある特定のコンテキストですぐにまだ実行して、そして他のものにオブジェクトとパスされるかもしれない）クロージャである生/.../ 常に今、であるRegex （ある特定のコンテキストですぐにまだマッチして、そして他のものにオブジェクトとパスされるかもしれない）オブジェクト。
Specifically, a /.../ 値コンテキスト（無効で、ブールの、文字列、あるいは数値的）、あるいはそれが明示的な引数であるいつですぐにマッチする~~. さもなければそれRegex 明示とまったく同じのコンストラクタregex できろ。 それでこれ：
$var = /pattern/;
もうマッチをして、そして沈まない$var 結果に。
その代わりにそれは割り当てるRegex そうするためのオブジェクト$var.
ケースが常に使って卓越し得る2（人・つ）m{...} あるいはrx{...}：
$match = m{pattern}; # Match regex immediately, assign result
$regex = rx{pattern}; # Assign regex expression itself
これが前の魔法のようにいい加減な使用法が好むことを意味することに注意を払え：
@list = split /pattern/, $str;
今ただ標準の意味規則の結果だ。
法令が好きであるユーザー定義のサブルーチンをセットアップすることは今同じく可能だgrep：
sub my_grep($selector, *@list) {
given $selector {
when Regex { ... }
when Code { ... }
when Hash { ... }
# etc.
}
}
あなたがいつを呼び出すかmy_grep最初の引数が項目コンテキストでバインドされるが、それほどパスする{...} あるいは/.../ 生産するCode あるいはRegex スイッチ文がそれからそれの上に選択するオブジェクト。 （標準だgrep ただ賃貸物件すべて仕事的に演算子ドにスマートマッチしろ。）
同じぐらいrx 変形を持って、それほどそうするregex 宣言詞。
特に、文法に使用のために2つの特殊な変形がある：token そしてrule.
トークン宣言：
token ident { [ <alpha> | _ ] \w* }
決してデフォルトまでにバックトラックしない。 すなわち、それはそれがこれまでのところ走査したものは何でも約束することを好む。 上の（人たち・もの）が同等であるそうすること
regex ident { [ <alpha>: | _: ]: \w*: }
しかし読むことがどちらかと言うとより容易だ。 そのままの（人たち・もの）*+そして? 限定記号が決して中にバックトラックしないtoken. 標準の正規表現、使用で*:+:あるいは?: 何でも修飾名の中にバックトラックするのを妨げるために。
もしあなたが明示的にバックトラックすることを望んで、いずれかを付加するなら? あるいは!
修飾名に。 ? いつものように最小のマッチングを強制する、他方! マッチしている貪欲な力。 token 宣言詞は賛成で本当にただ短い
regex :ratchet { ... }
他がそうであるrule 文法で非終端子プロダクションを宣言するための宣言詞。 Like a token同じくそれデフォルトまでにバックトラックする. 建て増し、でrule 同じく正規表現を想定する:sigspace. Arule 賛成で本当に短い：
regex :ratchet :sigspace { ... }
Perl 5?...? 構文（1度成功しろ）がめったに使われなかった、そして可変的にステートでいっそうきれいに今エミュレートされることができる：
$result = do { state $x ||= m/ pattern /; } # only matches first time
パターンをリセットするために、ただ言え$x = 0. もしあなたが欲するならけれども$x あなたがブロックを使うのを避けなければならないであろう visible ：
$result = state $x ||= m/ pattern /; ... $x = 0;
宣言部分よりむしろ手続き上であると見なされるパターンのそれらの部分の中で、あなたはバックトラックしている振る舞いをコントロールしてもよい。
デフォルトまでに、バックトラックすることは中に貪欲だrxmsなど.
それは普通で中に同じく貪欲だregex 宣言。 中にrule
そしてtoken バックトラックしている宣言は明示的でなくてはならない。
前のアトムに熱心なバックトラックすること、付加をすることを強いること:? あるいは? アトムに。 もし前のトークンが修飾名であるなら、: それほど、除かれるかもしれない*? ただ Perl 5 のように働く。
前のアトムにそうするであろう場所で貪欲なバックトラックすることに違っているデフォルト、付加をすることを強いること:! アトムに。
もし前のトークンが修飾名であるなら、: 除かれるかもしれない。
（5が Perl 5 に貪欲にバックトラックすることは常に義務を怠るから対応する構造を持っていない Perl）
前のアトムにバックトラックすることをしないことを強いるために、シングルを使え:
なしに次? あるいは!. 一つのコロンにわたってバックトラックすることは正規表現エンジンを前のアトムを再び試みさせない：
ms/ \( <expr> [ , <expr> ]*: \) /
（すなわちより少数を試しているポイントがない<expr> マッチする、もし地平線に姿を現している終わりの括弧がないなら）
修飾名、を修正するとき、+ その代わりに使われるかもしれなの:修飾名がどちらのケースにしばしば所有欲が強い修飾名として知られているか。
ms/ \( <expr> [ , <expr> ]*+ \) / # same thing
展開式でのすべてのアトムにデフォルト、使用までにバックトラックしないことを強いるために:ratchet あるいはrule あるいはtoken.
コロンが離れてスローする二塁打を評価することはすべて現在の LTM 交代における選択ポイントをセーブした。
ms/ [ if :: <expr> <block>
| for :: <list> <block>
| loop :: <loop_controls>? <block>
]
/
（すなわち、もし1つがすでに見いだされて、しかし失敗されたなら、異なったキーワードとマッチしようとしているポイントがない）。
:: 同じく通り過ぎて右手の宣言部分マッチ「最も長いトークン」処理から何でも隠す効果を持つ|. ただ左側だけが determinacy のために評価される。
:: もし現在の LTM 交代がないなら、何もしない。 「流れ」がダイナミックに、レキシカルにではなく、明確にされる。 A:: サブルールで交代を同封することに影響を与えるだろう。
評価すること::> 現在の一番奥の世俗的な交代におけるすべてのセーブされた選択ポイントをスローする。 それはそれで「それから」の役割を果たす。
ms/ [
|| <?{ $a == 1 }> ::> <foo>
|| <?{ $a == 2 }> ::> <bar>
|| <?{ $a == 3 }> ::> <baz>
]
/
あなたがまだこのような交代の「その時」部分に後退することができる、それであなたが置かれて同じくそうする必要があるかもしれないことに注意を払え: それの後にもしあなたが同じくそれを停止させることを望むなら。 もし明示あるいは暗黙であるなら:ratchet
暗黙を供給することによって、障害を持ったバックトラックすることを持っている:あなた明示を置く必要! 、例えば中に支持を可能にするべき交代の後に<foo> 上記の規則。
::> もし現在の世俗的な交代がないなら、何もしない。
「流れ」がダイナミックに、レキシカルにではなく、明確にされる。 A::> サブルールで交代を同封することに影響を与えるだろう。
コロンが離れてスローするトリプルを評価することは、現在の正規表現が入られたから、すべて選択ポイントをセーブした。 バックトラックするそうすること（あるいは過去）このポイントは完全に（正規表現でそれが起こる所はどんな所であっても）規則に失敗するだろう：
regex ident {
( [<alpha>|_] \w* ) ::: { fail if %reserved{$0} }
|| " [<alpha>|_] \w* "
}
ms/ get <ident>? /
（すなわち unquotedなリザーブワードを識別子ではないとして使用することは許した）
評価すること<commit> アサーションがマッチ全体のスタートからすべてのセーブされた選択ポイントをスローする。 バックトラックするそうすること（あるいは過去）このポイントはマッチ全体に失敗するだろう、サブルールが何（個・人）を打ち倒すかにかかわらずそれは起きる：
regex subname {
([<alpha>|_] \w*) <commit> { fail if %reserved{$0} }
}
ms/ sub <subname>? <block> /
（すなわちリザーブワードをサブルーチン名として使用することは同様に周囲のマッチに直ちに致命的だ）
もし確証が引数を与えられる、それが名前であるなら、呼び出している規則についてそれは責任を負われるべきだ：
<commit('infix')>
A<cut> アサーションが常に成功裏にマッチして、そして論理的にすでに合われた文字列の部分を削除することについての副作用を持つ。 これがすぐに実際にメモリを開放するかどうかがあなたの backreferences 、文字列実装とごみ収集人の間で種々の相互作用で依存するかもしれない。 何ででも場合、文字列はフロントでそれが切り取られたと報告するだろう。 それは使うことが法律違反だ<cut> あなたが書き込みアクセスを持っていない文字列に。
通り越してバックトラックしようと試みる<cut> 完全なマッチ倒産した原因（バックトラックしている過去のように<commit>）. これは今中にバックトラックするべき前のテキストがないからだ。 これは入力ストリームあるいは任意の長さのイテレータからマッチしているとき、離れて成功裏に処理されたインプットをスローすることに役立つ。
中間の類似sub そしてregex ずっとさらに拡張する。
あなたが匿名の sub を持っていることができるのとちょうど同じ（ように・時に）、そして名指された sub ・・・。
・・・それであまりにもあなたは匿名の正規表現と名指された正規表現（そしてトークンとルール）を持っていることができる：
token ident { [<alpha>|_] \w* }
# and later...
@ids = grep /<ident>/, @strings;
上記の例が示すように、次のような名指された正規表現に言及することは可能だ
regex serial_number { <[A..Z]> \d**8 }
token type { alpha | beta | production | deprecated | legacy }
他の正規表現で名指されたアサーションとして：
rule identification { [soft|hard]ware <type> <serial_number> }
これらのキーワードによって宣言された正規表現は公式に型の（こと・もの）だMethod得られるからRoutine.
概要、サブルール呼び出しがコントロールされる何でも固定することでその通話コンテキスト。
正規表現、トークン、あるいは規則メソッドが呼び出されるとき、サブルールとして、前部は現在の位置に固定される（と同じように:p）呼び出しているコンテキストから、固定された終わりではないが多分解析をし続けることを望むであろう間に. しかしながら、このようなメソッドが直接スマートマッチされるとき、それは始まりへの両端と文字列の終わりで自動的に固定される。 それで、あなたは、匿名の正規表現ルーチンをスタンドアローンのパターンとして使用することによって、マッチして直接のパターンをすることができる：
$string ~~ regex { \d+ }
$string ~~ token { \d+ }
$string ~~ rule { \d+ }
そしてこれらは同等だそうすること
$string ~~ m/^ \d+ $/; $string ~~ m/^ \d+: $/; $string ~~ m/^ <.ws> \d+: <.ws> $/;
基本的な概括的原則はキーワードによって定義されたメソッドが決して暗黙をしないということだ.*?走査のような － 、他方m// そしてs///
quotelike フォームが明示的なアンカリングがないときにはこのような走り読みする。
rx// そして// フォームがどちらにも行くことができる：使われるとき、直接中のそれらスキャンスマートマッチするあるいはブールのコンテキスト、けれども呼び出されるとき、間接的にサブルールそれらとしてスキャンではなくする. すなわち、通り過ぎて返されたオブジェクトrx// 同種のものを行儀よく振る舞うm// 直接使われるとき、けれども好むregex
{} サブルールとして使用されるとき、：
$pattern = rx/foo/; $string ~~ $pattern; # equivalent to m/foo/; $string ~~ /'[' <$pattern> ']'/ # equivalent to /'[foo]'/
空のパターンは今非合法だ。
事前の成功した正規表現が一致したものは何、使用とでもマッチするために：
/ <prior> /
ゼロ幅文字列とマッチするために、あなたはゼロのマッチの若干の明白な代表を使わなくちゃならない：
/ '' /; / <?> /;
例：
split /''/, $string
文字の間の分裂。 けれどもそれから、これもそうする：
split '', $string
同じく、空の代替物とマッチするために、何かを使え：
/a|b|c|<?>/ /a|b|c|''/
これはこのようなエラーをキャッチすることをより容易にする：
/a|b|c|/
しかしながら、特殊事例として、マッチで最初の空の代替物は好む
ms/ [
| if :: <expr> <block>
| for :: <list> <block>
| loop :: <loop_controls>? <block>
]
/
ただ無視される。 ただ最初の代替物だけがそのように特別だ。 もしあなたが書くなら：
ms/ [
if :: <expr> <block> |
for :: <list> <block> |
loop :: <loop_controls>? <block> |
]
/
それはまだエラーだ。
しかしながら、空でない構文的な構造が空の文字列に匹敵している変化したケースを持っていることは問題がない：
$something = ""; /a|b|c|$something/;
特に、<?> 常に、成功裏に、空の文字列とマッチするそして<!> 常に何とでもマッチし損ねる。
世俗的な交代を表す代わりに、| 今が宣言部分の最も長いトークンの意味規則で論理的な交代を表す。 （あなたは今使ってもよい|| 古い世俗的な交代を示すために。 すなわち、|
そして|| 今仕事が正規表現構文の中でほとんど同じようにそれらとして正規表現の外でそれらが junctional とショート OR を表す構文をする。
これは事実を含むそれ| もっときつい優先を持つより||.）
歴史的に正規表現処理がバックトラックしている NFA アルゴリズムとしての Perl に進んだ。 これは非常に強力だ、しかし多くのパーサーが、少なくとも最高1ポイント、次々によりむしろ並列にルールを処理することによって、いっそう効率的に機能する。 もしあなたが yacc 文法のように何かを見るなら、あなたはパターンがあるところが見なした多くのパターン / 行動宣言が平行していることを見いだす、そして最終的に文法はどの動きを発するべきか決める。 解析をすることについてのデフォルト Perl ビューが（多分演算子優先を扱うボトムアップの「真ん中のレイヤ」で）本質的にトップダウンである間に、もし少なくともトークン処理が決定論的に進むなら、ユーザー理解のために極めて有用だ。 それで正規表現のマッチしている目的で我々は可能性がある副作用あるいは self - 参照なしでトークンパターンをマッチされることができるそれらのパターンと定義する。 （空白文字がライン移行においてしばしば副作用を持つから、それは通常、少しの先読みほどのプラスマイナスはあるとしても、このようなパターンから除外される。） 基本的に、 Perl は、あなたがあなた自身1（人・つ）を書かなければならないということなしで、自動的に文法からレクサーを得る。
それを目指して、 Perl 6 のすべての正規表現がその「純粋な」パターンをその行動から区別して、そして最初のトークンパターンのそのリストを返すことが可能であるように要求される（過渡的にではないが許した self 参照を伝統的な正規表現に巻き込むであろう1度、それ以来よりさらにサブルールで、何でも含めてではなく、その正規表現の「純粋な」地域によって呼び出されたどんなサブルールのトークンパターンでも含めて）。 論理的な交代使用方法| それからこれらのリストとディスパッチの2かそれ以上を最も長いトークン接頭辞とマッチする代替物に持って行く。 これは最初にレキシカルに来る代替物であるかもしれない、あるいはそうしないかもしれない。
しかしながら、もし2つの代替物が同じ長さでマッチするなら、タイは特定性によって最初に破られる。 最も長い固定されている文字列が勝つ；すなわち、正確なマッチが文字を使って作られたマッチより閉じとして勘定に入れる前方一致が分類する代替物。 もしそれがうまくいかないなら、2つのメソッドの1つによって破られたタイ。 もし代替物が異なった文法であるなら、標準的な MRO （メソッド選択オーダー）は最初にどれを試みるべきか決定する。 もし代替物が同じ文法ファイルにあるなら、逐語的により以前の代替物は優先をとる。 （もし文法のルールであるならで1以上のファイルで定義されている、オーダーは未定義だ、そして明示的なアサーションが、もし間違った（の・もの・人）が最初に試みられるなら、失敗を強制するために使われなくちゃならない。）
この最も長いトークン接頭辞はレクサーを使う他のパージングシステムで乱暴に「トークン」の概念に対応する、しかし Perl のケースではこれは主として自動的に文法鮮明度から生じる epiphenomenon だ。 しかしながら、自動的に計算されていたにもかかわらず、トークンのセットはユーザーによって変更されることができる； 正規表現の中の種々の構造が宣言して教える、それがそうである文法エンジンはパターン部分そして、ユーザーが何がトークンだと見なされるか、そして何のではないかをコントロールするほど、このような構造を差し込むことによって、副作用を始めることを終わらせた。 トークン宣言を終えて、そしてパターンの「行動」部分を始めるとみなされた構造は次のものを含む：
Any ： : or ::: バックトラックしている制御（しかしそうじゃない：所有格の修飾子）.
Any アトムが最小のマッチですなわち、数量化される（使用方法? 修飾子）.
Any {...} 動き、しかしクロージャを含んでいるアサーションじゃない。
将官のクロージャフォーム**{...} 修飾名が最も長いトークンを終える、しかし closureless ではなくがフォームを終える。
Any 逐次制御流れ演算子のよう|| あるいは&&.
前のポイントの、結果としてそしてなぜなら標準的な文法の<ws> 統治が空白文字使用方法を定義する||トークンがとして暗黙的に合われた空白文字を含めて、その規則を使って空白文字とマッチするかもしれない正規表現あるいは規則について部分的に何によってでも同じく終了させられる最も長いもの:sigspace. （しかしながら、宣言がトークンの中で通り過ぎてこのようなもっと下級のプリミティブを使って特に空白文字を認識することを許されるトークン\h+ あるいは他の文字クラス。）
Subpatterns （キャプチャ）は特にトークンパターンを終えない、しかしトークンの再解析結果が subpatterns の場所を見いだすことを必要とするかもしれない。 同じく、最も長いトークンが決定された後、アサーションがチェックされる必要があるかもしれない。 （代わる代わる、もし DFA 意味規則が、 Thompson NFA によってのような、種々の方法の何かで仮想であるなら、 backchecks なしでいつアサーションを発するべきか知ることは可能であるかもしれない。）
貪欲な限定記号と文字クラスがトークンパターンを終了させない。 ワード境界のようなゼロ幅アサーションは同じく問題がない。
このようなアサーションがトークンの一部であり得るから、レクサーエンジンはこのようなアサーションの失敗から回復して、そして同じ長さ、あるいはもっと背が低いかもしれない、しかし決して現在の候補者より長くあり得ない次の最も良いトークン候補者にバックトラックすることができなければならない。
肯定的な先読みアサーションで始まるパターンのために、アサーションは次のパターンよりいっそう特定であると考えられる、それで先読みのパターンは最も長いトークンとして取り扱われる； 最も長いトークンの照合回路は何でもそれがマッチ続ける先読みいつ（そしてもし）によってくまなく渡り歩かれてテキストメッセージを送る再試合に十分にスマートだろう。
奇妙に十分、token トークンパターンが通常空白文字についてマッチして多くをしない限りにおいて以外、キーワードが特にトークンの範囲を決定しない。 それと対照的に、rule
キーワード（それ想定する:sigspace）最初の空白文字にそれ自身を不適格とする傾向があるパターンを定義する. それでパターンが来ることになるであろうトークンの大部分token 宣言。 インスタンス、トークン宣言のためにそんなものけれども
token list_composer { \[ <expr> \] }
その「最も長いトークン」がただ左大括弧であると見なす、なぜなら最初のものexpr ドが横断オプション空白文字である意志を抑制しろ。
これの例外として、そして読みやすさを促進するために、特別な例外がルールの中に交代のために作られる。 もし規則、あるいは何での変化でもならどこ（で・に）他のコンテキスト:sigspace 活発であって、交代のグループの前に空白文字を持っている、それで代替物の上の先行する空白文字がそうである何でも無視される。 すなわち、rule { [ a | b ] } それがそうであるかのように、扱われるrule { [a |b ] }そして LTM マッチで始まる最初非 sigspace アトム。
最初のトークン照合回路は大文字と小文字の区別（あるいは他のいかなるも標準化プリミティブ）を考慮に入れて、そして、同じ標準化を持っていないルールまで普及させられるときでさえ、正しいことをしなくちゃならない。 すなわち、それらがそうしなくちゃならない、セットを表すべき続けるがそれとマッチする、より低い規則はマッチするだろう。
|| 形式が意味規則と意志が試みない古いショートを持つ、から、すべての可能性じゃないなら、その右側とマッチする（すべてを含めて| 可能性）左に疲れ切った. 最初||
正規表現で左手のトークンパターンを外の最も長いトークンの照合回路に提供するが、マッチしている最も長いトークンからのどんな次のテストでも隠す。 すべての|| 新しい最も長いトークンの照合回路を確立する。 すなわち、もしあなたが使うなら| 右手に一方に加担しろ||右辺がこの部分式のために最も長いトークンの処理のために新しい最高級のスコープを確立する、そして何でもサブルールを呼び出したこと。 副菜の最も長いトークンのオートマトンが（それより）左寄りに見えない権利|| あるいは正規表現を含んでいることの外（に・で）||.
マッチが常に戻るMatch 同じく利用可能なオブジェクトけれども$/それは正規表現を呼び出している外のルーチンに宣言されるダイナミックな語彙だ。 （Aが名指されるregextokenあるいはrule ルーチンであって、そして従ってそれ自身のものが語彙であると宣言する$/ 常に統治、もし何の内にでも最も最近のサブマッチに言及する変数。） 現在のマッチステートは正規表現ので保持される$¢ 最終的にユーザーのにバインドされるであろう変数$/ マッチが完了する変数。
観念的に、マッチオブジェクトが（とりわけ）ブールの成功値、順序づけられたサブマッチオブジェクトの配列と名指されたサブマッチオブジェクトのハッシュを含んでいる。 （抽象構文ツリーの上に、建造することは同じくオプションとして通常使われた抽象的対象を媒介する）これらの種々の値、オブジェクトが異なったコンテキストで異なって評価するマッチへの都合が良いアクセスを提供するために：
それが同じぐらい真か、あるいは偽で評価するブールのコンテキスト（すなわちマッチは成功したか？）で：
if /pattern/ {...}
# or:
/pattern/; if $/ {...}
で:global あるいは:overlap あるいは:exhaustive ブールは最初のマッチに真に戻ることを許される。 Match オブジェクトが、もしリストコンテキストで評価されるならいい加減に結果の残りを産み出すことができる。
それが通常全部の合われた文字列であるそのマッチの文字列化された値に評価する文字列コンテキストで：
print %hash{ "{$text ~~ /<.ident>/}" };
# or equivalently:
$text ~~ /<.ident>/ && print %hash{~$/};
けれども一般にあなたは言うべきだ~$/ もしあなたが意味するなら~$/.
それが通常全部の合われた文字列であるそのマッチの数の値に評価する数のコンテキストで：
$sum += /\d+/; # or equivalently: /\d+/; $sum = $sum + $/;
スカラーとして、使われるとき、Match オブジェクトが評価するそれ自身に.
しかしながら、時々あなたは代わりのスカラ値にマッチで車に乗り続けて欲しい。 Match オブジェクト自身がコンクリートの解析樹を記述する、それでこの余分の値は呼び出される、抽象的なオブジェクトが；それはの属性として車に乗り続けるMatch オブジェクト。
.ast デフォルトによってのメソッドが未定義の値を返す。
$() 速記が賛成だ$($/.ast // ~$/).
そのために$() 通常ただ文字列、しかしあなたが呼び出して通り過ぎてそれをオーバーライドすることができるマッチ全体だmake 正規表現の中に：
my $moose = $(m[
<antler> <body>
{ make Moose.new( body => $<body>.attach($<antler>) ) }
# match succeeds -- ignore the rest of the regex
]);
これは新しい抽象的なノードを置く中に$/.ast. AST ノードがどんな型でもの（こと・もの）であるかもしれない。
これは任意のノード種別の抽象構文ツリーを増強することを都合が良くする。
あなたは同じくマッチ使用方法のサブセットをとらえるかもしれない<(...)> 構造：
"foo123bar" ~~ / foo <( \d+ )> bar / say $(); # says 123
この場合$() マッチして文字列をするとき、常に文字列だ、そして1つのリスト、あるいはもっと多くのマッチしているリストをしている要素いつ。
この構造は未設定をする.ast 属性。
配列として、使われるとき、Match オブジェクトがそのすべての位置のキャプチャの配列であるふりをする。 従って
($key, $val) = ms/ (\S+) => (\S+)/;
同じく書かれることができる：
$result = ms/ (\S+) '=>' (\S+)/; ($key, $val) = @$result;
一つのキャプチャを文字列に入れるために、添え字を使え：
$mystring = "{ ms/ (\S+) '=>' (\S+)/[0] }";
すべてのキャプチャを文字列に入れるために、 zen 断片を使え：
$mystring = "{ ms/ (\S+) '=>' (\S+)/[] }";
あるいはそれを配列に組み込め：
$mystring = "@( ms/ (\S+) '=>' (\S+)/ )";
それを、スカラー変数と注意する、$/ リストコンテキストで自動的に平らにならない。 使用@() 速記として賛成か@($/) リストコンテキストの下で位置のキャプチャを平らにするために。 それに注意するMatch オブジェクトがリストコンテキストでいい加減にそのマッチを評価することを許される。 使用eager @()
熱心なマッチに持ち込むために。
ハッシュとして、使われるとき、Match オブジェクトがそのすべての名指されたキャプチャのハッシュであるふりをする。 キーはシギルを含まない、それでもし変数にあなたキャプチャ@<foo> その実数名はそうだ$/{'foo'} あるいは$/<foo>. しかしながら、あなたはまだそれを参照してもよいけれども@<foo> どこでも$/
目に見える。 （けれども2つの異なったキャプチャデータ型のために同一名を使うことは誤っている。）
それを、スカラー変数と注意する、$/ リストコンテキストで自動的に平らにならない。 使用%() 速記として賛成か%($/) ハッシュとして平らになるか、あるいは適切な型の変数にそれをバインドするために。 と同じように@()それ賛成で可能だ%() リストコンテキストでいい加減にその対を生産するために。
名前をつけられるように、ナンバーが付けられたキャプチャはそれほど扱われるかもしれない$<0 1 2>
匹敵するものはそうするはずだ$/[0,1,2]. これはあなたが混ぜられた名指された、そしてナンバーが付けられたキャプチャの断片を書くことを可能にする。
.keys.values そして.kv メソッドが、リスト部分が最初に来るという状態で、リストに載っている両方ともとハッシュ地域を演ずる。
'abcd' ~~ /(.)(.)**2 <alpha>/; say ~$/.keys; # 1 2 alpha
普通のコード、変数で$0$1などただ別名である中に$/[0]$/[1]など. 従って、もし最後のマッチが失敗したなら、それらがまったく未定義だろう（それらが使わないでクロージャで明示的にバインドされなかったならlet キーワード）.
Match オブジェクトがマッチについて補足情報を提供するメソッドを持っている。 例：
if m/ def <ident> <codeblock> / {
say "Found sub def from index $/.from.bytes ",
"to index $/.to.bytes";
}
現在定義されたメソッドはそうだ
$/.from # the initial match position $/.to # the final match position $/.chars # $/.to - $/.from $/.orig # the original match string $/.Str # substr($/.orig, $/.from, $/.chars) $/.ast # the abstract result associated with this node $/.caps # sequential captures $/.chunks # sequential tokenization $/.prematch # $/.orig.substr(0, $/.from) $/.postmatch # $/.orig.substr($/.to)
正規表現の中で現在のマッチステート$¢ 同じく供給する
.pos # the current match position
この最後の値はいずれかに対応するかもしれない$¢.from あるいは$¢.to マッチが進んでいるかどうかについて、依存することがフォワードあるいは逆方向でだ（内部に生じている後のケース<?after ...> アサーション）.
上に、記述されるようにMatch リストでコンテキストがその位置のキャプチャを返す。 しかしながら、時々あなたはむしろそれらがテキストで起こるという命令でトークンのフラットなリストを受けとりたい。 .caps 名指されているか、あるいはナンバーが付けられたキャプチャの中にそれがどのようにさもなければバインドされたかにかかわらず、メソッドが順にすべてのキャプチャのリストを返す。 （オーダー以外に、ここに新情報がない；リストのすべての要素はそうだ非常に同じMatch ほかのどこかをバインドしたオブジェクト。） キー / 値がキーがそれの下でマッチオブジェクトがバインドされた名前あるいは数であるところをペアにする（とき・から・につれて・ように）、バインディングは実際に返送されている、そして値はそれ自身マッチオブジェクトだ。
捕えられた人たちを返すことに加えてMatch オブジェクト、.chunks メソッドがキャプチャの間に同じくすべての挟まれた「騒音」を返す。 と同じように.capsリスト要素がそれらが当初テキストにあったという命令でである. 挟まれたビットはキーが「~」であるペアとして同じく返される、そして値はシンプルだMatch ただ文字列、たとえ自由にされたサブルールであるとしてもそんなものだけを含んでいて反対しろ.ws 第一にテキストをくまなく渡り歩くために呼び出された。 呼び出している.ast そんなものの上にMatch オブジェクトが常に戻るStr.
もしいずれかであるなら、警告が表示されるだろう.caps あるいは.chunks それが重複バインディングを持っていることを見いだす。 このような重複がないときには、.chunks すべての部分をマップする保証がその合われた文字列の（中間で.from そして.to）正確にその戻って来たマッチのOR素子に、それで報道が完全である.
［推測：我々は同じくそうすることができたはずだ.deepcaps そして.deepchunks それは回帰的にサブマッチを含んでどんなキャプチャでも拡大する。 多分このような戻って来た厚切りのキーは解析樹でバインディングの「家柄」を示すだろう。］
すべては成功した試みとマッチする、あるいは何にでも対しての － ではなくが正規表現とマッチする、サブルール、あるいはサブパターン（下を見ろ）がクラスのオブジェクトを返すMatch. すなわち、：
$match_obj = $str ~~ /pattern/; say "Matched" if $match_obj;
この返送されたオブジェクトは語彙に同じく自動的にバインドされる$/ 成功にかかわらず現在の環境の変数。 すなわち、：
$str ~~ /pattern/; say "Matched" if $/;
正規表現、の中に$¢ 変数が現在の正規表現が不完全であると考えるMatch マッチステートとして知られたオブジェクト（型についてCursor）. 一般に、あなたがどのようにマッチステートを引き起こして、そして普及させるべきか知らないなら、これは修正されるべきじゃない。
あなたがそれらを考える実際はリターンマッチステートがイーブンにするすべての正規表現は他に何かを返している、なぜならマッチはあなたのために成功のキープトラックとパターンの失敗を述べるから。
幸いにあなたがただデフォルトコンクリートとともに異なった抽象的な結果を返すことを望むときMatch オブジェクト、あなたはあなたの復帰を関連づけるかもしれない、流れを持っている値が使ってステートとマッチするmake 何かを働かせる関数が好むreturnけれども、マッチステートを激しく打たない：
$str ~~ / foo # Match 'foo'
{ make 'bar' } # But pretend we matched 'bar'
/;
say $(); # says 'bar'
何もの抽象的なオブジェクトMatch オブジェクトが利用可能であるとして.ast メソッド。 従ってこれらのアブストラクトオブジェクトは返送されたカーソルオブジェクトとは無関係に管理されることができる。
オブジェクトが常に得られなくちゃならない最新のカーソルCursorあるいはマッチ働かないだろう. しかしながら、その制約の中で、最新のカーソルの実際の型はあなたが現在どの言語を解析しているか定義する。
あなたが文法の先頭を入力するとき、このカーソルは一般にその型があなたがいる文法の名前であるオブジェクトとして始まる、しかし現在の言語は、それらが、現在の文法から得られるかもしれない、あるいはそうしないかもしれない異なった型の中に神聖なカーソルオブジェクトを返すことによって、現在の言語を突然変異させる（とき・から・につれて・ように）、種々のメソッドによって修正されることができる。
括弧をとらえることにおいて、囲まれる正規表現の Any 部分がサブパターンと呼び出される。 例：
# subpattern
# _________________/\___________________
# | |
# | subpattern subpattern |
# | __/\__ __/\__ |
# | | | | | |
ms/ (I am the (walrus), ( khoo )**2 kachoo) /;
正規表現でのそれぞれのサブパターンが生産するMatch もしそれが成功裏に一致されるならオブジェクト。
いずれかが明示的に名指された目的地に割り当てるか、あるいは暗黙のうちにの配列に追加したサブパターンがそうであるそれぞれがマッチする。
それぞれのサブパターンのために明示的に名前を与えられたそのではない、サブパターンのMatch オブジェクトが外の（人たち・もの）の中に配列の上に押しやられるMatch 周囲の範囲に属しているオブジェクト（その親として知られているMatch オブジェクト）. 周囲のスコープはいずれか、一番奥の周囲のサブパターン、（もしサブパターンがネストされるなら）、あるいはほかにそれ自身正規表現全体であるかもしれない。
すべてのキャプチャのように、これらの割り当ては配列に仮説であって、そして未完成だ、サブパターンがそうであるかどうかがバックトラックした。
例えば、もし次のパターンが成功裏にマッチしたなら：
# subpat-A
# _________________/\__________________
# | |
# | subpat-B subpat-C |
# | __/\__ __/\__ |
# | | | | | |
ms/ (I am the (walrus), ( khoo )**2 kachoo) /;
それからMatch subpat - Bと subpat - Cによってされたマッチを表しているオブジェクトは subpat - エーズの中に続いて配列の上に押しやられるだろうMatch オブジェクト。 それから subpat - エーズMatch オブジェクトがそれ自身内部に配列の上に押しやられるだろうMatch 正規表現全体のためのオブジェクト（すなわちに$/「s配列）.
これらの結果として Perl 6 の意味規則、取り込んでいる括弧は、線ではなく、階層的だ（ネストされたサブパターンキャプチャ参照）。
配列要素のMatch オブジェクトが指名されて存在する、からいずれか、スタンダード配列、を使って、表記法にアクセスしろ（例えば。 $/[0]$/[1]$/[2]など）
対応するレキシカルスコープな数の別名としての排他的論理和（すなわち。
$0$1$2など） それで：
say "$/[1] was found between $/[0] and $/[2]";
同じであるけれども :
say "$1 was found between $0 and $2";
Perl 6 に、数のキャプチャ変数が、数が内部に要素のインデックスに対応するという状態で、 $1 ではなく、 $0 から始めることに注意を払え$/.
正規表現について配列要素Match オブジェクト（すなわち。 $/）民間企業を記憶するMatch 合われて、そして1番目、2番目、3番目などによって最も外側の（すなわち unnestedな） subpatterns をとらえたサブストリングを表しているオブジェクト。 それでこれらの要素は完全なマッチ結果のように扱われることができる。 例：
if m/ (\d\d\d\d)-(\d\d)-(\d\d) (BCE?|AD|CE)?/ {
($yr, $mon, $day) = $/[0..2];
$era = "$3" if $3; # stringify/boolify
@datepos = ( $0.from() .. $2.to() ); # Call Match methods
}
ネストされた subpatterns （すなわちネストされた取り込んでいる括弧）によってマッチされたサブストリングがネストされたサブパターンの親の中に配列に割り当てられるMatch
配列へじゃないオブジェクトの$/.
この振る舞いは Perl 5 意味規則と非常に異なっている：
# Perl 5... # # $1--------------------- $4--------- $5------------------ # | $2--------------- | | | | $6---- $7------ | # | | $3-- | | | | | | | | | | # | | | | | | | | | | | | | | m/ ( A (guy|gal|g(\S+) ) ) (sees|calls) ( (the|a) (gal|guy) ) /x;
Perl 6 に、ネストされた括弧が適切にネストされたキャプチャを生産する：
# Perl 6... # # $0--------------------- $1--------- $2------------------ # | $0[0]------------ | | | | $2[0]- $2[1]--- | # | | $0[0][0] | | | | | | | | | | # | | | | | | | | | | | | | | m/ ( A (guy|gal|g(\S+) ) ) (sees|calls) ( (the|a) (gal|guy) ) /;
もしサブパターンが直接数量化されるならで?同様それシングルを生産するMatch オブジェクト、あるいはNil. もしサブパターンが何でも使って直接数量化されるなら、他の修飾名、それは決してシングルを作り出さないMatch オブジェクト。 その代わりに、それはリストを作成するのMatch 民間企業の配列に対応することが繰り返されたサブパターンによって作られてマッチするオブジェクト。 もし我々が2つのカテゴリーを区別する必要があるなら、? 項目修飾名だ、他方*+そして** リスト限定記号と呼び出される。
もし0の値がマッチするなら、どの修飾名が使われるかについて、とらえられた値は依存する。 もし修飾名がそうであるなら?, a Nil もしそれが0回マッチしたなら、とらえられる。 もし修飾名がそうであるなら*空リスト、()その代わりにとらえられる. （何も通り過ぎて取り込まれて存在しない+ もし、それがバックトラックすることを引き起こすから、それが0回マッチする、しかしキャプチャ変数が戻ったなら修飾名Nil もし試みが不成功のマッチの後にそれを使わせられるなら。） A** 修飾名が () を返すけれども* もしにそれをするそのレンジの最小限は0であって、そしてさもなければバックトラックする.
それに注意しろ** 0..1 常にリスト修飾名だと見なされる、同じじゃない?.
おごることについての理論的根拠? どのようにかについて、項目修飾名がそれを一貫させるはずである（とき・から・につれて・ように）$object.?meth 定義される、そしていわれがない賛成の必要を減らすために.[0] 添え字、それはたいていの人々に驚くべきだ。 今それNil 賛成で同義語よりむしろ未定義であると見なされる()使うことが容易にである$0 // "default" あるいは安全にキャプチャをデリファレンスする何かそのようなもの。
なぜならサブパターンがリストを返す － が数量化したリストMatch オブジェクト、数量化されたキャプチャのための対応する配列要素はシングルよりむしろ（ネストされた）配列を記憶するだろうMatch オブジェクト。 例：
if m/ (\w+) \: (\w+ \s+)* / {
say "Key: $0"; # Unquantified --> single Match
say "Values: @($1)"; # Quantified --> array of Match
}
サブパターンが時々数量化された取り込まない構造体の中にネストされるかもしれない：
# non-capturing quantifier # __________/\____________ __/\__ # | || | # | $0 $1 || | # | _^_ ___^___ || | # | | | | | || | m/ [ (\w+) \: (\w+ \h*)* \n ] ** 2..* /
取り込まない括弧が別個のネストされたレキシカルスコープ、それらの中の2つの subpatterns が、従って、実際はまだ正規表現のトップレベルのスコープにあるように（彼・それ）らのトップレベルの肩書きを作成しない：$0 そして$1.
しかしながら、2つの subpatterns が数量化された構造物の中にあるから、$0 そして$1 それぞれ配列を含んでいるだろう。
その配列の要素は取り込まない括弧のそれぞれの繰り返しの上に対応する subpatterns によって返されたサブマッチだろう。 例：
my $text = "foo:food fool\nbar:bard barb";
# $0-- $1------
# | | | |
$text ~~ m/ [ (\w+) \: (\w+ \h*)* \n ] ** 2..* /;
# Because they're in a quantified non-capturing block...
# $0 contains the equivalent of:
#
# [ Match.new(str=>'foo'), Match.new(str=>'bar') ]
#
# and $1 contains the equivalent of:
#
# [ Match.new(str=>'food '),
# Match.new(str=>'fool' ),
# Match.new(str=>'bard '),
# Match.new(str=>'barb' ),
# ]
それと対照的に、もし外の数量化された構造が取り込んでいる構造体（すなわちサブパターン）であるなら、それはネストされたレキシカルスコープを開始するだろう。 その外の数量化された構造はそうするだろう、それから配列を返せMatch すべての繰り返しのために（上記のように）内部の括弧のキャプチャを表しているオブジェクト。 すなわち、：
my $text = "foo:food fool\nbar:bard barb";
# $0-----------------------
# | |
# | $0[0] $0[1]--- |
# | | | | | |
$text ~~ m/ ( (\w+) \: (\w+ \h*)* \n ) ** 2..* /;
# Because it's in a quantified capturing block,
# $0 contains the equivalent of:
#
# [ Match.new( str=>"foo:food fool\n",
# arr=>[ Match.new(str=>'foo'),
# [
# Match.new(str=>'food '),
# Match.new(str=>'fool'),
# ]
# ],
# ),
# Match.new( str=>'bar:bard barb',
# arr=>[ Match.new(str=>'bar'),
# [
# Match.new(str=>'bard '),
# Match.new(str=>'barb'),
# ]
# ],
# ),
# ]
#
# and there is no $1
言い換えれば、数量化された取り込まない括弧が有用な平らになったリストの中にそれらコンポーネントを集めるのに対して、数量化された取り込んでいる括弧が有用な階層構造でそれらコンポーネントを集める。
所定のサブパターンのインデックスは常に静的に決定され得る、しかし必ずしもユニークではなくそして常に単調だ。 subpatterns のナンバリングはそれぞれのレキシカルスコープ（正規表現、サブパターン、あるいは交代のブランチ）で再起動する。
特に、括弧をとらえることについてのインデックスはそれぞれの後に再起動する| あるいは|| （けれどもそれぞれの後にではなく& あるいは&&）. 従って：
# $0 $1 $2 $3 $4 $5
$tune_up = rx/ ("don't") (ray) (me) (for) (solar tea), ("d'oh!")
# $0 $1 $2 $3 $4
| (every) (green) (BEM) (devours) (faces)
/;
もし2番目の交代がマッチするなら、マッチのリスト値が含んでいるであろうこの手段('every', 'green', 'BEM', 'devours', 'faces') Perl 5 のよりむしろ(undef, undef, undef, undef, undef, undef, 'every', 'green', 'BEM',
'devours', 'faces').
それがまだ可能であるとは、注意しろ、から単調 Perl 5 キャプチャインデキシング意味規則をまねろ。 詳細については下のナンバーが付けられたスカラーエイリアシングを見ろ。
そうするための Any 呼び出し名指された<regex> パターンの中でサブルール、その正規表現が実際に定義されているかどうかとして知られている as a regex あるいはtoken あるいはrule あるいはさらに普通method あるいはmulti.
（下のエイリアシング参照）名指された変数に aliased される Any によってかっこでくくられた構造は同じくサブルールだ。
例えば、この正規表現は3つのサブルールを含んでいる：
# subrule subrule subrule # __^__ _______^_____ __^__ # | | | | | | m/ <ident> $<spaces>=(\s*) <digit>+ /
正規表現の中のサブルールが生産するそれぞれ成功裏に一致された subpatterns とまったく同じようにMatch オブジェクト。 けれども、 subpatterns 、それと異なり、Match
オブジェクトではないがその親の中に配列に割り当てられるMatch オブジェクト。
その代わりに、それはその親の中にハッシュの項目に割り当てられるMatch
オブジェクト。 例：
# .... $/ ..................................... # : : # : .... $/[0] .................. : # : : : : # : $/<ident> : $/[0]<ident> : : # : __^__ : __^__ : : # : | | : | | : : ms/ <ident> \: ( known as <ident> previously ) /
ハッシュ項目のMatch オブジェクトが標準的なハッシュアクセス表記法の何でも使って言及されることができる（$/{'foo'}$/<bar>$/«baz»など）、対応するレキシカルにスコープ宣言された別名としての排他的論理和（$<foo>$«bar»$<baz>など） それで前の例が同じく暗示する：
# $<ident> $0<ident> # __^__ __^__ # | | | | ms/ <ident> \: ( known as <ident> previously ) /
サブルールが角度によってかっこでくくられたかどうかは何の相違も生じないことを注意する（<ident>）あるいは内部的に aliased した（<ident=.name>）あるいは外部から aliased した（$<ident>=(<.alpha>\w*)）. 名前はそのことだ。
もしサブルールがレキシカルスコープについて何かで時が分岐させる2（あるいはさらに多く）のように見えるなら（すなわち2度同じサブパターンと交代の中で）、あるいはもしサブルールがリストであるなら － がどこでも所定のスコープの中で数量化される（すなわち、どんな修飾名他によってでもより?）、それから、エントリーが常に配列に割り当てられるその対応するハッシュMatch シングルよりむしろオブジェクトMatch オブジェクト。
同じサブルールの連続したマッチ（別個の呼び出しから、あるいは一つの数量化された繰り返しからかにかかわらず）が（彼・それ）らの個人を付加するMatch
この配列へのオブジェクト。 例：
if ms/ mv <file> <file> / {
$from = $<file>[0];
$to = $<file>[1];
}
（注意しろ、ここの空白文字繊細さ － ルールが必要とするであろう標準の sigspace がただ英数字の間に間隔を置く我々が無視している明快さのために文字、どちらかは間違っている。 我々のファイルサブルールがそれ自身のものの上に空白文字を取り扱うと想定しろ。）
同じく、数量化されたサブルールで：
if ms/ mv <file> ** 2 / {
$from = $<file>[0];
$to = $<file>[1];
}
そして両方ともの混合で：
if ms/ mv <file>+ <file> / {
$to = pop @($<file>);
@from = @($<file>);
}
名前衝突を避けるために、あなたは先行するドットの使用によってオリジナルの名前を隠して、そして次に別名をキャプチャに異なった名前：を与えるために使うかもしれない
if ms/ mv <file> <dir=.file> / {
$from = $<file>; # Only one subrule named <file>, so scalar
$to = $<dir>; # The Capture Formerly Known As <file>
}
同じく、次の構築原因のいずれも<file> から配列を生産しろMatch それらの少しも2かそれ以上を持っていないときからのオブジェクト<file> 同じレキシカルスコープのサブルール：
if ms/ (keep) <file> | (toss) <file> / {
# Each <file> is in a separate alternation, therefore <file>
# is not repeated in any one scope, hence $<file> is
# not an Array object...
$action = $0;
$target = $<file>;
}
if ms/ <file> \: (<file>|none) / {
# Second <file> nested in subpattern which confers a
# different scope...
$actual = $/<file>;
$virtual = $/[0]<file> if $/[0]<file>;
}
他方、 unaliasedな正方形の括弧が別個のスコープを授けない（なぜならそれら持っている関連づけるMatch オブジェクト）. それで：
if ms/ <file> \: [<file>|none] / { # Two <file>s in same scope
$actual = $/<file>[0];
$virtual = $/<file>[1] if $/<file>[1];
}
別名が名前をつけられるか、あるいは番号を付けられることができる。 それらはスカラー、配列かハッシュのようであり得る。 そしてそれらが取り込んでいるか、あるいは取り込まない構造に適用されることができる。 それらの組み合わせの若干の意味規則の次節ハイライト特色。
もし名指されたスカラーエイリアスが括弧をとらえることについてのセットに適用されるなら：
# _____/capturing parens\_____
# | |
# | |
ms/ $<key>=( (<[A..E]>) (\d**3..6) (X?) ) /;
それから括弧がもう配列の中に取り込まない外の取り込むこと$/ unaliased されるように、括弧がそうするだろう。 その代わりに括弧がハッシュの中に取り込む aliased $/特に、そのキーが別名であるハッシュ要素の中に。
それで、上記の例、成功したマッチセットで$<key> （すなわち。 $/<key>）、しかしそうじゃない$0 （すなわちそうじゃない$/[0]）.
もっと特定すると：
$/<key> を含む段落がそうするだろうMatch それが前に置かれたであろうオブジェクト$/[0].
$/<key>[0] A - E 英字を含んでいるだろう、
$/<key>[1] 数値を含んでいるだろう、
$/<key>[2] 任意のXを含んでいるだろう。
この振る舞いについて考えるもう1方法は aliasedな括弧が一種のレキシカルスコープな名指されたサブルールを作るということだ；それらがその名前が別名である別個のサブルールの一部であるかのように、括弧の内容物が処理されること。
もし名指されたスカラーエイリアスが取り込まない括弧のセットに適用されるなら：
# __/non-capturing brackets\__
# | |
# | |
ms/ $<key>=[ (<[A..E]>) (\d**3..6) (X?) ] /;
それから文通すること$/<key> Match オブジェクトがただ取り込まない括弧によって合われた文字列だけを含んでいる。
特に、配列の$/<key> エントリーは空しい。 それは正方形の括弧がネストされたレキシカルスコープを作らないからだ、それで subpatterns は unnested されて、そして従って $0 に対応する、 $1 と2ドル、そしてそうしないために$/<key>[0]$/<key>[1]そして$/<key>[2].
言い換えれば：
$/<key> 正方形の括弧によってマッチされた完全なサブストリングを含んでいるだろう（中にMatch 同じぐらい上記のオブジェクト）、
$0 A - E 英字を含んでいるだろう、
$1 数値を含んでいるだろう、
$2 任意のXを含んでいるだろう。
もしサブルールが aliased されるなら、それは割り当てるそMatch オリジナルの名前にと同様、そのキーが別名の名前であるハッシュ項目にオブジェクト。
if m/ ID\: <id=ident> / {
say "Identified as $/<id> and $/<ident>"; # both names defined
}
オリジナルの名前を隠すために、ドット形式を使え：
if m/ ID\: <id=.ident> / {
say "Identified as $/<id>"; # $/<ident> is undefined
}
従ってドットを打たれたサブルールが変える別名化、サブルールの目的地Match
オブジェクト。 同じ範囲で同じサブルールに2かそれ以上の呼び出しを区別することに対して、これは特に有用だ。 例：
if ms/ mv <file>+ <dir=.file> / {
@from = @($<file>);
$to = $<dir>;
}
もしナンバーが付けられた別名が名指された別名の代わりに使われるなら：
m/ $1=(<-[:]>*) \: $0=<ident> / # captures $<ident> too m/ $1=(<-[:]>*) \: $0=<.ident> / # doesn't capture $<ident>
振る舞いは名指された別名（すなわち上記の種々のケース）のためにとまったく同じもの、それ以外結果として生じることだMatch オブジェクトはハッシュの要素によりむしろ適切な配列の対応する要素に指名されている。
もし達せられた何でもなら、エリアスが使われる、次の unaliasedな subpatterns のナンバリングは同じ範囲で自動的にその別名番号から（列挙型値とほとんど同じように最後の明示的な値からのインクリメント）を増加させる。 すなわち、：
# --$1--- -$2- --$6--- -$7- # | | | | | | | | m/ $1=(food) (bard) $6=(bazd) (quxd) /;
この後続の振る舞いは特に交代で連続したサブパターンナンバリングのために Perl5 意味規則を再建することに役立つ：
$tune_up = rx/ ("don't") (ray) (me) (for) (solar tea), ("d'oh!")
| $6 = (every) (green) (BEM) (devours) (faces)
# $7 $8 $9 $10
/;
それは同じくネストされた Perl 5 subpatterns の unnestedなナンバリング意味規則を再建する Perl 6 での容易な方法を提供する：
# Perl 5...
# $1
# _____________/\___________
# | $2 $3 $4 |
# | __/\___ __/\___ /\ |
# | | | | | | | |
m/ ( ( [A-E] ) (\d{3,6}) (X?) ) /x;
# Perl 6...
# $0
# ______________/\______________
# | $0[0] $0[1] $0[2] |
# | ___/\___ ____/\____ /\ |
# | | | | | | | |
m/ ( (<[A..E]>) (\d ** 3..6) (X?) ) /;
# Perl 6 simulating Perl 5...
# $1
# _______________/\________________
# | $2 $3 $4 |
# | ___/\___ ____/\____ /\ |
# | | | | | | | |
m/ $1=[ (<[A..E]>) (\d ** 3..6) (X?) ] /;
取り込まない括弧はスコープを開始しない、それでそれらの中の subpatterns は正規表現範囲において、そして従ってトップのレベルと数値化される。 そうするための別名化、正方形の括弧$1 手段が同水準でそれほど次のサブパターン的だ（すなわち(<[A..E]>)）連続的にナンバーが付けられた（すなわち. $2）など.
上の意味規則のすべては数量化された構造に等しくバインドされるエイリアスに当てはまる。
数量化されたサブルールあるいはサブパターンがリストを返してしまっているであろう唯一の相違が、もし aliasedな構造がサブルールあるいはサブパターンであるなら、それだMatch オブジェクト（同じサブルールの数量化されたサブパターンキャプチャと繰り返されたキャプチャで記述されるように）。
それで対応する配列要素あるいは別名のハッシュ項目が、シングルの代わりに、配列を含んでいるだろうMatch オブジェクト。
言い換えれば、エイリアシングと限定は完全に直角だ。 例：
if ms/ mv $0=<.file>+ / {
# <file>+ returns a list of Match objects,
# so $0 contains an array of Match objects,
# one for each successful call to <file>
# $/<file> does not exist (it's suppressed by the dot)
}
if m/ mv \s+ $<from>=(\S+ \s+)* / {
# Quantified subpattern returns a list of Match objects,
# so $/<from> contains an array of Match
# objects, one for each successful match of the subpattern
# $0 does not exist (it's pre-empted by the alias)
}
注意しろ、しかしながら、その1セットの数量化された取り込まない括弧は常にシングルを返すMatch （取り込まない括弧に適用された名指されたスカラーエイリアスで記述されるように）、ただ括弧の反復のフルセットによって一致された完全なサブストリングだけを含んでいるオブジェクト。 例：
"coffee fifo fumble" ~~ m/ $<effs>=[f <-[f]> ** 1..2 \s*]+ /; say $<effs>; # prints "fee fifo fum"
別名が同じくスカラーの代わりに配列を使って別名として明示されることができる。 例：
m/ mv \s+ @<from>=[(\S+) \s+]* <dir> /;
使う@alias= その代わりに表記法の$alias=
対応するハッシュエントリーあるいは配列要素が常に配列を受け取る命令Match オブジェクト、たとえ aliased されている構造が通常シングルを返すであろうとしてもMatch オブジェクト。
これは構造上異なった交代を越えて（すべてのブランチで配列キャプチャを実施することによって）、一貫したキャプチャ意味規則を作ることに役立つ：
ms/ Mr?s? @<names>=<ident> W\. @<names>=<ident>
| Mr?s? @<names>=<ident>
/;
# Aliasing to @names means $/<names> is always
# an Array object, so...
say @($/<names>);
便利さのために、そして一貫性、@<key> 同じく正規表現の外（に・で）、賛成の速記として使用されることができる@( $/<key> ). すなわち、：
ms/ Mr?s? @<names>=<ident> W\. @<names>=<ident>
| Mr?s? @<names>=<ident>
/;
say @<names>;
配列エイリアスがそうであるかどうかが対応する配列の要素をサブストリングが中へ括弧のそれぞれの反復によってマッチしたキャプチャが分離する数量化された1対の取り込まない括弧、それに適用した。 すなわち、：
ms/ mv $<files>=[ f.. \s* ]* /; # $/<files> assigned a single
# Match object containing the
# complete substring matched by
# the full set of repetitions
# of the non-capturing brackets
ms/ mv @<files>=[ f.. \s* ]* /; # $/<files> assigned an array,
# each element of which is a
# Match object containing
# the substring matched by Nth
# repetition of the non-
# capturing bracket match
もし配列エイリアスがそうであるならそれぞれについて配列値を連結してそれから対応するハッシュあるいは配列要素が作成されたリストを割り当てられる、（すなわちサブパターンに）、括弧を取り込むことについての数量化されたペアに申し込んだMatch オブジェクトが1時までにサブパターンの反復を返した。 すなわち、サブパターンの上の配列エイリアスが平らになって、そして aliasedなサブパターンの中ですべてのネストされたサブパターンキャプチャを集める。 例：
if ms/ $<pairs>=( (\w+) \: (\N+) )+ / {
# Scalar alias, so $/<pairs> is assigned an array
# of Match objects, each of which has its own array
# of two subcaptures...
for @($<pairs>) -> $pair {
say "Key: $pair[0]";
say "Val: $pair[1]";
}
}
if ms/ @<pairs>=( (\w+) \: (\N+) )+ / {
# Array alias, so $/<pairs> is assigned an array
# of Match objects, each of which is flattened out of
# the two subcaptures within the subpattern
for @($<pairs>) -> $key, $val {
say "Key: $key";
say "Val: $val";
}
}
同じく、もし配列別名がそうであるならそれぞれ数量化されたサブルール、それから別名に対応している要素が配列値を含んでいてリストを割り当てられるハッシュあるいは配列に申し込んだMatch 一つの配列の中に、すべて平らになったサブルールのそれぞれの反復によって返されたオブジェクト：
rule pair { (\w+) \: (\N+) \n }
if ms/ $<pairs>=<pair>+ / {
# Scalar alias, so $/<pairs> contains an array of
# Match objects, each of which is the result of the
# <pair> subrule call...
for @($<pairs>) -> $pair {
say "Key: $pair[0]";
say "Val: $pair[1]";
}
}
if ms/ mv @<pairs>=<pair>+ / {
# Array alias, so $/<pairs> contains an array of
# Match objects, all flattened down from the
# nested arrays inside the Match objects returned
# by each match of the <pair> subrule...
for @($<pairs>) -> $key, $val {
say "Key: $key";
say "Val: $val";
}
}
言い換えれば、配列別名が何でもネストした一つの配列の中に数量化されたサブパターンあるいはサブルールの中で起こるかもしれないキャプチャを平らにするために有用だ。 スカラー別名が有用であるのに対してトップレベルの配列の中でそれぞれの繰り返しの内部構造を保存するために。
ナンバーが付けられた変数を配列別名として使用することは同じく可能だ。
意味規則は正確に上記のように、唯一の相違がそれであることで、結果として生じている配列であるのMatch オブジェクトそのマッチハッシュのキーによりむしろ正規表現のマッチ配列の適切な要素の中に割り当てられる. 例：
if m/ mv \s+ @0=((\w+) \s+)+ $1=((\W+) (\s*))* / {
# | |
# | |
# | \_ Scalar alias, so $1 gets an
# | array, with each element
# | a Match object containing
# | the two nested captures
# |
# \___ Array alias, so $0 gets a flattened array of
# just the (\w+) captures from each repetition
@from = @($0); # Flattened list
$to_str = $1[0][0]; # Nested elems of
$to_gap = $1[0][1]; # unflattened list
}
正規表現の外（に・で）、再びそれに注意しろ@0 ただ速記が賛成だ@($0)それで1日上の割り当てが同じく書かれることができたはずだ：
@from = @0;
エイリアスが同じく、スカラーあるいは配列の代わりに、ハッシュを使ってエイリアス変数として明示されることができる。 例：
m/ mv %<location>=( (<ident>) \: (\N+) )+ /;
ハッシュ別名が現在のスコープのに対応するハッシュあるいは配列要素を引き起こすMatch （ネストされた）ハッシュオブジェクトを割り当てられるオブジェクト（よりむしろArray オブジェクトあるいはシングルMatch オブジェクト）.
もしハッシュエイリアスがサブルールあるいはサブパターンに適用されるなら、それから最初のネストされた数のキャプチャは残っている数のキャプチャが（配列でもし1以上があるなら）値になるというそれぞれのハッシュ項目と何のキーにでもなる。
配列エイリアスと同じようにナンバーが付けられた変数をハッシュエイリアスとして使用することは同じく可能だ。 もう一度、唯一の相違は結果として生じることである場合はだMatch オブジェクトが記憶される：
rule one_to_many { (\w+) \: (\S+) (\S+) (\S+) }
if ms/ %0=<one_to_many>+ / {
# $/[0] contains a hash, in which each key is provided by
# the first subcapture within C<one_to_many>, and each
# value is an array containing the
# subrule's second, third, fourth, etc. subcaptures...
for %($/[0]) -> $pair {
say "One: $pair.key()";
say "Many: { @($pair.value) }";
}
}
正規表現の外（に・で）、%0 賛成で近道だ%($0)：
for %0 -> $pair {
say "One: $pair.key()";
say "Many: @($pair.value)";
}
内部の別名を使う代わりに、好む：
m/ mv @<files>=<ident>+ $<dir>=<ident> /
普通の変数の名前は、そうであると同じように、外部の別名として使われることができる：
m/ mv @OUTER::files=<ident>+ $OUTER::dir=<ident> /
このケース、それぞれのエイリアスであるの振る舞いで、それ以外何でも結果として生じるという状態で、前のセクションで記述されるように、キャプチャがすでに正規表現が宣言されるスコープに存在しなくちゃならない指定名の変数に直接（しかしそれでもそして仮説的に）バインドされる。
正規表現全体が成功裏にである時が繰り返しと合わせられる（指定されたとして:x あるいは:g フラグ）あるいはオーバラップ（指定されたとして:ov あるいは:ex フラグ）、それ通常別のマッチの連続を作り出すだろう.
これらの旗の何の下の成功したマッチもまだシングルを返すMatch オブジェクトが中にある$/. しかしながら、このオブジェクトは正規表現の部分評価を表すかもしれない。 さらに、このマッチオブジェクトの値は少し繰り返されていないマッチによって提供されたそれらと異なっている：
ブールの値の$/ そんなものがマッチした後、パターンがマッチしたかどうかについて、依存して、真か、あるいは偽だ。
文字列値は最後のマッチの終わりに（後に見い出すために飛ばされた正規表現がマッチする文字列のどんな介入している地域でも含めて）最初のマッチのスタートからのサブストリングだ。
Subcaptures は多次元のリストとして返される、そしてそれをユーザーが2つの方法のいずれかでプロセスに選択することができる。 あなたが言及するもし@().flat （あるいはただ使用@() 平らなリストコンテキストで）、多次元無視されるそしてすべてのマッチは平らにされて返される（しかしいい加減に静かにする）. あなたが言及するもし@().sliceあなた容器それぞれの個別の部分リストを受けとる as a Parcel オブジェクト。
何でも多次元であるという状態で、傾くように、それぞれの部分リストが別にいい加減であり得る。
例：
if $text ~~ ms:g/ (\S+:) <rocks> / {
say "Full match context is: [$/]";
}
けれどもそれぞれに対応しているマッチオブジェクトが分離する民間企業のリストはマッチ同じく利用可能だ：
if $text ~~ ms:g/ (\S+:) <rocks> / {
say "Matched { +@().slice } times"; # Note: forced eager here by +
for @().slice -> $m {
say "Match between $m.from() and $m.to()";
say 'Right on, dude!' if $m[0] eq 'Perl';
say "Rocks like $m<rocks>";
}
}
あなたのプライベートident 統治がほかの誰かのを激しく打つべきじゃないident 規則。 それでいずれかのメカニズムがルールをネームスペースに限定するために必要とされる。
もし sub がルールのためのモデルであるなら、モジュール / クラスがそれらを集めるための明白なモデルだ。 このようなルールのコレクションは一般に文法として知られている。
クラスが一緒に名指された行動を集めることができるのとちょうど同じ（ように・時に）：
class Identity {
method name { "Name = $.name" }
method age { "Age = $.age" }
method addr { "Addr = $.addr" }
method desc {
print &.name(), "\n",
&.age(), "\n",
&.addr(), "\n";
}
# etc.
}
同じく文法が一緒に名指されたルールのセットを集めることができる：
grammar Identity {
rule name { Name '=' (\N+) }
rule age { Age '=' (\d+) }
rule addr { Addr '=' (\N+) }
rule desc {
<name> \n
<age> \n
<addr> \n
}
# etc.
}
クラスのように、文法が財産を相続することができる：
grammar Letter {
rule text { <greet> <body> <close> }
rule greet { [Hi|Hey|Yo] $<to>=(\S+?) , $$}
rule body { <line>+? } # note: backtracks forwards via +?
rule close { Later dude, $<from>=(.+) }
# etc.
}
grammar FormalLetter is Letter {
rule greet { Dear $<to>=(\S+?) , $$}
rule close { Yours sincerely, $<from>=(.+) }
}
クラスのメソッドとまったく同じように、文法の規則定義は相続される（そして polymorphic する！）。 それで再び指定する必要がないbodylineなど.
Perl 6 は少なくとも1人の文法既定義と一緒に来るだろう：
grammar STD { # Perl's own standard grammar
rule prog { <statement>* }
rule statement {
| <decl>
| <loop>
| <label> [<cond>|<sideff>|';']
}
rule decl { <sub> | <class> | <use> }
# etc. etc. etc.
}
従って：
$parsetree = STD.parse($source_code)
正規表現の真ん中（に・で）異なった文法に切り替えるために、あなたは使うかもしれない:lang 副詞。
例えば、展開式とマッチするために、 <expr> $funnylang からそれは、例えばカーリーで埋め込みだ：
token funnylang { '{' [ :lang($funnylang.unbalanced('}')) <expr> ] '}' }
文字列が、呼び出すことによって、文法に対して対抗させられることができる.parse
あるいは.parsefile 文法に関して、そしてオプションとして、その文法に動作オブジェクトをパスしろ：
MyGrammar.parse($string, :actions($action-object)) MyGrammar.parsefile($filename, :actions($action-object))
これが引き起こすGrammar その型が解析されている現在の言語を意味する、そしてそ（れ・こ）から他の文法が拡張言語として得られるかもしれないオブジェクト。
文法オブジェクトが得られるすべてCursorすべての文法オブジェクトの値が現在のマッチの現在の状態を具体化するように。 オブジェクトがへインボカントとして存在する、それからパスしたこの新しい文法TOP メソッド（正規表現、トークン、あるいは規則）のMyGrammar. 呼び出すべき規則名が一緒にオーバーライドされることができるデフォルト:rule 引数という名前のparse メソッド。
文法オブジェクトが不変であると見なされる、それですべてのマッチが異なったマッチステートを返す、そして多数のマッチステートが同時に存在するかもしれない。 パターンがどのように最終的にマッチするであろうかについて、おのおののそのようなマッチステートが仮説だと見なされる。 パターン・マッチングでの backtrackable 選択が Perl 6 にマッチの公式のカーソルのいい加減なリストとして容易に表されるかもしれない；バックトラックすることはただリストの前の値をスローして、そして次の値でマッチし続けることから成る。 従って、これらのマッチカーソルのマネージメントはいい加減なリストパラダイムからバックトラックすることがどのように当然機能して、そして落ちるかをコントロールする。
サブルール、あなたが増大させるかもしれないあなた自身のバックスラッシュとアサーションを書くことに対して、（あなたのコピーの）次の構文カテゴリを使っている正規表現部分言語：
augment slang Regex {
token backslash:sym<y> { ... } # define your own \y and \Y
token assertion:sym<*> { ... } # define your own <*stuff>
token metachar:sym<,> { ... } # define a new metacharacter
multi method tweak (:$x) {...} # define your own :x modifier
}
種々のプラグマが正規表現コンパイルの諸相とさもなければ提供されない使用をコントロールするために使われるかもしれない。 これらは問題の特定の宣言詞にタイされる：
use s :foo; # control s defaults use m :foo; # control m defaults use rx :foo; # control rx defaults use regex :foo; # control regex defaults use token :foo; # control token defaults use rule :foo; # control rule defaults
（さもなければするべき良い理由がないなら、キーワードの表面振る舞いがキーワード自身とまったく同じであることはプラグマが設計した何でも影響を与える Perl 6 の一般的なポリシーだ。 他方、もちろんいずれかの類似性が良いけれども、深い意味規則に影響を与えるよう意図されたプラグマが同じく名前をつけられるべきじゃない。）
tr/// クォートのような演算子が今同じくメソッド書式が呼び出されるようにするtrans(). その引数はペアのリストだ。 権限：がペアリストを作り出す何でも使う：
$str.trans( %mapping.pairs );
使用.= 決まった場所で翻訳をするためにできろ：
$str.=trans( %mapping.pairs );
（6がサポートしない Perl y/// ただ入っただけであった形式sed なぜならそれらが一つの英字を使い果たしていたから。）
2（人・つ）ペアが解釈された文字列であり得る何ものサイドtr/// そうするだろう：
$str.=trans( 'A..C' => 'a..c', 'XYZ' => 'xyz' );
変化した訴訟として、両側は個別の文字であり得る：
$str.=trans( 'A'=>'a', 'B'=>'b', 'C'=>'c' );
空白文字文字が翻訳されることか、あるいはそうするために文字として文字通りに受けとめられる。 .. あなたがもちろん二重のクォートでバックスラッシュ書き入れを使うかもしれないけれども、レンジのシーケンスは文字列の中で認識された唯一のメタ構文だ。 もし右側があまりにも短いなら、最終の文字は左の文字列の長さに向かって複製される。
もし最終の文字がないなら、右側が空白文字列であるから、結果はその代わりに削除だ。
いずれかあるいは二人の両側が同じく配列オブジェクトであるかもしれない：
$str.=trans( ['A'..'C'] => ['a'..'c'], <X Y Z> => <x y z> );
配列機種が基礎をなしている基本形である：最初の行為と等しい文字列書式であるの意味規則.. 拡大そして次に文字列を個別の文字に分けることと、それを配列として使うこと。
配列バージョンは1つ以上の文字に1つ以上の文字をマップすることができる：
$str.=trans( [' ', '<', '>', '&' ] =>
[' ', '<', '>', '&' ]);
インプット文字の1以上の連続がマッチするケースで、最も長い（の・もの・人）は勝つ。 2つの同一の連続に関しては順調な最初が勝つ。
文字列フォームで、欠けている righthand 要素が決勝戦を繰り返す（とき・から・につれて・ように）、要素と空の配列がその代わりに削除をもたらす。
文字列によってされた認識と配列フォームは非常に基本的だ。 より大きい力、何でも達成するために、左側の認識要素がやればできると考える積極思考型の文字が分類する正規表現、先読みなどによって指定されるかもしれない。
$str.=trans( [/ \h /, '<', '>', '&' ] =>
[' ', '<', '>', '&' ]);
$str.=trans( / \s+ / => ' ' ); # squash all whitespace to one space
$str.=trans( / <-alpha> / => '' ); # delete all non-alpha
サブマッチが中に混ぜられるこれらは全体的なマッチまったく同じ方法でそのそれらで普通の正規表現処理で平行した交代の中に混ぜられる、それで最も長くトークンルールがすべての指定された可能なマッチの向こう側に文字変換演算子に適用される。 マッチがされて、そして transliterated される途端に、たとえそれが多数の文字と一致したとしても、平行したマッチしている（人たち・もの）は転職先で前のマッチの終わりの後に続くことを再び始める。
もし矢の右側がクロージャであるなら、それは取り換え値を決定するために評価される。 もし左側が正規表現によって匹敵されたなら、結果として生じているマッチオブジェクトはクロージャの中で利用可能だ。
同じくメソッドフォームがあるのm// そしてs///：
$str.match(/pat/);
$str.subst(/pat/, "replacement");
$str.subst(/pat/, {"replacement"});
$str.=subst(/pat/, "replacement");
$str.=subst(/pat/, {"replacement"});
.match そして.subst メソッドが副詞をサポートするのm// そしてs/// あなたが書くことができるように、引数と命名されるように
$str.match(/pat/, :g)
等価物としてそうするために
$str.comb(/pat/, :match)
ここに構文的な構文糖がない、それで代替物の延期された評価を得るために、あなたはそれをクロージャに入れなくちゃならない。 構文的な構文糖は quotelike フォームによってだけ供給される。 最初に標準的な「3つの要素から成るクォート」形状がある：
s/pattern/replacement/
ただ非括弧の文字だけが「3つの要素から成るクォート」のために使われるかもしれない。 それがクォートにかかわらず選択された二重に引用された文字列であるかのように、右側は常に評価される。
Perl 5 と同じように、フォームをかっこでくくることが同じくサポートされる、しかし Perl 5 と異なり、 Perl 6 はただパターンの周りに括弧を使う。 それが、普通の引用ルールで、普通の項目割り当てであるかのように、取り換えはそれから指定される。 あなた自身のクォートが右手にただ1（人・つ）を使う指名にq
フォーム。 上の置換は同等の値：だ
s[pattern] = "replacement"
あるいは
s[pattern] = qq[replacement]
置換がマッチする（擬似割り当てとほとんど同じように宣言子に奇妙な時に起きることができる）たびに、これは右側が評価されるから、標準の assigment じゃない。 従ってそれは「thunk」として取り扱われる、すなわち、それはかなりのレキシカルスコープではなく、ダイナミックスコープを作成するコードと呼び出されるだろう。 （あなたは同じく thunk を寄生するように現在のレキシカルスコープを使うクロージャであると考えることができる。） 実際、言うことはまったく意味をなさない
s[pattern] = { doit }
なぜならそれは文字列の中にクロージャを代用しようとするだろうから。
Any スカラー割り当て演算子が使われるかもしれない；置換マクロはどのように向きを変えるべきか知っている
$target ~~ s:g[pattern] op= expr
何かにあたかも：
$target.subst(rx[pattern], { $() op expr }, :g)
例えば、あなたが缶詰めにするように、すべてのドルの量に2を掛けろ：
s:g[\$ <( \d+ )>] *= 2
（もちろん、オプティマイザは実際のメソッドより速い何かを呼び出しですることが自由だ。）
あなたは最後の例から置換がただマッチの「公式の」文字列結果、すなわち、中間の文字列の部分を偶然発見するだけであることを指摘するだろう$/.from そして$/.to ポジション。
（ここで我々は人たちに明示的に使わせた<(...)> 対になれ；さもなければ我々は後読みをマッチするために使わなければならなかっただろう$.）
どうかそれに注意する:ii/ :samecase そして:mm/ :samemark
スイッチは1つで本当に2つの異なった修飾子だ、そしてコンパイラがクォートのようなフォームを desugars するとき、それはパターンと代替物両方に意味規則を配る。 すなわち、:ii 取り換えの上に暗示する:i パターン、に関してそして:mm 暗示する:m. 適切なメソッド匹敵するもの値：
s:ii/foo/bar/ s:mm/boo/far/
存在する：
.subst(/foo/, 'bar', :ii) # WRONG .subst(/boo/, 'far', :mm) # WRONG
けれどもどちらかと言えば：
.subst(rx:i/foo/, 'bar', :ii) # okay .subst(rx:m/boo/, 'far', :mm) # okay
それがケースとマークに関して正規表現を一般的であるとして扱うことは特に実装に要求されない。 さかのぼって有効なリコンピレーションが有害であると見なされる。 もし実装がいい加減な一般的なケースとマーク意味規則をするなら、それの上に依存することはプログラムにとって誤っているそして据え置き型だ。
あなたが使うことができる一般的なケースにおける特別のポジションに固定すること<at($pos)> アサーションが現在の位置があなたが供給するポジションオブジェクトと同じだと言う。 あなたは現在のマッチ立場を設定するかもしれないとして:c そして:p 修飾子。
しかしながら、どうかバイトあるいは符号位置あるいは書記素までにあなたが数えるかどうかにかかわらず Perl 6 文字列ポジションの中に一般に整数ではなく、文字列の特定の場所を指し示すオブジェクトがあることを覚えていてくれ。 もし、整数で、使われるならat アサーションがあなたが、この整数がどうにかしてこの同じレキシカルスコープで生成されたという仮定に関して、現在のレキシカルにスコープ宣言された Unicode レベルを意味すると想定するだろう。
もしこれが現在の文字列の許可 Unicode 抽出レベルの外（に・で）あるなら、例外がスローされる。 もっと多くの弦つきのポジションのディスカッションのために S02 を見ろ。
Buf 型は固定幅細胞に基づいていて、そして従ってただ素晴らしい整数ポジションを扱って、そしてそれらを配列インデックスとして扱うことができる。
特に、buf8 （同じく知られているけれどもbuf）ただ旧式のバイト文字列である.
反対にマッチするBuf 型が配列の値が UTF - 32のようないずれかの特定のエンコーディングとして取り扱われることを求めて明白な修飾子がないときには ASCIIの意味規則に制限される。 （これは同形だと見なされるそれらのぎっしり詰まった配列がそうするように同じく真だBuf 型。） 中のポジションBuf 型は原因となっている配列の1つの1式当たりのセルを計算に入れて、常に整数だ。 それほど "from" 的に気付いていて、そして、要素の間にあるとして、ポジション「に」報告された.
もしぎっしり詰まった配列に対してマッチしているなら@foo42のポジションが示す決勝戦それ@foo[42] 含まれない最初の要素だった。
文字列にタイされることができる何でも正規表現に対して対抗させられることができる。 この特徴は入力の流れで特に有用だ：
my $stream := cat $fh.lines; # tie scalar to filehandle # and later... $stream ~~ m/pattern/; # match from stream
入り混ざった文字列あるいはオブジェクトの非コンパクトの配列がそれと共にあなたがそれらをオブジェクトとして提示するのと同じぐらい長い正規表現に対して対抗させられることができる Any Str
他がそんなものをインタフェースするオブジェクトを持つことを妨げない接合点Array. 通常あなたは使うだろうcat このようなオブジェクトを生み出すために：
@array.cat ~~ / foo <,> bar <elem>* /;
スペシャル<,> サブルールが要素の間に境界とマッチする。
<elem> アサーションがどんな個別の配列要素とでもマッチする。
それは要素全体のために「ドット」メタキャラクタの同等物だ。
配列要素が文字列であるかどうか、それらが事実上一つの論理的な文字列の中に連結される。 もし配列要素がトークンあるいは他のそのようなオブジェクトであるなら、オブジェクトは種類のサブルールがマッチするべき適切なメソッドを供給しなくちゃならない。 それは文字列化された光景を供給しないオブジェクトに対して文字列 - マッチしているアサーションとマッチするアサーション失敗だ。 しかしながら、純粋なオブジェクトリストが（何でも含めてサブルール）がそれ自身のようアサーションに制限するマッチと同じぐらい長く解析されることができる：
<.isa(Dog)>
<.does(Bark)>
<.can('scratch')>
オブジェクトを混ぜることは許される、そしてそれらの長さの配列での文字列が異なった要素にいる。 しかしながら、あなたはオブジェクトを文字列に埋めてはならない。
要素もしそれが好きであるオブジェクトが文字列であるために、もちろん、詐称するかもしれない Any 、そしてそれでCat オブジェクトが主として文字列と同じ制約でサブストリングとして使用されるかもしれない。
どうか上にそれほど警告的に気付いてくれ.from そして.to 不透明オブジェクトを返すことは配列に対してマッチして賛成で二重になる、そしてそこで特別のポジションが配列の中のポジションと（潜在的に）その配列の文字列の中のポジションの両方を反映する。 このような値で数学を期待して、からするな。 同様にあなたは要素の境界を越える substr を引き出すことが可能であることを期待するべきじゃない。
［推測：あるいはあなたはそうするべきか？］
マッチするために、配列のすべての要素に対して、超演算子を使え：
@array».match($regex);
何にでも対してそれが普通のスマートマッチを使うために十分である配列の、要素とマッチするために：
@array ~~ $regex;
$/ 正当だimplementational 自由を提供するために、$/ パターンがそれを必要とするシーケンスポイントに達するまで（マッチ、あるいは埋め込みのクロージャを呼び出すこと、あるいは Perl 展開式を必要とするサブマッチをその引数について診断することさえ完了するような）、変数ではないが定義されることを約束した。 正規表現コードの中で、$/ 公式に未定義で、そしてそうするための参照だ$0 あるいは他のキャプチャ変数がそうするための参照がない現在の値を生産するためにコンパイルされるかもしれない$/. 同じくそうするための参照$<foo> 必ずしも平均ではなくする$/<foo> 正規表現プロパーの中で。 ステートが実際に記憶されるマッチ、現在のマッチの実行の間に$¢ レキシカルスコープなではないが行儀よく振る舞うことを約束したマッチ、しかしそれの適切な部分への変数$/ オブジェクト、から$/
型の（こと・もの）だMatchステートが型について生じるマッチである間にCursor.
何ででもこれが（そのために）すべてユーザーにトランスペアレントな場合が簡単にマッチする；そして正規表現コードの外で（そして正規表現の中でクロージャの中に）$/ 変数がその時点でマッチのステートを表すことを保証される。 すなわち、標準の Perl コードが上に常に依存することができる$<foo> 意味$/<foo>そして$0 意味$/[0]マッチが完了した後、そのコードが正規表現の中のあるいは正規表現の外のクロージャで埋め込みかにかかわらず。