タイトル

Synopsis 4：ブロックと文

著者

Larry Wall <larry@wall.org>

機種

Created: 19 Aug 2004

Last Modified: 30 Aug 2011
Version: 113

このドキュメントは Perl のブロックと文構文をカバーする Apocalypse 4を要約する。

語彙の、そしてダイナミックなスコープの Relationship

制御流れはすべてのコンピュータプログラム言語のダイナミックな特徴だ、しかし言語が制御流れがしばしば「雑音」として知られている言語の宣言部分特徴に愛着を持っているか、あるいは「語彙である」程度で異なる。我々は現在の原文の場所を囲むそれらのブロックを示すつもりであってその工業規格で語句「語彙の有効範囲規則」を使う。いっそう抽象的には、宣言がそれと交際した何でもそれらの原文のブロック同じくレキシカルスコープの一部であると見なされる、そしてこれは、変数とルーチンの鮮明度がローカルな領域特定言語を作成する限りにおいて、項が語彙の有効範囲規則が実際にコードの現在のチャンクのために「レキシコン」を定義するという意味で、その名前の「語彙の」部分を得るところだ。

関数あるいはメソッドが呼び出される時いつも、我々は作られて、そして破壊されるネストされた呼び出しフレームを示すために同じく標準的なファッションで「動的関係をスコープ宣言し」項を使う。たいていの面白い番組で動的有効範囲はレキシカルスコープから非常に異なってネストされる、それで慎重に我々がどの有効範囲規則の種類について話をしているか識別することは重要だ。

さらに困難を増大させることは有効範囲規則あるいは他について孤立してすべてのダイナミックスコープの外の呼び出しフレームがどこか（に・で）レキシカルスコープと結び付けられる、それであなたが1種類にただ見なすことができないということだ。多くの構造が語彙の、そしてダイナミックな機能の特定の相互作用を明確にする。例えばは、正常と異なり、レキシカルに範囲変数、動的変数が特定の名前のダイナミックな変数のための呼び出し一時的記憶装置上がる、しかし途中でそれぞれの「停止」においてで捜索する、それらは実際に語彙の「メモパッド」であの特定のダイナミックスコープの呼び出しフレームと結び付けられるように見えている。

Perl 6 に、制御流れがユーザーがほとんどいつも期待することをするよう意図される、しかしこれは我々が宣言部分をラベルとブロックの性質だと見なして、そしてそれらを呼出しスタックのダイナミックな性質と組み合わせなくちゃならないことを意味する。例えば、return 文が常にそれを囲むレキシカルにスコープ宣言されたサブルーチンから戻る。けれどもそれをするために、サブルーチンの電流に内部の呼び出しフレームがフレームを呼び出すことは最終的に dynamic のレイヤについて何でも番号を付ける後部の皮をむかなければならないかもしれない。レキシカルスコープはダイナミックな演算のために宣言されたターゲットを供給する。これのための産業に一般的な項があるように思われない、それで我々は語彙のターゲットを念頭に置いてダイナミックな演算を行なうこれらの奇妙な演算に言及するために項 lexotic を造り出した。 Perl 6 の Lexotic 演算子が次のものを含む：

return
next
last
redo
goto

もし lexotic 解釈がうまくいかないなら、これらの演算子の若干が同じく純粋にダイナミックな解釈に戻って落ちる。例えば、next ラベルで lexotically にループを出ることをより好むだろう、しかしもし語彙のコンテキストに適切なラベルにループがないなら、そのループがレキシカルに目に見えないであろうけれども、それはそれから上方に動的に呼び出しフレームを通して何についてでも適切なラベルを持っているループを走査するだろう。（next ラベルなしで純粋にダイナミックだ。） Lexotic とダイナミックな制御流れがコントロールの例外のシステムによって実装される。 lexotic のために戻れnextコントロールの例外（ラベルがその識別情報を発見するためにすでに「使い尽くされた」ときから）、出られるためにループスコープの識別情報を含んでいるだろう、しかしダイナミックな後退のために、例外は動的に一致されるためにただループラベルだけを含むだろう. 下のコントロールの例外を見ろ。

Relationship of Blocks と宣言

すべてのブロックはクロージャだ。（すなわち、アブストラクト、それらに（彼・それ）らの語彙の環境のスナップショットをとるすべての匿名のサブルーチンがある。）ブロックがどのように訴えられるか、そしてその結果がどのように使われるかがコンテキストの問題だ、しかしクロージャがすべて内側に同じことを発揮する。

ブロックカーリーによって、あるいは初めまでに区切られるそして現在のコンパイル単位の終端（現行ファイルあるいは電流eval 文字列）. Perl 5 の場合と異なり、標準的な制御構造の周りに（ポリシーまでに）暗黙のブロックがない。（あなたはこれを裏切るマクロを書くが、衝動に抵抗することができた。）外の文と（ループ変数のような）内側ブロックの間を調停する変数が一般にそのブロックに仮パラメータとして宣言されるべきだ。クロージャに仮パラメータを宣言する3つの方法がある。

$func = sub ($a, $b) { .print if $a eq $b };  # standard sub declaration
$func = -> $a, $b { .print if $a eq $b };     # a "pointy" block
$func = { .print if $^a eq $^b }              # placeholder arguments

それが使うプレースホルダー引数がないそのままのクロージャ（条件命令と結び付けられるブロック以外）$_ （明示的にあるいは暗黙のうちに）扱われるかのように$_ 仮引数だった：

$func = { .print if $_ };   # Same as: $func = <-> $_ { .print if $_ };
$func("printme");

何ででも場合、仮パラメータが同等物であるすべてmy ブロックの中の変数。関数パラメータの上にさらに多くのために S06 を見ろ。

このような仮引数宣言以外、すべてレキシカルスコープな宣言が宣言のポイントからブロックを囲むことの終わりまで目に見える。お終い。 Lexicals がそうしないかもしれないブロックから（少なくとも、ブロックの部分での若干の明示的なエイリアシングの動きなしでではなく、モジュールからのシンボルの書き出しのような、）他のいかなる外部範囲でもまでの「漏えい」. 「宣言のポイント」はコンパイラが見る瞬間だ「my $foo」 Perl 5 のように、それほど文の終わりじゃない

my $x = $x;

もう外の（人たち・もの）の値を見ないだろう$xあなた同様言う必要があるだろう

my $x = $OUTER::x;

あるいは

my $x = OUTER::<$x>;

その代わりに。

もしあなたが同じ範囲に2度語彙を宣言するなら、それは同じ語彙だ：

my $x;
my $x;

デフォルトまでに2番目の宣言はコンパイラ警告を受けとるだろう。あなたは、最初の宣言を修正することによって、これを隠すかもしれないでproto：

my proto $x;
...
while my $x = @x.shift {...}              # no warning
while my $x = @x.shift {...}              # no warning

あなたが言及したもし$x 宣言とコンパイラが試験的にそれをバインドした最初の前に$OUTER::xそれから、それはそれを宣言するエラーだ、そして編集者はその時点で不平を言うように要求される。もしこのような用途が、それが eval で隠されるから、検出されることができないなら、それ以来、誤っているeval() コンパイラがいずれかにバインドするかもしれない$OUTER::x あるいはその後宣言する「my $x」.

Perl 5 、のように「our $foo」現在のパッケージで変数のためにレキシカルにスコープ宣言された別名を開始する.

新しい（人たち・もの）constant 宣言詞がコンパイル時定数を開始する、変数あるいはそうであるかもしれない名指された値が擬似割り当てで初期化した：

constant $pi of Int = 3;
my Num constant π = atan2(2,2) * 4;

展開式が評価される初期化することBEGIN 時間。定数（そして列挙型）が義務を怠るそうすることour 有効範囲規則、それでそれらがパッケージの外からアクセスされることができる。

ある新しいstate それがレキシカルにスコープ宣言された変数を開始する宣言詞my それが1つの呼び出しの終わりから次の（人たち・もの）の始まりまでその値を引き留めるように、クロージャの生活をして、しかし生涯それでために固執する。クロージャの別個のクローンが別個のステート変数になる。しかしながら、再帰的が同じクローンの使用に同じステート変数を呼び出す。

Perl 5 「local」関数が改名されたそうしたことtemp もっと良くそれが何をするかを反映するために。同じくあるlet 仮説の値をセットする関数。それは正確に同種のものをもたらすtemp現在ブロックが失敗して終了する場合に限り、それ以外、値は回復するだろう。（さらに多くのために下の Definition of Success を見ろ。） temp そしてlet テンポラリ化しろ、あるいは値あるいは、あなたが割り当てあるいはバインディングをするかどうかについて、依存している変数を hypotheticalize しろ。 Perl 5 からの他の1つの相違がデフォルトが変数を undefine しないはずであるということだ。それで

temp $x;

原因$x で始まる項目にその現在の値。使用

temp undefine $x;

Perl 5 振る舞いを得るために。

もしそのスコープの中の継続がとられるなら、範囲辞任の上に未完成の temporizations がやり直される用意を整えているに違いないことに注意を払え。

Relationship of Blocks と文

早くブロックを終了させている明白な制御流れがないときには、リターン値ブロックの終了はその最終の文の値だ。これは文のそのトップレベルのリストの逐語的に最後の文と定義される；それらのトップレベルの文の中で埋め込みのどんな文でも文の（彼・それ）ら自身のより低レベルのリストにあって、そしてそれらである間にそれら subscope で最終の文であるかもしれない、それら問題の外側ブロックの最終の文だと見なされない.

これは遠まわしに Perl 5 の振る舞いと異なっている、そしてそれは戻るはずだ、と最後の展開式の値は、たとえその展開式がただ条件文に過ぎなかったとしても、評価した。 Perl 5 の場合と異なり、もし Perl 6 の最終の文がその支店の何も実行しない条件文であるなら、 condional の値が何であるかは重要じゃない、その条件付きの文の値は常に存在するNil. 　もし、まったくブロックに文がないなら、結果は同じくだNil.

文 - 最終のブロック

閉じ括弧で終わっている1行「}」空白文字あるいはコメント以外の何によっても後に続かれないで、もし文の終わりがそこ（に・で）起こることができるなら、文を終了させるだろう. すなわち、これらの2つの文は同等だ：

my $x = sub { 3 }
my $x = sub { 3 };

かっこでくくられた展開式からと文であるそれら胃腸が見なす、これは首尾一貫してどこ（で・に）さえあなたが問題を期待するかもしれないか考え出す：

my $x = [
    sub { 3 },  # this comma is not optional
    sub { 3 }   # the statement inside [] terminates here
];

my $hash = {
    1 => { 2 => 3, 4 => 5 },  # OK
    2 => { 6 => 7, 8 => 9 }   # OK, terminates inner statement
};

サブルーチン宣言が、文ではなく、展開式であるから、これは今無効だ：

sub f { 3 } sub g { 3 }     # two terms occur in a row

けれどもこれらの2は効力がある：

sub f { 3 }; sub g { 3 };
sub f { 3 }; sub g { 3 }    # the trailing semicolon is optional

ある特定のコントロール文が考えられるところではラインの真ん中に終わるすべての文を終了させるブロックが終了させられなくちゃならない、ビジュアル一貫性のための、独立の方法で解析されることができたけれどもそれらじゃないならセミコロンによって、何か他の文ターミネータによって：当然終了させられる

while yin() { yang() }  say "done";      # ILLEGAL
while yin() { yang() }; say "done";      # okay, explicit semicolon
@yy := [ while yin() { yang() } ];       # okay within outer [...]
while yin() { yang() } ==> sort          # okay, ==> separates statements

条件付きの文

if そしてunless それらが Perl 5 にすると同じように、文が働く。しかしながら、あなたは条件文で括弧を除いてもよい：

if $foo == 123 {
    ...
}
elsif $foo == 321 {
    ...
}
else {
    ...
}

条件命令の結果は実行するように選ばれたブロックの結果だ。もし条件文が実行しないなら、何でも分岐する、帰りの値はそうだNil.

unless 文が許さないelsif あるいはelse 中にいる Perl 6。

条件付きの展開式の値はクロージャパラメータにオプションとしてバインドされるかもしれない：

if    testa() -> $a { say $a }
elsif testb() -> $b { say $b }
else          -> $b { say $b }

真実で評価されて、そしてその後バインドされている値が必ずしも型の値じゃないことに注意を払えBool. 　（Perl のすべての標準の型は真実で評価されるかもしれない。実際、この構造は、クロージャの中であなたがすでに知っているから、もしあなたがパラメータとしてそれ以外の何ものでもなくブールの値をバインドすることができたなら、比較的無用であるであろうかどうかそれ真あるいは偽に評価される。）中のバインディングelse 自動的に前のものによってテストされた値をバインドするif あるいはelsifそれは偽であることが知られている間に、にもかかわらず偽の面白い値であるかもしれない。（推論している相似によってunless 偽のパラメータのバインディングを許す。）

明示的なプレースホルダーが同じく使われるかもしれない：

if blahblah() { return $^it }

しかしながら、使え$_ これらすべてのメソッドが同じインボカントを使うように、0 - ary ブロックを1 - ary 関数に変えるのに十分明示的であると見なされた条件付きか、あるいは条件付きで繰り返しの文のブロックではないで：

if .haste { .waste }
while .haste { .waste }

（次のような非条件命令とコントラストを呈しろ

for .haste { .waste }

ブロックへのそれぞれの呼び出しがのために新しいインボカントをバインドするであろう.waste メソッドは、それぞれはどちらかについて多分オリジナルのインボカントと異なっている.haste メソッド。）

条件付きの文修飾子が Perl 5 のように機能する。それでショート演算子によって暗示された暗黙の条件付きをしろ。注意するしかし括弧の中身あるいは括弧が文のセミコロンによって分離されたリストと解析される、それであなたが言うことができるとは：

@x = 41, (42 if $answer), 43;

そしてすなわち、同等の値：

@x = 41, ($answer ?? 42 !! Nil), 43

文を輪にしろ

Looping 文修飾子はそれ以外の、リスト comprehensions 、修飾子が許可である環状になっている文が一つの条件付きの文修飾子を含んでいると書くことについての容易さのための Perl 5 にと同じだ：

@evens = ($_ * 2 if .odd for 0..100);

修飾子を輪にしろnextlastそしてredo Perl 5 のように同じく極めて働け。しかしながら、ラベルをはられたフォームはメソッド呼び出し構文を使うことができる：LABEL.nextなど. .next そして.last メソッドがオプションを飲む、寛容な引数、それの最終の値、が繰り返しを輪にする。それで古いものnext LINE 構文がまだ許される、しかし本当に何かに同種のものをするLINE.next(Nil) 下に。 Any ブロックオブジェクトが使われることができる、ただラベルじゃない、それで値を返すために、現在ブロックのこの繰り返しからあなたは言うことができる：

&?BLOCK.next($retval);

［推測：そのままnext($retval) 関数が教えられることができた、から同じぐらい長い同じことをしろ$retval ループラベルじゃない。多分多数のディスパッチがこれを分類することができた。］

ターゲットオブジェクトあるいはラベルで、ループ修飾子が lexotically に修正するべき範囲を検索する。しかしながら、ターゲットなしで、それらが純粋に存在する動的関係、そしてそうであるであろう一番奥のダイナミックなループを選択するmap あるいは、ユーザー定義の関数を含めて、他の暗黙のうちに環状になっている関数。

もっと長く、ないcontinue ブロック。その代わりに、使用NEXT ループの主要部の中でブロックしろ。下を見ろ。

ループ文の値はそれぞれの繰り返しからの値のリストだ。それぞれの繰り返しの値は一つの「引数」オブジェクトとして返される。引数の長い定義のために、しかし要するに S02 を見ろ、普通のオブジェクトあるいは区画が多数の値を含んでいる。

標準の平らなリストコンテキストが区画の境界を無視して、そしてリストを平らにする。コンテキスト回に何のためにでも区画オブジェクトをスライスしろSeq オブジェクト。

戻る繰り返しNil （呼び出すことによってのようだnext 余分の帰りの引数なしで）それを返すNil 従って、平らなコンテキストで間にはさまれるとき、姿を消すだろう、しかし空きを補間挿入するであろう次の値としてSeq スライスコンテキストの中に。

繰り返しが値を返すよりきめが細かい制御のために、使えgather そしてtake.

サブルーチンの最終の展開式がその値を返す、偶然にループのリターンを返すことが可能だからあなたがただ側近グループをその副作用について診断していただけであった値。もしあなたがサブルーチンで最終のループ文から偶然にリストを返すか、それの後に明示的な引き取り命令を置くか、あるいは使うことを望まないならsink ループ自身に関する文接頭語。

`while` そして`until` 文

while そしてuntil あなたが条件文の周りに括弧を書き（言い）落とすかもしれないこと以外、文が Perl 5 のように働く：

while $bar < 100 {
    ...
}

条件付きと同じように、あなたはブロックのパラメータに条件付きの展開式についてオプションとして結果をバインドするかもしれない：

while something() -> $thing {
    ...
}

while something() { ... $^thing ... }

何も暗黙のうちに今までにバインドされない、しかしながら、そして条件付きがただバインドするであろう多くTrue あるいはFalse 面白くないファッションで。このメカニズムは本当にただ値とスチールが（彼・それ）ら自身ままでいるどのようにブールを返すべきか知っているオブジェクトに良いだけだ。一般に、あなたが使って見なすべきであるたいていの反復される解決のためにfor その代わりに輪を作る（下を見ろ）。特に、我々は一般に、今使うfor ファイルハンドルを反復するために。

`repeat` 文

文修飾子を適用している Perl 5 の場合と異なりそうすることdo ブロックは特に認められない：




do {
    ...
} while $x < 10;    # ILLEGAL

その代わりに、いっそう Pascal のようであると、それだけあなたは書くべきだrepeat 輪を作る：

repeat {
    ...
} while $x < 10;

あるいは等しく：

repeat {
    ...
} until $x >= 10;

Perl 5 のと異なり、do-while 輪を作る、これはそれほど、今、実数ループブロックだnextlastそしてredo 期待されるように、働け。上に条件付きのループrepeat ブロックが必要とされる、それでそれはそれ自身のものによって、たとえあなたがラインにそれを置いたとしても、認識されるだろう：

repeat
{
    ...
}
while $x < 10;

しかしながら、それは崇拝者と一緒に視覚的に困惑している可能性が高いwhile 最良のときでも輪を作る、それでそれは同じく、同じ意味で、前部においてループを条件付きにすることを可能にされる。（repeat キーワードがループの終わりに条件文に評価されることを強いる、それでそれはまだCのだdo-while 意味規則。）そのために、ルール、前の例が中に書き直されるかもしれないGNUスタイルの下でさえ非常に明確 :

repeat while $x < 10
  {
    ...
  }

あるいは等しく：

repeat until $x >= 10
  {
    ...
  }

と同じように普通whileあなた、ブロックのパラメータに：条件付きの展開式についてオプションとして結果をバインドするかもしれない

repeat -> $thing {
    ...
} while something();

あるいは

repeat while something() -> $thing {
    ...
}

ループが、条件を評価する前に、1度実行するから、境界パラメータはループを通してその初めてのときに未定義だろう。

一般的なループ文

loop 文はCスタイルだfor 変装して輪を作る：

loop ($i = 0; $i < 10; $i++) {
    ...
}

Cのように、もしあなたが3部分の仕様を供給するなら、括弧は必要とされる；しかしながら、3部分のループ仕様は無限ループを書くために完全に除かれるかもしれない。すなわち、

loop {...}

Cish 慣用句と等しい：

loop (;;) {...}

`for` 文

ノーがあるforeach もう文。それは常につづられるfor Perl 6 に、それでそれは常にリストを引数であると思う：

for @foo { .print }

以前に、変数が名前をつけられるループがパスするという状態で、クロージャへのパラメータに言及したように：

for @foo -> $item { print $item }

パラメータがそうであるかもしれない Multiple がパスした、そしてその場合リストは一度にOR素子よりもっとくまなく渡り歩かれる：

for %hash.kv -> $key, $value { print "$key => $value\n" }

平行の2つの配列が使うプロセスにzip パラメータの対応する数にバインドされることができるリストを生成する関数：

for zip(@a;@b) -> $a, $b { print "[$a, $b]\n" }
for @a Z @b -> $a, $b { print "[$a, $b]\n" }        # same thing

リストは、使う代わりに、それほど、デフォルトによっていい加減に評価されるwhile あなたが Perl 5 にそうするであろう（とき・から・につれて・ように）、一度に1行ファイルを読むために：

while (my $line = <STDIN>) {...}

あなたが使うべきである Perl 6 にfor その代わりに：

for $*IN.lines -> $line {...}

これはスコープを制限することについての付加的な給与外特典を持っているの$line それが境界であるブロックへのパラメータ。（while「s宣言の$line ブロックの終わりを過ぎて目に見え続ける。思い出せ、ではなく暗黙じゃないブロック範囲。）書くことは同じく可能だ

while $*IN.get -> $line {...}

しかしながら、これは自動的にむしゃむしゃ食べられたファイルハンドルに失敗する可能性が高くて、それほど使用であるfor その代わりに輪を作る。

同じく Perl 5 が特別な規則を起こすことであることに注意を払え

while (<>) {...}

自動的に割り当てるために、そうするために$_ Perl 6 へと振る舞われたではない。それは今書かれるべきだ：

for lines() {...}

ショートがどちらのためか

for lines($*ARGFILES) {...}

pointy ブロックの仮パラメータにバインドされた引数がブロックの中でデフォルト読み取り専用のそばにいる。あなたは、含むことによって、パラメータを読み書きだと宣言することができる「is rw」トレイト. 次のことが中にすべての他の値を処理する@values modifiable として：

for @values -> $even is rw, $odd { ... }

あなたがデフォルトとするべきあなたのすべてのパラメータを欲するケースでrwあなた視覚的に示唆に富むダブルによって終わらせられた矢印を値が、両方の方法で：流れ出ることを示すために使うかもしれない

for @values <-> $even, $odd { ... }

これは同等であるそうすること

for @values -> $even is rw, $odd is rw { ... }

あなたが頼るもし$_ 暗黙のパラメータとしてブロックに、それから$_ デフォルトによって読み書きだと見なされる。すなわち、構造：

for @foo {...}

賛成で実際に短い：

for @foo <-> $_ {...}

それであなたはこのような場合現在のリスト要素を修正することができる。

暗黙のブロック（thunk）の上に、文修飾子として使用されるとき、for そしてgiven 個人的にテンポラリ化する現在の値の$_ 文の左側のために、そしてループ辞任においてオリジナルの値を復活させろ：

$_ = 42;
.say             # 42
.say for 1,2,3;  # 1,2,3
.say;            # 42

前の値の$_ ループの中で使用不可だ。もしあなたがそれが利用可能であることを望むなら、あなたはカーリーを使って明示的なブロックとしてそれを書き直さなくちゃならない：

{ say OUTER::<$_>, $_ } for 1,2,3;  # 421,422,423

temporization がそれ以来陽関数形で必要じゃない$_ ブロックに仮引数だ。同じく、 temporization が賛成で決して必要とされないstatement_control:<for> なぜならそれは常にクロージャを呼び出すから。

髪形1度ループ

Perl 5 に、そのままのブロックが髪形1度ループであるとみなされる。 Perl 6 に、そのままのブロックは do-once じゃない。その代わりにdo {...} do-once ループである（それはあなたがそれ；使用に文修飾子を置くことができないもう1つの理由だrepeat なぜなら－の終わりにおけるテストが輪を作るから）。

何のためにでも文、プレフィックス変換でdo あなたにその文の値を返すことを許すそして展開式でそれを使え：

$x = do if $a { $b } else { $c };

この構造はただあなたに一つの文を展開式の終端に取り付けることを許す。もしあなたが文の後に展開式を続けることを望むなら、あるいはもしあなたが多数の文を付加することを望むなら、あなたはカール状のフォームを使うか、あるいはある種の括弧で展開式全体を囲まなくちゃならない：

@primesquares = (do $_ if prime($_) for 1..100) »**» 2;

そのままの展開式が文として使用されるかもしれないから、あなたは使ってもよいdo 展開式に、けれどもその唯一の効果は比類がない左として作用するはずだ、括弧、多くは好む$ Haskell での演算子。すなわち、優先決定が交差しないdo 境界と欠けている「right paren」は次の文ターミネータあるいは比類がない括弧において仮定される。 Ado 括弧の中に括弧を構文として開いている何でも文のセミコロンによって分離されたリストであるすぐ後に、不必要だ、それで上の人たちは実際手紙を書かれることができる：

@primesquares = ($_ if prime($_) for 1..100) »**» 2;

これは基本的に、右辺値展開式として我々にリスト comprehensions を与える：

(for 1..100 { $_ if prime($_)}).say

もう1つのこれの結果が通り過ぎてどんなブロックでもただ内部に左の括弧がすぐにそのままのブロックのように呼び出される、それで理解が多数のパラメータでブロック使って書かれるかもしれない多次元のリストが食べたということであるfor 修飾子：

@names = (-> $name, $num { "$name.$num" } for 'a'..'zzz' X 1..100);

あるいは、等しく、プレースホルダーを使って：

@names = ({ "$^name.$^num" } for 'a'..'zzz' X 1..100);

それ以来do 文レコード会社によって、文、それの前（に・で）行くことは、それが常に後に続かれることができるとは、続く（とき・から・につれて・ように）、定義される。それが公式にループであって、そしてそのためにループ制御文を要することができるから、これは特に do-once ブロックのために有用だ。

文レベルのそのままのブロック

一つの文がもうループ、それが、それがすぐにデリファレンスされるかのように、 Perl 5 のようにすぐにまだ実行する do-once じゃないように起こっているそのままのブロックであるけれども.() このようなブロックの中でそうで、接尾辞CALLER:: ブロックを取り巻いているレキシカルスコープと結び付けられるダイナミックスコープに言及する。

もしあなたが関数からクロージャを返すために、あなたが明示を使わなくちゃならないならいいのにと思うなら、そんなものを前接続しろreturn あるいはsub あるいは->.

sub f1
{
    # lots of stuff ...
    { say "I'm a closure." }
}

my $x1= f1;  # fall-off return is result of the say, not the closure.

sub f2
{
    # lots of stuff ...
    return { say "I'm a closure." }
}

my $x2= f2;  # returns a Block object.

それが見られることができるところ（に・で）、文レベルブロックでのプレースホルダーパラメータの使用がパラメータが表にないから、構文エラーを引き起こす。しかしながら、通り過ぎて前接続されるとき、それはエラーじゃないdoあるいは、文修飾子によって：後に続かれるとき、

# Syntax error: Statement-level placeholder block
{ say $^x };

# Not a syntax error, though $x doesn't get the argument it wants
do { say $^x };

# Not an error: Equivalent to "for 1..10 -> $x { say $x }"
{ say $^x } for 1..10;

# Not an error: Equivalent to "if foo() -> $x { say $x }"
{ say $^x } if foo();

`gather` 文接頭辞

変形のdo 存在するgather. 　好むdoそれ文あるいはブロックによって後に続かれる、そして1度それを実行する. 同じじゃないdoそれ；値がその代わりに指定されるそれの復帰が呼び出すという状態で、文を評価するか、あるいは流し（空虚さ）コンテキストをふさぐtake 1つ以上が（語彙か、あるいはダイナミックな）スコープ以内の時間を測定する前置演算子をリストするgather.take シグネチャーがそれのような関数のreturnリスト演算子の構文を持っている間に、それはただ一つの項目あるいは「引数」を返す（鮮明度のための S02 参照）。

take もし visible があるなら、関数が lexotic である外gatherしかしもしそうでなければ純粋に dynamic に戻っている墜落。まあ、それは、それ以来、本当に後ろに下がらないtake コンパイル時間にそれがレキシカルにあるいはダイナミックに使われているかどうか知る。より低度に明らかに、それほどそうするgather; もし a gather レキシカルに何でも含んでいるtake 呼び出し、それは、 lexotic のみであると同じように、記録されている、そしてそれは原動力にとって目に見えないだろうtake. 　もしgather ノーを含んでいるtake レキシカルに、それは定義上何もの lexotic ターゲットであるはずがないtakeそれがただ dynamic を収獲することができるだけであるようにtake 呼び出し。もしユーザーと dynamic を使うライブラリの著者の試み両方がユーザー定義のコールバックでそのを含む段落を増すなら、唯一の残っている困難は生ずるtake. 　それで我々は、それらのコールバックが外のダイナミックスコープにどうにかして「ungathered」じゃないなら、図書館の著者がダイナミックなギャザーをコールバックと混ぜることが誤っていると言うだろう。［推測が：そこ（に・で）あるいはそうであるべきだcallergather これ、あるいはそれが職務記述に加えられるべきであるする原始lift. 　3番目の選択がラベルをはられて許すことだgather/ take このような状況と dynamic のためにtake マッチしなくちゃならないgather「正確にs名札（あるいはその欠如）。（項「ラベル」を大ざっぱに、若干の識別情報オブジェクトに .gather と .take メソッドのような、ラベル構文のほかに他のソリューションを含むために使う）］

もしあなたがコンマリストの中の多数の品目をとる、（それが、結局のところ、リスト演算子だから）、それらが中にラップされるであろうならParcel 次の引数としての帰りのためのオブジェクト。コンテキストが応用される付加的take 演算子は、すべてのコンテキストから Perl 6 にいい加減だ。どのようにかについて、平らになることあるいはそんなものが区画をリターンした何でも薄く切ることが依存するだろうgather「sリターンイテレータが反復される（で.get 対.getarg）.

通り過ぎて返された値take to the take「s　コンテキストがその同じ返送された引数であることを告白しろ（それはいつ無視されるtake 流しコンテキストにある）. かかわらずtake「即刻のコンテキストが、オブジェクトが返送されているという状態で、同じく返される集められている値のリストに加えられるsgather いい加減なリスト（すなわち、本当に、イテレータ）として、そのリストのそれぞれの引数要素が1（人・つ）に対応するという状態でtake.

平らなコンテキストの中にバインドされるとき、返送されたリストの Any 区画は通常平らになっている。しかしながら、 lol コンテキストの中にバインドされるとき、区画オブジェクトは実数になるList それら識別情報を別々の部分リストとして保持するオブジェクト。終局のバインディングコンテキストはそれで離れてスローするか、あるいは組分けをそれぞれの個人に起因させておくべきかどうか決定するtake 呼び出し。コンテキストが薄く切られてよりむしろ平らなたいていのリスト、それで民間企業の間の境界take 通常呼び出しが姿を消す。（FLAT は Flat Lists Are Typical. ことを意味する頭字語だ :)

からgather コンテキストが、これほど典型的に起こす撃沈でそのブロックあるいは文を評価するtake 流しコンテキストで評価される関数。 However, a take 流しコンテキストでのではないがその帰りのオブジェクトが passant に、そして同じく en すると思う関数が変化していないそれらを返す。これはあなたが最後に何を「した」かを記録・追跡することを容易にする：

my @uniq = gather for @list {
    state $previous = take $_;
    next if $_ === $previous;
    $previous = take $_;
}

take 同時に関数が本質的に2つのコンテキストを持っている、コンテキストはどちらでであるgather 営業することとコンテキストはどちらにあるtake 営業している。それらが異なって結果として生じている区画をバインドするか、あるいは強制するかもしれないから、これらは同一のコンテキストである必要がない：

my @y;
@x = gather for 1..2 {          # flat context for list of parcels
    my ($y) := take $_, $_ * 10;  # item context promotes parcel to seq
    push @y, $y;
}
# @x contains 4 Ints:  1,10,2,20 flattened by list assignment to @x
# @y contains 2 Seqs: Seq(1,10),Seq(2,20) sliced by binding to positional $y

同じく、我々はただ、それをバインドして、そして後に強制することによって、ギャザーの起因区画を覚えていることができる：

my |$c := gather for 1..2 {
    take $_, $_ * 10;
}
# $c.flat produces 1,10,2,20 -- flatten fully into a list of Ints.
# $c.slice produces Seq(1,10),Seq(2,20) -- list of Seqs, a 2-D list.
# $c.item produces Seq((1,10),(2,20)) -- coerced to Seq of unresolved Parcels

それに注意するtake この例でそれ自身流しコンテキストにあるからfor ループがコンテキストがギャザーの中に供給したシンクにある。

Agather ではないがループを見なした、しかしそれは上記の例のようにループ文と組み合わせることが容易だ。

take 演算が resumable コントロールの例外、あるいはダイナミックな変数、あるいは粘土錠剤を振る舞っているハトを使って内部的に定義されるかもしれない。特定の実装がする何でも特にそうである選択で Perl 6 とあなたの定義の一部ではなくが移植性があるコードでそれに頼るべきじゃない。

`lift` 文接頭辞

一般的なマルチルーチンを書くとき、あなたはしばしばその意味が呼び出し側の言語のコンテキストに依存する少しのコードを書くことを望む。それはいくぶんインボカントの型に実際の呼び出しが依存する事実上のメソッドのようだ、しかしここで「インボカント」は本当にレキシカルスコープだ、呼び出し側と事実上の呼び出しについてが名前バインディングだ。リフトの中で、特殊なルールが名前が調べられる方法に適用される。ただすぐに周囲のルーチンのレキシカルスコープで定義された名前がコンクリートだと見なされる。我々が実際に呼び出し側がランタイムに誰であるか知っているとき、他のすべての名前（演算子の暗黙の名を含めて）が呼び出し側のレキシカルスコープで検索される。（呼び出し側が呼び出しから呼び出しへと変動することができることに注意を払え！）

これは、型と sub のような変数と名指された値の名を含めて、時間を見上げられる必要がコンパイルする何にでも適用する。

このメカニズム、いっそう特定のバージョンへの一般的なマルチ容器のリダイレクト死刑執行である、しかしこのリダイレクションのためのリストが、レキシカルスコープによってではなく、呼び出し側によって決定される候補を通してマルチ、呼び出し側を通して以外呼び出し側のレキシカルスコープを見ることができない : : 疑似パッケージ。例えば、一般的な Perl 力eq 文字列への強制型変換にこのような比較

proto infix:<eq> (Any $a, Any $b)   { lift ~$a eq ~$b }            # user's eq, user's ~
multi infix:<eq> (Whatever, Any $b) { -> $a { lift $a eq $b } }    # user's eq
multi infix:<eq> (Any $a, Whatever) { -> $b { lift $a eq $b } }    # user's eq
multi infix:<eq> (&f:($), Any $b)   { -> $a { lift f($a) eq $b } } # user's eq
multi infix:<eq> (Str $a, Str $b)   { !Str::leg($a, $b) }          # primitive leg, primitive !

の定義された変数に参照があるそれぞれの一片の持ち上げられたコードでそれに注意するマルチ、そんなものけれども$a$bそして&f. 　これらは額面通りに信用される。リフトの中の他のすべてが呼び出し側の言語のコンテキストで何かを意味すると考えられる。（これは時ある、それが通常見つけられるであろう若干のエラーが、我々が呼び出し側のレキシカルスコープが点でどのように見えるか知っているまで、発見されることができない時間をコンパイルすることを意味する。それは問題がない。）

他`do`－フォームのように

キーワードがそれによってコントロールされるためにコードによって後に続かれる他の類似のフォームが同じくそのままの文をとるかもしれない、それは下記を含むtryquietlycontendasynclazyそしてsink. 　これらの構造は必ずレキシカルスコープを確立しないでダイナミックスコープを確立する。（権限：が、常に、引数のブロック形式を使うことによって、明示的にレキシカルスコープを確証する。）文 introducers として、これらすべてのキーワードは空白文字によって後に続かれなくちゃならない。（権限：が何かが好むと言うtry({...})それからあなた以外呼び出しているtry() その代わりに、そして Perl から関数呼び出し構文を使っている関数がこのような関数を供給しない、それは想定されるだろう、からユーザー定義の関数であれ。）フロー制御の目的で、フォームがそうであるこれらのいずれでもとループが見なした、けれどもそれらが容易に標準のループに適用されるかもしれない。

何でもカテゴリーが定義する statement_prefix で特別な構文を作成するとは、注意しろ。もしそれがリスト演算子と解析しないブロックによって後に続かれるならあるいは単項の接頭辞；それが決して何も探さないであろうけれどもブロックの後に続く追加の展開式。特に、

foo( try {...}, 2, 3 )

呼び出しfoo 3つの引数と一緒の関数。そして

do {...} + 1

髪形の結果への1がブロックすると付け加えろ。他方、もし statement_prefix が非ブロックによって後に続かれるなら、文が、すべて statement_prefixes が同じ文終末で終えるであろう blockless をネストした：

do do do foo(); bar 43;

解析されるけれども :

do { do { do { foo(); }}}; bar(43);

スイッチ文

スイッチ文は topicalizing の手段だ、それでスイッチキーワードは、 topicalizer に、英語だgiven. 　個別のケースのためのキーワードはそうだwhen：

given EXPR {
    when EXPR { ... }
    when EXPR { ... }
    default { ... }
}

現在のトピックは特別な変数に常に aliasedだ$_.given ブロックはただ現在のトピックをセットする1つの方法に過ぎない、しかしスイッチ文は凝固するどんなブロックでもであり得る$_含むfor ループ（そのループ変数の1つが境界である仮定すること$_）あるいは体がメソッドの（あなたがインボカントを宣言したもし$_）. 切り換え振る舞いが実際に生じているようにwhen ブロック自身の性質によってではなく、ブロックの文。 Awhen 文が暗黙のうちに現在のトピックの間の「スマートなマッチ」をする（$_）そして引数のwhen. 　もしスマートなマッチが成功するなら、when「sによって関連づけられたブロック実行される、そしてそれが持っている一番奥の周囲のブロック$_ （明示的であるか、あるいは暗黙の）その仮パラメータの1つが自動的に脱出される（とき・から・につれて・ように）。（もしブロックあなたが残すことを望む、あなたが使わなくちゃならないそのではないLABEL.leave メソッド（あるいは何か他のコントロールの例外ようreturn あるいはnext）もっと具体的に言うと、コンパイラからどの周囲の構造が実際の topicalizer だと意図されたか言い当てることが難しいことを見いだすかもしれない。）内側ブロックの値は外側ブロックの値として返される。

もしスマートなマッチが失敗するなら、そうするかもしれない通常代金、次の文、をコントロールするか、あるいはそうじゃないかもしれないwhen 文。それ以来when 文が標準の文のように順に実行されると推測される、すべてのスイッチブロックの文が存在することは要求されないwhen 文（それが連続的にシーケンスを持っているべきオプティマイザを助けるけれどもwhen 文、それからそれがもしかするとマッチするかもしれない最初の適切なテストにすぐ上がるように手はずを整えることができるから。）

デフォルトのケース：

default {...}

であると同等そうすること

when * {...}

からwhen 文が順に実行される、デフォルトは最後に来なくちゃならない。あなたは明示的なデフォルトを使わなくてもよい－あなたはただ最後のものから落ちることができるwhen 普通のコードの中に。しかし使用のdefault ブロックは良いドキュメンテーションだ。

もしあなたが使うならfor 名前をつけられたパラメータでループしろ$_ （明示的にあるいは暗黙のうちに）、何ものトピックとしてのそのパラメータの缶詰関数when ループの中の文。

あなたは明示的に脱出することができるのwhen 使うのが早いブロック（そしてその周囲の topicalizer 区画）succeed 動詞。いっそう正確には、それは最初に外へ（レキシカルに）一番奥の（人たち・もの）について含んでいることを走査するwhen ブロック。そこからそれはスキャンに外へ外に一番奥のブロックを見いだし続けるwhen それが定義する$_明示的にあるいは暗黙のうちに。（これらの走査の両方ともがされる重要性で時間をコンパイルしろ；もし走査が失敗するなら、それはコンパイル時セマンティックエラーだ。）典型的に、このような外側ブロックがブロックだろうのgiven あるいはfor 文、何以外でもトピックを設定するブロックが脱出されることができる。ランタイムに、succeed スキャンのコントロールの例外を動的連鎖を上にのぼってその同じ外側ブロックに、そしてそれがそのフレームを見いだした、それがそうするとき呼び出しフレーム帰属を見いだすために使う.leave それに関して呼び出しフレームを解くために。もし引数が供給されるならそうすることsucceed 関数、それらがパスされるとしてleave メソッド。なぜならブロックが1を脱出している成功した復帰だと見なされる去ることsucceed 目的で同じく成功した復帰だと見なされのKEEP そしてUNDO.

通常の暗黙の休憩when 暗黙としてのブロック全体（通常その最後の文から）の値を返して、同じように作品をブロックしろsucceed.

あなたは明示的に去ることができるwhen ブロックして、そして次の文下記に行くwhen 使うことによってproceed. 　（次のCの「失敗に終わる」考えと異なり、それに注意しろwhen 条件が評価される。次の（人たち・もの）の中に飛び込むためにwhen その状態、あなたが使わなくちゃならないテストなしでブロックするgoto. 　けれども一般にその手段は、あなたはその代わりに再び因数分解するべきだ。）

もしあなたがそれがメイン区画であるスイッチを持っているならfor 使うループ$_ 可変そのループとして、そしてあなたは暗黙的にあるいは明示的に取り替えを脱出する（すなわち、スイッチを「成功する」）、コントロールがそのブロックの終わりに、そしてそこからループの次の繰り返しの上にただ行く。あなたは使わなくちゃならないlast （あるいは若干のいっそう強暴なコントロールの例外ようreturn）早くループ全体を脱出すること. もちろん、明示next いっそう明確であるかもしれないよりsucceed もしあなたが本当に直接次の繰り返しに行くことを望むなら。他方、succeed オプションの引数をループのその繰り返しに値しに連れて行くことができる。と同じように.leave メソッド、同じくある.succeed スイッチとして作用しているラベル付きブロックから離れるメソッド：

OUTER.succeed($retval)

あるwhen 文修飾子、しかしそれは何も持っていない、包囲突破意味規則；それはただ存在する流れに対して項目にスマートマッチする. すなわち、

doit() when 42;

であると同等そうすること

doit() if $_ ~~ 42;

これは特に有効な繰り返し要素の並び comprehensions だ：

@lucky = ($_ when /7/ for 1..100);

例外調教師

多くの他の言語と異なり、 Perl 6 は、3位以内に入賞することによって、例外ハンドラを指定するCATCH その例外が扱われるようにしているそのブロックの中でブロックしろ。

Perl 5 のへの Perl 6 同等物eval {...} 存在するtry {...}. 　（Perl 6 のeval 関数がただ、ブロックではなく、文字列を評価するだけだ。） Atry ブロックがデフォルトでそうしたCATCH それらを無視することによって、すべての致命的な例外を扱うブロック。あなたが定義するもしCATCH 中でブロックするtryそれデフォルトを置き換えるCATCH. 　同じくそれ型try 缶が機能する、何でもブロックするから、冗長なキーワードtry あなたが置いたもしをブロックするCATCH それの中でブロックしろ。

例外ハンドラはたまたま取り扱われるために最新の例外である暗黙のトピックに関してただswitch文に過ぎない。内部にCATCH ブロック、問題の例外はバインドされるそうすること$_. 　マッチしている、普通の苦悩のためにwhen 文は十分に強力だ、からパターンが例外ハンドラのために何も特別な構文なしでクラスに対しての最新の例外あるいはパターンあるいは数とマッチする。もし中にケースのいずれもCATCH 例外を扱う、例外は再び投げられるだろう。すべての unhandledな例外を無視するために、空きを使えdefault ケース。（言い換えれば、暗黙がある.die 終わりのすぐ内側にのCATCH ブロック。扱われた例外がこの暗黙の再投げを過ぎてループを抜ける。）従って、CATCH それが内部にコードを扱うという点で、他のすべてのswitch文と異なったdefault すべての後のコードとは異なってブロックするwhen ブロックしかし中にではなくdefault ブロック。

もっと特定するとあなたが書くとき：

CATCH {
    when Mumble {...}
    default {...}
}

あなたは本当に機能するキャッチラムダの中にこのような何かを呼び出している：

-> *@! {
    my @handled = ();
    my @unhandled = ();
    my @*undead = ();

    for @! {
        # note, fails current iteration, continues with loop
        SIMPLECATCH { push @*undead, $_; push @unhandled, OUTER::<$_>; }

        .handled = True;
        when Mumble {...}
        default {...}
        .handled = False;

        push @*unhandled, $_;

        KEEP { push @handled, $_ if .handled }
    }

    push @unhandled, @*undead;

    # no point in setting their $! if we're gonna blow past
    set_outer_caller's_bang(@handled) unless @unhandled;

    @unhandled;
}

それが終わりに押しやられる例外が、調教師の実行の間に、起こるときはいつも@*undead 外の調教師によっての後の処理のための配列。もし unhandled された何かがあるなら@! 例外、あるいはもし例外がそうであった何（何もしないが、何も作り出すべきじゃないその推薦コードに例外の負担を強いる）内部の SIMPLECATCH によってもついたなら。

呼び出し上がる例外の投げ手顔つきは () を返すキャッチラムダがすべての例外が扱われることを示すために積み重なる、そして次にそれは幸せであって、そしてそのポイントに山をほどく。もし例外がそうである何かが handled. ではなくとして例外を返したなら、フリンガーがスポットがほどけるべきより高いダイナミックスコープを探し続ける。それほど何も的に注意しろdie ラムダが最終的にとして例外ハンドラが来たすべての例外を扱うチャンスを持つ流れになって初めて外部にわずか1つの新しい例外としてのラムダを再び投げかける止め金に@!.

Resumable の例外が実装に依存して通常去るかもしれない、あるいはそうしないかもしれない。もし継続が使われるなら、.resume 呼び出しがただ問題の継続に行くだろう、そしてラムダの callframe は捨てられる。「再開した」ように、 Resumable の例外が同じくただ最新の例外を記録を残すことによって、実装されるかもしれない、その場合オリジナルの例外の投げ手はただ、戻る前に、くつろぐよりむしろ、 resumable の例外をスローしたコードに戻る。これは、再開された例外を unhandledなリストの上に押しやることによって、されることができた、そして次にただシングルだけがあるかどうか見るために調べている投げ手は「unhandled」リストで例外を再開した。 .resume がそれを操作することが容易であるように、 unhandledなリストは動的変数だ。

ACATCH ブロックがそれが定義されたレキシカルスコープを見る、しかしその呼び出し側は例外をスローしたダイナミックな場所だ。すなわち、若干の例外ハンドラが、問題の例外を「扱う」ことによって、それをほどくことに決めるまで、スタックではないはくつろいだ。それで論理的に、もしCATCH それ自身の例外、あなたが期待するであろうブロック投げCATCH 回帰的に永久にそれ自身の例外をとらえるためにブロックしろ。 However, a CATCH 我々がそれを言うように、そのように振る舞ってはならないCATCH 決してそれ自身のダイナミックスコープの中でスローされたどんな例外でも扱う試みではなくブロックしろ。（さもなければ何もdie 無限ループを起こすだろう。）その代わりに我々は上へそれらを大事にして、そして調教師にもっと上にそれらを再び投げる。

例外をコントロールしろ

すべての異常な制御流れが、一般的なケースで、（特定のケースで離れて最適化される可能性が高い）例外メカニズムによって扱われるここで「異常な」は何にも外へただブロックの終わりから落ちていない制御転移を意図する。 Areturn例えば、それが現在のサブルーチン定義の範囲の終わりにクロージャのマルチレベルからジャンプすることができるから、ある形式の異常な制御流れだと見なされる。指令を輪にしろnext 異常であるが、あなたがブロックの端を打ったから、ループしているではないだ。暗黙の休憩（何かsucceed 明示的にする）のwhen ブロックは異常だ。

ACATCH ブロックがただ「良くない」例外だけを扱って、そしてコントロールの例外を unhindered されてパスさせる。例外が一緒にとらえられるかもしれない Control CONTROL ブロック。一般に、あなたがコントロール構造を定義していないなら、あなたはこれのことで心配する必要がない。あなたは1（人・つ）を持っているかもしれないCATCH ブロックと1（人・つ）CONTROL 若干のユーザー定義の構造が暗黙を供給することを望むかもしれないから、ブロックしろCONTROL あなたのクロージャにブロックしろ、しかしあなたにあなた自身のものを定義させろCATCH ブロック。

Areturn 常にレキシカルに周囲の sub から終了するあるいはメソッド定義（すなわち、関数から公式に宣言されたでsubmethodあるいはsubmethod キーワード）. ブロックとそのままのクロージャが明白な Pointy returnそれでreturn 文がまだ意味する&?ROUTINE.leave からRoutine クロージャがクローンされたとき、それはダイナミックスコープに存在した。

もしそれであるなら、クロージャから戻ることは非合法だRoutine もう1呼び出しフレームで現在の呼び出しスタックを所有しない。

（dynamical 呼び出し側に）何からでも値を pointy ブロックあるいはそのままのクロージャリターンするために、あなたはあるいはただブロックをその最終の展開式の値を返させる、あるいはあなたは使うことができるleaveそれは関数とメソッドフォーム両方で起きる。形式が一番奥のブロックから、正確にとしてブロックの最終の値としてその引数を返して常に終了する関数（あるいはリスト演算）return そうする。オブジェクトと名付けられることができる何でもダイナミックスコープでふさぐ、そしてそれが応答する形式が残すであろうメソッド.leave メソッド。

Hence, the leave 関数：

leave(1,2,3)

賛成で本当にただ短い：

&?BLOCK.leave(1,2,3)

あなたの即刻の呼び出し側から戻るために、あなたは言うことができる：

caller.leave(1,2,3)

呼び出し側スタック上がるフレームが使用までに位置を定められるかもしれないそれ以上の呼び出しcallframe 関数：

callframe({ .labels.any eq 'LINE' }).leave(1,2,3);

デフォルト、マッチしている一番奥の呼び出しフレーム、によって選択基準は終了されるだろう。これは少し扱いにくくあり得る、それでラベルの特定のケースで、現在のレキシカルスコープですでに目に見えるラベルは可能性があるダイナミックなコンテキストを指定して一種の擬似オブジェクトだと見なされる。もし上の（人たち・もの）の代わりにあなたが言うなら：

LINE.leave(1,2,3)

それは常に辞任であったからあなたレキシカルスコープなLINE たとえあなたが見ることができない若干の内部のダイナミックスコープがたまたま同じくそのラベルを持っているとしても、輪を作る。（言い換えれば、それは lexotic だ。）もしLINE 名札は目に見える、しかしあなたは実際にダイナミックスコープでそのレコード会社によってコントロールされない、例外がスローされる。（もしLINE ではないが目に見えるという状態で、それはそれ以来コンパイル時間より以前にに捕えられただろうLINE 多分 bareword だろう。）

理論上、ユーザー定義のコントロール構造が何のためにでも捕えることができる何でもそれが好きである例外をコントロールする。しかしながら、どの構造がどの例外を獲得するかについて若干の文化的に適用された標準がなければならない。極めてあたかもreturn ただ「公式の」サブルーチンから戻るかもしれないあるいはメソッド、出口のようなループnext ユーザーがそれが捕えられることを期待する構造によって捕えられるべきだ。（常にユーザーを仮定することは、もちろん、正しいことを期待する．．．）特に、もしユーザーが特定のラベルでループにラベルをはって、そしてそのループのレキシカルスコープの中から、そしてもしその呼び出しが外側ループのラベルに言及するならループ制御を呼び出すなら、その外側ループは制御されているに違いない（の・もの・人）だ。言い換えれば、それは最初にこの形式を試みる：

LINE.leave(1,2,3)

もし最新のサブルーチンにこのようなどのレキシカルスコープな外のループもないなら、次候補検索が Perl 5 がする同じような動的有効範囲を通して外へされる。（ただ Perl 5 がユーザー定義の制御構造を持っていなかったから、 Perl 5 と Perl 6 の間の差はこの点に関して生ずる、従って sub のレキシカルスコープは常に一番奥のダイナミックスコープだった、それで現在の sub でのレキシカルスコープに対する優先は暗示的だった。 Perl 6 のために我々は lexotic 振る舞いに対するこの優先を明示的にしなければならない。）

警告が、通り過ぎて供給されなくちゃならない例外から履歴書継続を抽出することによって、デフォルトによって警告をプリントして、そして例外を再開する最も外側のスコープの resumable コントロールの例外をスローすることによって、 Perl 6 に作り出されているwarn() 関数（あるいは匹敵するもの）。例外オブジェクトがそうしないなら、例外が Perl 6 に resumable じゃないResumable ロール。（型がすることができるその致命的な例外に注意するResumable もしスローされるならさえロールとしてfail()－ uncaught それらがただ最も外側の警告調教師の代わりに最も外側の致命的な調教師をぶったとき、それほどいくらか内部の範囲が明示的にそれらを警告として扱って、そしてそれらを再開しなければならない。）

警告が標準的なコントロール例外メカニズムを使って処理されるから、それらが途中で捕えられるかもしれない、そして通り過ぎてダイナミックスコープ以内を隠すか、あるいはどこでも fatalized した供給すること適切CONTROL ブロック。この動的制御は呼び出しにか否かにかかわらずレキシカルスコープなただ決定するコントロールに警告している何にでも無関係だwarn() 第一に。

呼び出しと同じようにそうするためにreturnコンパイラあるいはランタイムが意味規則が、ただエラーをプリントアウトして、そして先へ進むことによって、維持されるであろうことを決めることができるとき、離れて（関連づけられた継続とともに）最適化するコンパイラが無料であるというコントロールの例外が抽象概念であるという警告。例外ハンドラが減量する投げの、ダイナミックスコープでただ戻ることを含むすべてからwarn 最もその時の関数。キャッチラムダから戻る方法のディスカッションのために前のセクションを見ろ。コントロールラムダは論理的にキャッチラムダから独立している、実装が結束することを許されるけれども、もしそれが注意深いなら維持するべきそれらがキャッチとコントロールの例外のために意味規則を分離する。

goto文

加えるにそうするためにnextlastそしてredo6が同じくサポートする Perl goto. 　普通のループ制御と同じように、ラベルは最初にレキシカルに最新のサブルーチンの中で、それから動的にそれの外で検索される。しかしながら、ループ制御と異なり、スコープを走査することは現在の候補の中で含まれているレキシカルスコープがスコープ宣言する何のスキャンでも含む。 Perl 5 のように、そうすることは可能だgoto レキシカルスコープの中に、しかしただパラメータの特別でない初期化を必要とするレキシカルスコープのために。（普通の変数の Initialization が重要でない－多分ラベルの存在はラベルを超えてコード動き最適化を防ぐだろう。）それで、例えば、そうすることは常に可能だgoto 次のケースにのwhen あるいはいずれかの中に条件文の「それから」あるいは「ほかに」ブランチ。あなたは行かないかもしれない中にgiven あるいはforけれども、なぜならそれは仮引数バインディングを迂回するだろう（事例でリスト世代に言及しないためにのfor）. （暗黙の（人たち・もの）が結び付いて義務を怠るメモ：外$_ そうすること内部$_ それが正式のバインディングを迂回することに対する禁止令の下にないように、そのままのブロックで模倣されることができる。）

なぜなら演算を求めているレコード会社に行くことは可能だから、そしてなぜなら Perl 6 はパスしている1パス、何でもするからgoto まだ宣言されなかったラベルに（あるいは外見上のレキシカルスコープの外（に・で）宣言されるのgoto）ラベルをクォートに同封しなくちゃならない.

例外

Perl 5 のように、多くの組込み関数が、レンジから、ただあなたが値を求める未定義の値を返す、あるいは関数はどうにかして失敗する。 6が持っている Perl Failure それらが扱われたかどうか知っている「スローされない例外」として知られているオブジェクト。 $! lastest 失敗への都合が良いリンクであって、そしてただ今までで最も最近の1つの例外を含む。

［推測：ルーチンの中の unhandledな例外が記憶されることができたすべて@!最も最近のもので最初に。 $! それで賛成の構文糖だろう@![0]. 　（あるいは我々は推薦意味規則を使うそして$! 手段@![*-1].）これはただ製造だけよりいっそうたくましいかもしれない@! CATCH へのパラメータ。しかしながら、撃沈が Failure を食べるとき、自動的に投げることについての新しい意味規則は我々がブロックもう扱われた指定期間の末であるためにぶらぶらして待って多くのスローされない例外を持っていないであろうことを意味する。けれども、我々は、もし GC が最終的に決して扱われなかった失敗を集めるなら、おそらく少なくとも警告を公表するべきだ。我々は本当に「ルーチンの終わり」クリーンアップが、我々が語彙のオーバーヘッドで行かない限り、標準のデータとして返される失敗を取り扱うことを当てにすることができない@! 変数。］

もしあなたがテストをするならFailure 賛成だ.defined あるいは.BoolFailure その後、それ自身扱われるように；例外法令に比較的無害な未定義の値であるという記録を残す。他のいかなる使用でものFailure 標準の値を引き抜くオブジェクトがすぐにその関連づけられた例外をスローするだろう。（Failure しかしながら、その型が許すどんなコンテナででも記憶されるかもしれないFailure 混ぜられるロール。） .handled メソッド帰りFalse 扱われなかった失敗に関して。それは戻るTrue 扱われた例外のためにそしてすべての非－のためにFailure オブジェクト。（すなわち、それはそうだMu メソッド、そうじゃないFailure メソッド。それ以外の何ものでもなくFailure オブジェクトがしかしながら実際のステータスを記憶する必要がある；他の型がただ戻るTrue.）

.handled メソッドがそうだrwあなたが、割り当てることによって、扱われるように、例外を記録を残すかもしれないようにTrue それに。注意するしかしながらそれ

$!.handled = 1;

扱われるように、ただ最後の例外だけを記録を残す。マークそれらにすべて扱われるように、あなたは個々に CATCH ブロックの暗黙のループとしてのそれらにアクセスしなくちゃならない。

A bare die/ fail 撮影$! スローされるか、あるいは呼び出し側のに外へ普及させられるために例外を指定しているデフォルト引数として$!.

権限：が失敗使用方法の上にビルトインを自動的に例外をスローさせる

use fatal;

fail 関数が呼び出し側のに応答するuse fatal ステート。それはスローされない例外を返すか、あるいは例外をスローする。あなたがこのプラグマについてあまりにも満足する前に、 Perl 6 がスローされた例外によって早々に爆破される傾向があるであろう種々の並列処理プリミティブを限定することに注意を払え。スローされない例外は、完全に効力がある並列計算であるかもしれないことの実行を中止しないで、失敗がデータとして取り扱われて、そして1つずつ取り扱われることができるフェイルソフトメカニズムを供給することを意図されている。もしあなたがデータとして失敗を取り扱わないなら、流しコンテキストが自動的に unhandled されて何でもスローするだろうFailure あなたが手札を捨てようとすること。

何でも場合、ここのオーバーライドしている設計原理は unhandledな例外が今までに床にドロップされて、しかし、それが扱われるまで、外へ普及させられないということだ。ない場合明示操作子がそれを扱う、と暗示的な最も外側の例外ハンドラが最終的に停止に決定するだろうそしてすべての unhandledな例外がその流れとしてパスした印刷@! 傾け。

Phasers

ACATCH ブロックは適切な瞬間にそれを含んでいるただクロージャのトレイトであって、そして自動的に呼び出される。これらのオート－呼び出されて、ブロックはフェーザとして知られていて、それらから一般に、計算の1つの段階からもう1つまで政権移行期間を記録を残す。例えば、CHECK ブロックがコンパイル単位をコンパイルしている指定期間の末と呼び出される。他の種類のフェーザが同様にインストールされ得る；これらは適切に自動的に種々の時に呼び出される、そしてそれらのいくらかが種々のコントロールの例外に返答する、そして値を終了しろ：

  BEGIN {...}*      at compile time, ASAP, only ever runs once
  CHECK {...}*      at compile time, ALAP, only ever runs once
   INIT {...}*      at run time, ASAP, only ever runs once
    END {...}       at run time, ALAP, only ever runs once

  START {...}*      on first ever execution, once per closure clone

  ENTER {...}*      at every block entry time, repeats on loop blocks.
  LEAVE {...}       at every block exit time (even stack unwinds from exceptions)
   KEEP {...}       at every successful block exit, part of LEAVE queue
   UNDO {...}       at every unsuccessful block exit, part of LEAVE queue

  FIRST {...}*      at loop initialization time, before any ENTER
   NEXT {...}       at loop continuation time, before any LEAVE
   LAST {...}       at loop termination time, after any LEAVE

    PRE {...}       assert precondition at every block entry, before ENTER
   POST {...}       assert postcondition at every block exit, after LEAVE

  CATCH {...}       catch exceptions, before LEAVE
CONTROL {...}       catch control exceptions, before LEAVE

記録されているそれらで* 同じく展開式の中で使われることができる：

my $compiletime = BEGIN { now };
our $temphandle = START { maketemp() };

他の文接頭辞で、これらの値を生産する構造がブロックあるいは文の前（に・で）置かれるかもしれない（とき・から・につれて・ように）：

my $compiletime = BEGIN now;
our $temphandle = START maketemp();

実際、これらのフェーザの大部分がブロックあるいは（方言で爆発として知られている）文をとるだろう。文形態はブロック以内にそれを「捕えな」いで周囲のレキシカルスコープにレキシカルにスコープ宣言された宣言をさらすために特に有用であり得る。

従ってこれらは前の例と同じスコープで同じ変数を宣言するが、示された時間での文全体を動かす：

BEGIN my $compiletime = now;
START our $temphandle = maketemp();

（注意しろ、しかしながら、変数の値がコンパイル時間に計算したことはクロージャを取り巻いている何の実行時クローニングの下でも固執しないかもしれない。）

非値を生産するフェーザの大部分が同じくそれほど使われるかもしれない：

END say my $accumulator;

しかしながら、注意しろ、それ

END say my $accumulator = 0;

変数を0にセットすでEND それがいつかであるときからの時間宣言が実際にそうである "my" が実行した. ただ引数のないフェーザだけが文形式を使うかもしれない。これはそれを意味するCATCH そしてCONTROL 常にブロックを必要として、それらから沈む引数を要する$_ 現在のトピックに内臓が性質を有することが可能であるようにスイッチ文。（そのままの文が許可された、仮製本であったもし$_ 終わりを過ぎて漏れだすだろうのCATCH あるいはCONTROL予想できない、そして非常に多分緊急の結果で。例外調教師は不確実を減らして、それを増やさないはずだ。）

ランタイムに生成されるコードが離れてまだ発砲することができるCHECK そしてINIT フェーザ、しかしもちろんそれらのフェーザは時間に戻って旅行を必要とするであろうことをすることができない。あなたはそれのために wormhole を必要とする。

これらのフェーザの若干が同じく変数にけしかけられることができる対応するトレイトを持っている。これらはクロージャの中に問題の変数をそのトピックとしてパスするという長所を持っている：

my $r will start { .set_random_seed() };
our $h will enter { .rememberit() } will undo { .forgetit() };

別としてCATCH そしてCONTROLそれはただ1度起こることができるだけだ、これらの大部分がブロックの中で何度も起こることができる。（彼・それ）らが（彼・それ）ら自身本当に、正確に、トレイト－それらが付け加えるということじゃないようにリストに実際のトレイトに記憶される（賛成であるを除いて、STARTそれはインラインを実行する）. もしあなたが調査するならそうENTER トレイトブロックの終了、あなたはそれが一つの移相器よりむしろ本当にフェーザのリストであることに気付くだろう。一般に、 initalizing フェーザが順に宣言を実行する、他方完成させているフェーザが反対の命令で実行する。

意味規則のINIT そしてSTART クローンされたクロージャに関してはお互いと等しくない。 INIT ただかつてクローンされたクロージャのすべてのコピーのために走るだけだ。 ASTART 別にそれぞれのクローンのために走る、それでもし生活費がステート変数を分離するならクローンを分離しろ：

our $i = 0;
...
$func = { state $x will start { $x = $i++ }; dostuff($i) };

ただstate 自動的に初期化演算子が、それほどこれほど同じくもたらす何までの「スタート」意味規則も応用する：

$func = { state $x = $i++; dostuff($i) }

それぞれの次のクローンが前のものとそれぞれのクローンがそれ自身のステートを維持するより高く1（人・つ）である最初のステートを得る$xそれが何かであるからstate 変数がそうする。

クロージャクローニングがないのでさえ、INIT 主回線コードの前に走る、他方START 投げが最後の可能な瞬間が、それから1度正確に走って、そしてすべての次の呼び出しのためにその値をキャッシュするまで初期化から離れている（それがどちらのケースに、流しコンテキストで、呼び出されなかったと想定するSTART かつてその副作用だけのために診断される）. 特に、これはそれを意味するSTART パラメータが、最初の呼び出しに、パスした何でも利用することができるのに対してINIT そうすることができない。

これらすべての移相器ブロックは前に、たとえそれらの変数が詳述されなかったとしても、それでもなおクロージャが訴えられるとき、語彙の変数だと宣言された何か（変数が未定義にどのケースを評価するかについて値。）を見ることができる

注意しろ：4が概念を混乱させた Apocalypse PRE/ POST でENTER/ LEAVE. 　これらは今別個の概念だ。 ENTER そしてLEAVE それら副作用のためにだけ使われる。 PRE そしてPOST 契約（DBC）ルールによっていつもの Design によれば、評価されるブール値を返さなくちゃならない。（そして、もしあなたが使うならENTER/ LEAVE クラスブロックで、クラスブロックが制作されるとき、それらがただ実行するだけだ、しかしあなたは宣言してもよいPRE/ POST クラスですべてのメソッドの周りに評価されるであろうクラスブロックの submethods 。） KEEP そしてUNDO ただ変形であrnoLEAVEそして処刑命令のために列の一部として扱われのLEAVE フェーザ。

FIRSTNEXTそしてLAST ただループのレキシカルスコープの中で有意義であって、そしてただこのようなループブロックのトップのレベルで起こるかもしれない。 ANEXT ただもしループブロックの終わりが通常達せられるなら、実行するあるいは明示next 実行される。特質でそうするためにLEAVE フェーザ、NEXT もしループブロックが出られるなら、実行された移相器ではないが通り過ぎてスローされたコントロールの例外以外のどんな例外としてでものnext. 　詳細、でlast 評価を回避すのNEXT フェーザ。

［注意しろ：名前FIRST 使ったから結び付けられろstate 宣言。今それはループとだけ結び付けられる。見るSTART 上に賛成かstate 意味規則。］

賛成であるを除いて、CATCH そしてCONTROL 例外がフェーザが呼び出し山がそうであるまで待つ、すべてブロックを残すそれを扱う場所を探している間に、走るフェーザが走るために実際にくつろいだ。くつろぐことは、若干の例外ハンドラがただそのように例外を扱うことに決める後になるまで、起きる。すなわち、ただ例外が通り越してスローされるからといって、スタックフレームが、例外が resumable であるかもしれないから、我々が公式にまだブロックを残したことを意味しない。何ででも、例外が resumable か否かにかかわらず、収納ケース、例外ハンドラが衰えるコードのダイナミックスコープの中で走るために指定される。山はほどかれる、そして、例外ではないが再開した場合に限り、フェーザは呼び出される。

それでLEAVE 所定のブロックのためのフェーザが何の後にでも必ず評価されるCATCH そしてCONTROL フェーザ。これは含むLEAVE 変形、KEEP そしてUNDO. POST フェーザがそれが互角であると保証するために、他のすべての後に評価されるLEAVE フェーザが DBC に違反することができない。同じくPRE フェーザが前に何でも発するENTER あるいはFIRST （前にではなくけれどもBEGINCHECKあるいはINITそれらがコンパイルあるいはプロセス初期化時間にされるから）. 極めてあたかもBUILD そしてDESTROY 通り過ぎて正しい順に呼び出されて暗黙のうちにだBUILDALL そしてDESTROYALLPRE/ POST 呼び出しは暗黙としてだCALL-VIA-DBC 実際の呼び出しの外（に・で）問題のメソッドに走るメソッド。クラスレベルPRE/ POST submethods が観念的にメソッド - レベルの外にあるPRE/ POST ブロック。ものの標準のコースで、CALL-VIA-DBC これらのステップに従う：

1. create an empty stack for scheduling postcalls.
2. call all the appropriate per-class C<PRE> submethods,
    pushing any corresponding C<POST> onto the postcall stack.
3. call all the appropriate per-method C<PRE> phasers,
    pushing any corresponding C<POST> onto the postcall stack.
4. enforce DBC logic of C<PRE> calls
5. call the method call itself, capturing return/unwind status.
6. pop and call every C<POST> on the postcall stack.
7. enforce DBC logic of C<POST> calls
8. continue with the return or unwind.

ステップ2と3で、それに注意するPOST ブロックが2つの方法の1つで定義されることができる。あるいは文通することPOST どちらのケースに、別個の宣言（2のためのサブメソッド、3のための移相器）として、定義されるPRE そしてPOST レキシカルスコープを共有するな。交互に、何もPRE （サブメソッドあるいは移相器）がそれが対応することを明確にするかもしれないPOST それがレキシカルスコープを包み込む埋め込みの移相器ブロックとしてPRE. 　どちらの場合も、コードは適切な瞬間に走らせられるために postphaser 山の上に押しやられる。

もし出口フェーザがスタックの結果として走っているなら、例外によって始められてほぐれ去れ、この情報は提供される必要がある。何かで場合、ブロックが成功裏に出られているか、あるいは失敗して走るべきかどうか決めるためにアクセス可能である必要があるかどうかについての情報KEEP あるいはUNDO ブロック。この情報が提供される方法は実装依存だ。

スローされた例外からENTER 移相器が中断するだろうENTER スローされた列、しかし人からLEAVE 移相器がそうしないだろう。例外が、失敗することによって、スローされるPRE そしてPOST フェーザが通り過ぎて捕えられることができないCATCH それを暗示する同じブロックでPOST 移相器が失点もしじゃないPRE 移相器が失敗する。

もしPOST 失敗あるいは何もまあLEAVE 山がほどけている間に、ブロックが例外をスローする、くつろぐことは扱われるために例外を続けて、そして集める。くつろぐことが完了されるとき、すべての新しい例外はそのポイントからスローされる。

フェーザのためにそんなものけれどもKEEP そしてPOST 通常スコープを終了すること、その範囲からの返値（もし何も）が移相器の中で現在のトピックとして利用可能であるとき、動かされる. （それはリストで唯一の区画あるいは立つことができるオブジェクトとして引数、すなわち、いずれかとして提示される。言い換えれば、それは正確に何かだreturn 移相器が早々に偶然にコンテキストを課さないように、生の形式で外の世界に注文している。）

移相器がまだ入手可能な外のブロックのトピックOUTER::<$_>. 　帰りの値が modifiable かどうかが問題の移相器のポリシーであるかもしれない。特に、帰りの値は中で修正されるべきじゃないPOST ただ、移相器LEAVE 移相器はいっそう自由主義であり得た。

クラスレベルPRE そしてPOST submethods がメソッドのレキシカルスコープにいない（そしてメソッドのダイナミックスコープに掲載されない）、それでそれらがメソッドのを見ることができない$_ まったく。メソッドとして、それらが流れへのアクセスを持っているselfもちろん。そしてPOST 出口フェーザがそうするのとちょうど同じように、サブメソッドが帰りの値をトピックとして手に入れる。

メソッドのレキシカルスコープで定義された移相器が上に閉じるクロージャである Any self 標準の語彙と同様。（あるいは等しく、実装がただすべてのそのようなフェーザをそのカリー化されたインボカントが現在のオブジェクトである submethods に変えるかもしれない。）

文が解析をする

この文で：

given EXPR {
    when EXPR { ... }
    when EXPR { ... }
    ...
}

括弧は周りに必要じゃないEXPR なぜなら中間の空白文字EXPR そしてブロックはブロックを強制する、そうであることは見なした、ブロックが添え字よりむしろ、供給した、ブロックはインフィックス演算子が期待されるであろうところ（に・で）起こる。これは Perl 6 に、新しいものだけじゃなく、すべての制御構造で働く。もし項があるならトップレベルのそのままのブロックが文ブロック常に評価されている、そしてスペースがそれの前にだ：

if $foo { ... }
elsif $bar { ... }
else { ... }
while $more { ... }
for 1..10 { ... }

終わりの括弧と左中括弧の間にスペースがある限り、権限：が古い時のためにまだ展開式引数を括弧で括る。（さもなければそれはハッシュ添え字と解析されるだろう。）

リスト演算子が、あなたがブロックに項の後に現われることを強いるために引数リストを括弧で括らなくちゃならないほどもしあなたが0の引数を意味するなら、とっているパーサーがいくつの引数を直感で知ることができないというノート：

if caller {...}    # WRONG, parsed as caller({...})
if caller() {...}  # okay
if (caller) {...}  # okay

けれども期待されるように、共通慣用句がうまくいくことに注意を払え：

for map { $^a + 1 }, @list { .say }

あなたがブロック引数を期待する文を解析している、そのままのクロージャを使うことは非合法じゃないなら、それがそうであるであろうから、演算子が期待されるところは見なした、から列で2つの項であれ。（もしあなたがそれが後置接周辞であることを望むなら、空白文字を取り去れ。）

どこでも項が期待される、ブロックがクロージャ定義（匿名のサブルーチン）であるためにとられる。もしクロージャが引数を持っているなら、それは常に標準のクロージャと考えられる。（スタンダード仮パラメータのほかに、プレースホルダー引数が同じく数える、そしてアンダースコア変数もそうする。暗黙の用途の$_ で.method 同じく引数として扱われる。）

どんなに、もし引数のないクロージャが空であるか、あるいは1対あるいはハッシュから始める（一つのペアあるいはリストとしてのハッシュが1つの要素の（こと・もの）であると考える）コンマによって分離されたリスト以外の何も含んでいないように思われないなら、呼び出されるかのように、クロージャがすぐにハッシュ生成するものとして実行されるであろうとしてもで.().

$hash = { };
$hash = { %stuff };
$hash = { "a" => 1 };
$hash = { "a" => 1, $b, $c, %stuff, @nonsense };

$code = { %_ };                            # use of %_
$code = { "a" => $_ };                     # use of $_
$code = { "a" => 1, $b, $c, %stuff, @_ };  # use of @_
$code = { ; };
$code = { @stuff };
$code = { "a", 1 };
$code = { "a" => 1, $b, $c ==> print };

もしあなたがそれほどあいまいであらないことを望むなら、hash リスト演算子が明示的にリストを評価して、そして返送された値のハッシュを構成するだろう、他方sub あるいは-> 匿名のサブルーチンを開始する：

$code = -> { "a" => 1 };
$code = sub { "a" => 1 };
$hash = hash("a" => 1);
$hash = hash("a", 1);

中にそれほどクロージャ的に注意するmap 決して、このようなクロージャが常に（アンダースコア変数を含めて）引数とプレースホルダーの使用をとるときからのハッシュが引数の証拠と思われる（とき・から・につれて・ように）、解釈されないだろう。

もしクロージャがドット演算子の右の引数であるなら、クロージャはハッシュ添え字として解釈される。

$code = {$x};       # closure because term expected
if $term{$x}        # subscript because postfix expected
if $term {$x}       # expression followed by statement block
if $term.{$x}       # valid subscript with dot
if $term\  {$x}     # valid subscript with "unspace"

類似のルールが配列添え字に適用される：

$array = [$x];      # array composer because term expected
if $term[$x]        # subscript because postfix expected
if $term [$x]       # syntax error (two terms in a row)
if $term.[$x]       # valid subscript with dot
if $term\  [$x]     # valid subscript with "unspace"

そして関数引数を区切っている括弧に：

$scalar = ($x);     # grouping parens because term expected
if $term($x)        # function call because operator expected
if $term ($x)       # syntax error (two terms in a row)
if $term.($x)       # valid function call with explicit dot deref
if $term\  .($x)    # valid function call with "unspace" and dot

何の外ででも展開式括弧について親切で、あなたがそれの後にセミコロンを置いたか否かにかかわらず、ラインで（空白文字あるいはコメントを計算に入れないで）カール状の最終の閉鎖が常にセミコロンの優先に逆戻りする。（明白なセミコロン、文が次のラインで続けるかもしれない、しかしただ正当な文でそんなものを continuators する流れがないときにはelse それは新しい文の始まりと混同されることができない。文修飾子のような、他の何も（上に、例えばloop 文）改行が「unspace」構造を使ってエスケープされて－ S02 を見ない限り、同じラインに続くに違いない。）

文レベル構造の上の最終のブロックがその後カール状の取引完了のポジションにかかわらず常にセミコロン優先を暗示する。構造が、宣言されることによって、文法で著名な文レベルstatement_control カテゴリー：

macro statement_control:<if> ($expr, &ifblock) {...}
macro statement_control:<while> ($expr, &whileblock) {...}
macro statement_control:<BEGIN> (&beginblock) {...}

文レベル構造がただパーサーが文のスタートを期待しているところだけを始めるかもしれない。文をあなたが何かを使わなくちゃならない展開式に埋めるためにdo {...} あるいはtry {...}.

$x =  do { given $foo { when 1 {2} when 3 {4} } } + $bar;
$x = try { given $foo { when 1 {2} when 3 {4} } } + $bar;

存在のstatement_control:<BEGIN> 同じく定義することから我々を排斥するprefix:<BEGIN> それは展開式の中で使われることができる：

macro prefix:<BEGIN> (&beginblock) { beginblock().repr }

それからあなたはものが好むと言うことができる：

$recompile_by = BEGIN { time } + $expiration_time;

ただstatement_control:<BEGIN> 隠れるprefix:<BEGIN> 文のスタートで。あなたは同じく考えられるところではそうすることができた定義するprefix:<if>、それからあなた以外あなたが言うとき、あなたが欲するものを手に入れないかもしれない：

die if $foo;

それ以来prefix:<if> 隠れるだろうstatement_modifier:<if>.

組込み文レベルキーワードが、終わっている何でも輪を作る前にと同様、キーワードと最初の引数の間に空白文字を必要とする。特に、構文エラーがこれらのようなC - isms のために報告されるだろう：

if(...) {...}
while(...) {...}
for(...) {...}

成功の定義

仮説の変数はいくぶん transactional －それらが現在ブロックの成功した辞任でだけそれらを新しい値にしておくということであって、そしてさもなければ（彼・それ）らのオリジナルの値に開けられる。

例外をとらえた後で、定義された値を返すことは問題がないけれども、エラーの例外を普及させることによって、ブロックを残すことは、もちろん、失敗だ。

エラー例外普及がないので、上出来の出口が定義された値あるいは区画を返す（の・もの・人）だ。（定義された区画が未定義の値を含んでいるかもしれない。）それで Perl 6 関数が言うことができる何も

fail "message";

そして項目あるいはリストコンテキストで関数が呼び出されているかどうかに関して気を使わない。明示的なスカラー undef を返すために、あなたは常に言うことができる

return Mu;          # like "return undef" in Perl 5

それからリストコンテキストで、あなたは（Perl 5 においてとほとんど同じように）定義される長さ1のリストを返している。けれども一般にあなたは使っているべきだfail このような場合例外をオブジェクトリターンするために。スローされない例外を返している場合が見地から失敗だと見なされる何ででもlet. 　正規表現でクロージャにわたってバックトラックすることは同じくクロージャの失敗だと見なされる、そしてそれは仮説の変数がどのように正規表現によって管理されるかだ。（そして上に使用フリップ側のfail 正規表現の中でクロージャが正規表現についてバックトラックし始める。）

いつがクロージャではなく、クロージャか

すべてが Perl 6 に概念的にクロージャだ、しかしオプティマイザは unreferencedなクロージャをコードの単なるブロックに変えることが自由だ。もしブロックが（彼・それ）ら自身クローンされるべきである外部の語彙に何も紹介しないなら、それは参照されたクロージャを単なる匿名のサブルーチンに変えるために同じく自由だ。（我々が「クローン」と言うとき、我々がシステムがルーチンのレキシカルスコープのスナップショットをとって、そして、それもしあなたがルーチンに今までに現在の参照を使うように、ルーチンの現在のインスタンスにそれをバインドするように意味する、それはそれを使って見える語彙のシンボルに関してその世界の現在のスナップショットを得る。）

それらを含んでいるレキシカルスコープが入られるとすぐに、すべての残っているブロックはクロージャの中に概念的に複製される。（長い間一貫した意味規則として維持されているように、これはいい加減にされるかもしれない、それで決して実行されなくて、そして決して参照がとられるようにしないブロックがまったくクローン生成を避けることができる。実行あるいは参照をとることがこの場合クローニングを強制する－参照がいい加減にクローンされることを可能にされない、どんな保証もそれにされることができないから、クローン生成のために必要なスコープは参照の人生にわたって残存しているだろう。）

特に、パッケージサブルーチンが、変わっているレキシカルスコープで（それらがそれに参照をするとき）埋め込みであるとき、特別な問題だ。シンボルテーブルの中の名前へのこのような定義のバインディングは参照を魅力的であるとみなす、それでコンパイル時間に問題のシンボルテーブル項目に最初のバインディングがある。「グローバル」バインディングの間コンパイル時間に目に見える記号テーブルに、これはコンパイル時にレキシカルスコープのビューをバインドする。（実行時において、最初の実行時ビューはこれらのスコープについてコンパイラのそれらのビューからコピーされる、それで初期化が例えば、上に、振る舞う。）ランタイムに、このようなサブルーチンが複製されるとき、さらにバインディングがオリジナルの（人たち・もの）が境界であった同じシンボルテーブル項目にクローン時間にされる。（現在のレキシカルスコープから辞任で復元されたバインディングではない；このバインディングは、現在用いられてを複製する（人たち・もの）ではなく、最後のクローニングを記録する、それでグローバルな参照のどんな使用でもそれが現在のレキシカルスコープのために、代理としてではなく、最も最近のクローン生成のキャッシュとしてだけ機能していることを考慮に入れなくちゃならない。）

もし問題のパッケージがレキシカルに明確であるなら、問題はいっそう複雑だ。このような場合、それが対応するレキシカルスコープの項目の上に sub であるかのように、パッケージは複製されなくちゃならない。一つのパッケージのすべてのランタイムのインスタンスは宣言共用、コンパイル時の同じセット、が関数だと宣言した、しかしながら、前段で記述されるように、ランタイムインスタンスは異なった語彙の環境を持っていることができる。もし sub の多数の相いれない定義が同じコンパイル時パッケージのために存在するなら、誤り状態が存在する、そして振る舞いではないが Perl のために6.0を指定した。

クラスでのメソッドが機能上パッケージサブルーチンのように振る舞って、そして、もしクラスがクローンされるなら、同じバインディング振る舞いを持っている。さらに、それほどクラス宣言的に注意する増大させろ、基本的にコンパイル時演算；作曲がただ1度起きるだけである、そして結果がプロトタイプのクラスでレコーディングされるということである. 類型学の扱いが再取付けすることに限定されているランタイムOUTER:: メソッドのスコープ。

シンボルが同時にその使用で範囲から出て行くから、語彙の名前がこの問題を共有しない。グローバルな sub と異なり、それらがコンパイル時バインディングを必要としないが、グローバルな sub が好きだ、それらがクローン時間に語彙のシンボルにバインディングを実行する（再び、概念的に外のレキシカルスコープの項目において、しかし多分延期された）

sub foo {
    # conceptual cloning happens to both blocks below
    my $x = 1;
    my sub bar { print $x }         # already conceptualy cloned, but can be lazily deferred
    my &baz := { bar(); print $x }; # block is cloned immediately, forcing cloning of bar
    my $code = &bar;                # this would also force bar to be cloned
    return &baz;
}

特に、呼び出されるまで、インラインの制御流れのブロックが複製される必要がない。［注意しろ：これは現在ユーザー定義の構造のための潜在的な問題そしてあなたがパスするために参照をブロックに持って行かなければならないから制御流れを処理しているものは何へのそれらもだ。多分怠惰は完全に延期され得るCaptureバインディングタイムへのs、そうだブロック審判員について素晴らしいすべて早々にそれらをクローンする. これほど同様、他方の手段Capture それがクローンメーカーにインフォメーションをパスすることができるように、それが来たレキシカルスコープを記録・追跡するのに十分頭が良いければならない、あるいはそれは我々がいい加減にインフォメーションを振る舞うことができる若干の特別な太ったもう－クローンされ－ない参照を必要とすることを意味する。いずれのアプローチもきれいじゃない。］

若干のクロージャが生産するBlock 複製されることができないコンパイル時間に、実際にそれらを複製することができるそれらがランタイムコードにかけられないからオブジェクト。 BEGINCHECKINITそしてEND ブロックがこのカテゴリーに分類される。そのために、たとえそれらがスコープにあるように思われるとしても、あなたはこれらのクロージャから確実に実行時変数に言及することができない。（コンパイル時クロージャはそうするかもしれない、実際、変数の何らかの種類の永久のコピー若干の記憶域のために、クロージャがいずれにしても走らせられるとき、クラス、しかし変数が未定義である可能性が高いのを見ろ。）このようなルーチンからパッケージ変数とファイルによってスコープ宣言された語彙に言及することはただ安全なだけだ。

他方、それは必要とされるそれCATCH そしてLEAVE ブロックは（彼・それ）らの現在のレキシカルスコープの中に一時の変数を見ることが可能だ、それらクローニングステータスが依存するように、少なくともブロックそれらのクローニングステータスの上にインチがある。