Synopsis 6：サブルーチン

Damian Conway <damian@conway.org>
Allison Randal <al@shadowed.net>
Larry Wall <larry@wall.org>
Daniel Ruoso <daniel@ruoso.com>
 

Created: 21 Mar 2003

Last Modified: 9 Jul 2011
Version: 151
 

このドキュメントはサブルーチンをカバーする Apocalypse 6と新しい型システムを要約する。

Routine すべてのキーワードによって宣言されたコードブロックの親の型だ。 ルーチンが未定義の値を持って生まれるすべて$_$!そして$/ルーチンがさもなければ明示的にそれらを宣言しない限り。 コンパイル単位が同じくルーチンだと見なされる、あるいはあなたは参照に有能じゃないだろう$! あるいは$/ それらで。 （非ルーチンのコードBlock宣言されたsで-> あるいはそのままのカーリーで、それ以外の何ものでもなく生まれるで$_それは、パラメータとしてバインドされないなら、その OUTER:: <$_>に aliased される。 一般にブロックが使う$! そして$/ ルーチンを囲んでいる、一番奥の（人たち・もの）によって定義しなかったなら$! あるいは$/ 明示的にブロックに宣言される。 thunk が新しい変数を宣言するためにスコープを持っていないこと以外、条件付きの thunk が同じルールに従う。 どんなにそれほど何も的であるとしても、注意するそしてブロックベースであるか、あるいは thunk ベースかにかかわらず、ギャザーあるいは async のようなすべてのいい加減な構造あるいは==> （彼・それ）ら自身のものを宣言するべきだ$/ そして$! それらの変数のためのユーザーの値が asyncronously に打ち負かされることができないように。 そしてこの parentheticl 発言は深刻に置き忘れられ始めている・・・。）

サブルーチン（キーワード：sub）パラメーターリストを持っている非 inheritable ルーチンである.

メソッド（キーワード：method）常に（それらインボカントとして知られている）関連づけられたオブジェクトを持って、そして特定の種類あるいはクラスに属する inheritable ルーチンである.

Submethods （キーワード：submethod）メソッドとしてふりをする非 inheritable メソッド、あるいはサブルーチンである. それらがインボカントを持って、そして特定の種類あるいはクラスに属する。

正規表現（キーワード：regex）マッチしているパターンを実行する（文法の）メソッドである. （彼・それ）らの関連づけられたブロックは特別な構文を持っている（Synopsis 5参照）。 （我々は同じく匿名の伝統的な形式のパターンのために項「正規表現」を使う。）

トークン（キーワード：token）（デフォルトまでに）非 - バックトラックして低レベルを実行する正規表現はマッチしているパターンである.

ルール（キーワード：rule）非後戻り法（デフォルトまでに）マッチしているパターンを実行する（そして同じくルールが空白文字 dwimmery をすることができるようにする）正規表現である.

マクロ（キーワード：macro）その呼び出しが（彼・それ）らがそうであるように同じぐらいまもなく実行するルーチンが（すなわちコンパイル時において）解析される. マクロがもう1つのソースコード文字列あるいは解析樹を返すかもしれない。

Multis （キーワード：multi）同一名を共有する多数の変形を持つことができるルーチン、選択方法 arity 、型、あるいは若干の他の制約である.

プロトタイプ（キーワード：proto）スコープでその名前のすべての multis によって共有される（parameter name 、安定性と結合性のような）共通性を指定すのproto 宣言。 Aproto 同じく暗黙を加えるmulti そのスコープの中のすべての同じ短い名前の定常課程に、それらじゃないなら、明白な修飾子を持っていろ。 （規則集合に付け加えるとき、あるいはロールから相いれないメソッドを構成しようと試みるとき、これは特に有用だ。） Abstractly, the proto ディスパッチの周りのノーブランドの包み紙がそうするはずであるmultis．。 それぞれproto 異なった候補者リストを必要とするそれぞれのスコープのために実際の配車係の中に instantianted される。

ただ（キーワード：only）定常課程が他のルーチンとそれらショートネームを共有しない. これはすべての定常課程のためにデフォルト修飾子だ、ならproto 同一名についてすでに範囲にあった。 （sub 、支配することのためにproto それほど、同じファイルに宣言されたに違いないproto 明示的に輸入されないなら、設定あるいは他のモジュールからの宣言がこの効果を持っていない。）

修飾子キーワードが名指されたルーチンでルーチンキーワードの前に存在するかもしれない：

only sub foo {...}
proto sub foo {...}
dispatch sub foo {...}      # internal
multi sub foo {...}

only method bar {...}
proto method bar {...}
dispatch method bar {...}   # internal
multi method bar {...}
 

もしルーチンキーワードが省略されるなら、そうすることは義務を怠るsub.

修飾子キーワードが匿名の定常課程に当てはまることができない。

Aproto そうである配車係、ユニークな候補者と一緒に範囲を与えられた何かがどちらをリストするかが中にインスタンス生成を遺贈するノーブランドdispatch ルーチン。 従ってproto 直接決して呼び出されなくて存在して、極めて好むrole インスタンスを作られたオブジェクトとして使用されることができない。

あなたが何でも呼び出すとき、多数の候補、基本的なディスパッチャーを持っているかもしれないルーチン（あるいはメソッド、あるいは規則）が本当にただ呼び出しているだけである「それ以外の何ものでもなく」代行するあるいはメソッド － しかしもし多数の候補者がいるなら見いだされるであろう "only" が本当はディスパッチャーである. これがインスタンスを作られるdispatch 常に最初に呼び出される（少なくとも要約 － これでしばしば離れて最適化されることができる）。 本質、でdispatch 正確にディスパッチされる好むonly ただ、 sub dispatch それ自身それが「管理して」いる候補者の何にでも権限を委ねるかもしれない。

それはそうであるdispatch「すべての候補のために最初に引数を調査するs責任；それが成功裏にバインドしないどんな呼び出しでもdispatch「sシグネチャーが完全に失敗する。 （そのシグネチャーは1つの帰属のコピーだ to the proto それがどちらからインスタンスを作られたか。） dispatch しかしながら、必ずしもその候補者にオリジナルのキャプチャを送らない。 positionals にバインドする引数を名指すdispatch sig がその管理された multis にすべての次の呼び出しのために positionals になるだろう。

ディスパッチはそれから見なす、呼び出し側あるいはオブジェクトの、観点からの管理された立候補者のそのリストは若干の秩序の中へのそれらをソートする、そしてディスパッチは種々のディスパッチャーのそれぞれのために定義されるように多数のディスパッチのルールに従ってそれらをソートする。 多 sub に関しては、候補者リストはコンパイル時間に知られている。 マルチメソッドに関しては、何がだいたい継承ツリーをとき、知られているかについて、依存して、ランタイムに候補者リストを生み出して、（あるいはよみがえらせる）ことは必要であるかもしれない。

このデフォルトディスパッチ振る舞いはオリジナルの（人たち・もの）の中で象徴されるproto シングルのブロックを含むことによって* （すなわち、「何でも」）。 従って典型的な（人たち・もの）proto ただ体を持っているだろうの{*}.

proto method bar {*}
 

（我々は使わない... なぜならそれがランタイムに失敗するだろう、そして proto が例示されるからdispatch ブロックは切り株じゃない、しかし制作されるように意図される。）

他の文が前と後に差し込まれるかもしれない{*} マルチディスパッチの前か後のキャプチャコントロールへの文：

proto foo ($a,$b) { say "Called with $a $b"; {*}; say "Returning"; }
 

（それproto 賛成でただ良いだけだmultiそれが結果を返す、それ以来、返値ではなく、副作用を持っているssayそれはあなたが欲するものじゃないかもしれない。 どのようにそれを修理するべきかについて、下を見ろ。）

構文的な形式&foo （変更されているシグネチャーなしで）決してそうすることができない参照するmulti 対象あるいはノーブランドproto. 　それはただシングルを意味するかもしれないonly あるいはdispatch それが最初に呼び出されるであろうルーチンfoo(). 　個人multisが、名詞形にシグネチャーを添えることによって、名前をつけられるかもしれない：&foo:($,$,*@).

我々はセットを示すべき上の大ざっぱに「管理された」項を使ったmulti問題のs；「管理されたセット」はいっそう正確にすべての交差点と定義されるmultisでproto「すべてと一緒のsの下方への範囲multi呼び出し側の上方へに見えるスコープを使って見えるs。 普通の定常課程のためにこれはレキシカルスコープを見下ろして、そしてレキシカルスコープを調べることを意味する。 ［これは多かれ少なかれどのようにかだmultis　すでに振る舞え。］

これが見下ろして意味するか、あるいは「セットされて管理された」継承の木の上にこの場合ですべてのメソッドの交差点に翻訳するメソッドのためにproto「sクラスあるいはすべてと一緒のそのサブクラスmulti その親クラス、すなわち、誰のかについてのオブジェクトの実際の型の親クラスでオブジェクトに見えるメソッドためメソッドは呼び出された. ［注意する、これは多方法を一つのクラスに制限した事前の多メソッドの意味規則からの変化；意味規則が定義することに等しい古いものだproto すべてのクラスでそれは多方法を持っている。 新しい方法はユーザーに混ぜるべき能力を与えるmulti異なった継承レベルでのs。

同じく、古い意味規則のproto 大部分 - デフォルトを供給するmulti 体がここにけなされる。 デフォルトmultisが記録されるべきであるで「is default」.

それはまだ省略時動作を提供することが可能であるprotoしかしながら、それを包み紙として使用することによって：

my proto sub foo (@args) {
    do-something-before(@args);
    {*}       # call into the managed set, then come back
    do-something-after(@args);
}
 

これが値を返す重要性で船尾にある － 何か － に () をする、そうじゃないmulti. 　それを回避する2つの方法がある。 ここに1つの方法がある：

my proto sub foo (@args) {
    ENTER do-something-before(@args);
    {*}
    LEAVE do-something-after(@args);
}
 

代わる代わる、あなたは何かについて規定することができる{*} 実際は次のようないずれかのディスパッチャーマクロであろう賛成の構文糖だ

my proto sub foo (|$cap (@args)) {
    do-something-before(@args);
    my |$retcap := MULTI-DISPATCH-CALLWITH(&?ROUTINE,$cap);
    do-something-after(@args);
    return |$retcap;
}
 

（希望を抱いてメモ化された）これらの引数のすべての候補を見つけて、ディスパッチのダイナミックスコープを作成して、ディスパッチを始めて、管理するインライン化された多ディスパッチャーにどちらが最適化するか（我々が希望する）callnext そしてlastcall 意味規則と帰り、結果、のどちらmulti 成功した、もし何も。

それは我々がなぜを持っているかだ{*} その代わりに。

もう1つの普通の変形が、もしこれが存在しなかったなら、見いだされたであろう外の / より高いルーチンに制御を普及させることだろう：

my proto method foo { {*}; UNDO nextsame; }  # failover to super foo
 

製造のほかに、それに注意しろmultis　お互い、新しい（人たち・もの）と同様に働けproto 意味規則が大いに決して近くにいて心配しなくてもよいトップレベルの配車係を単純化するmultis、からmultisが常に二重のディスパッチの後半にある（ただ抽象的に、1日から再びディスパッチがしばしば離れて最適化されることができる、かのようにproto インライン化された）. それで抽象的に、foo() ただ今までにシングルを呼び出すonly/ proto ルーチンと我々はそれがである1が時間をコンパイルすることを知っている。

これはすでに内部にクラスを再び急送するそれぞれのクラスに一つの proto のような何かがあると想定したメソッドディスパッチのためにそれほど移行じゃない。 ここで変化は多メソッドの配車係が現在のクラスよりいっそう広くその候補のために見る必要があるということだ。 けれども、正規表現メソッドがすでに正確に他動詞の LTM をするためにこのより大きい管理されたセットを探さなければならなかった限りにおいて、我々の意味規則が前に首尾一貫しなかったことに注意を払え。 今標準のメソッドの意味規則protosと正規表現protosはほとんど同一で、正規表現対象リストが当然最も長いトークンに関するもっとおしゃれな tiebreaking ルールをマッチしているようにするという事実を別としてだ。

Adispatch 1つ以上を含むすべてのスコープのために生み出されなくちゃならないmulti 宣言。 これは後ろ向きで、そして外へ（あるいは継承チェーンを上にのぼってメソッドのために）賛成で、捜索することによって、されるproto インスタンス生成に。 もしそんなものじゃないならproto 見いだされる、「最も一般的な」proto 生み出されるだろう、何かが好む：

proto sub foo (*@, *%) {*}
proto method foo (*@, *%) {*}
 

明らかに、名指された － が － に位置じゃないという状態で、再マッピングがこの場合されることができない。

［推測：我々はその代わりにそうすることができた自（己・動）情報そんなものが自動的に作ったそれぞれのためのいっそう特定のシグネチャーdispatch かつて我々は、定位置パラメタ名の一貫した使用が名指されたパラメータを再マップすることができた生み出されたシグネチャーで位置の名前で報いられるように、設定されたその正確な候補を知っている。］

名指されたサブルーチンのための構文が何もである概要：

 my RETTYPE sub NAME ( PARAMS ) TRAITS {...}    # lexical only
            sub NAME ( PARAMS ) TRAITS {...}    # same as "my"
our RETTYPE sub NAME ( PARAMS ) TRAITS {...}    # package-scoped
 

帰りの型は同じく括弧の中に置かれるかもしれない：

sub NAME (PARAMS --> RETTYPE) {...}
 

Perl 5 に、名指されたサブルーチンがそうであると異なりと展開式が見なした、それでこれは正当な Perl 6 だ：

my @subs = (sub foo { ... }, sub bar { ... });
 

相違がそのサブルーチンデフォルトであるもう1（つ・人）my 範囲よりむしろour スコープ。 しかしながら、サブルーチンディスパッチが外へレキシカルスコープを検索する、そしてサブルーチンがそれらの使用の後に同じく postdeclared されることを可能にされる、それであなたはこれだけに気付かないだろう。 ではないがもう宣言したサブルーチンが引数の周りに括弧を使って呼び出されるかもしれない、括弧がないときには、サブルーチン呼び出しはリスト演算子のかたちで多数の引数をとると考えられる。

匿名のサブルーチンのための一般的な構文はそうだ：

sub ( PARAMS ) TRAITS {...}
 

わずか1缶同じく使用anon 最初に帰りの型を開始するために修飾子をスコープ宣言しろ：

anon RETTYPE sub ( PARAMS ) TRAITS {...}
 

匿名のサブルーチンがスカラーに割り当てられるであろうとき、変数、変数はそれに割り当てられるであろうルーチンのシグネチャーで宣言されることができる：

my $grammar_factory:(Str, int, int --> Grammar);
$grammar_factory = sub (Str $name, int $n, int $x --> Grammar) { ... }; 
 

共分散が（スカラーのシグネチャーで定義されることよりさらに多くによって得られた戻型を持っている）ルーチンがそのスカラーに割り当てられることを可能にする。 Contravariance はルーチンが（スカラーのシグネチャーでさらに少なくそれらより得られるパラメーターの型で）そのスカラーに割り当てられることを可能にする。 もし可能であるなら、コンパイラは（型検証によって）このようなコンパイル時においての割り当てを実施することに決めるかもしれない。 このような型注釈は型推論でコンパイラがこのような注釈が含まれるという程度にそして／あるいはエクステントそれら支援にコードを最適化するのに役立つように意図される。

同じシグネチャーはもう1つのサブルーチンにクロージャパラメータの型に記録を残すために使われることができる：

sub (int $n, &g_fact:(Str, int, int --> Grammar) --> Str) { ... }
 

トレイトがコンパイル時の名前である（is）プロパティ. 「プロパティとトレイト」を見ろ。

あなたは、 Perl 5 のように、引数リストなしで sub を宣言することができる：

sub foo {...}
 

これは1（人・つ）と等しいの :

sub foo () {...}
sub foo (*@_) {...}
sub foo (*%_) {...}
sub foo (*@_, *%_) {...}
 

いずれかあるいはそれらの変数の両方ともがルーチンのボディーで使われるかどうかについて、依存する。

位置の引数が暗黙のうちに中に入るとして@_ 配列、しかし Perl 5 の場合と異なりそれらがそうだreadonly 実引数への別名：

sub say { print qq{"@_[]"\n}; }   # args appear in @_

sub cap { $_ = uc $_ for @_ }   # Error: elements of @_ are read-only
 

同じく Perl 5 の場合と異なり、 Perl 6 は中に入る真の名指された引数を持っているとして%_ 代わりに@_. 　（中に入る擬似名指された引数を作成するためにとして@_ Perl 5 のように、 p5 から p6 への翻訳者は醜い（人たち・もの）を定義して、そして使うだろうp5=> Perl 6 のの代わりの演算子=> Pair コンストラクタ。）

もしあなたがそうする必要があるなら、要素を修正しろ@_ あるいは%_宣言、配列、あるいはハッシュ明示的にis rw トレイト：

sub swap (*@_ is rw, *%_ is rw) { @_[0,1] = @_[1,0]; %_<status> = "Q:S"; }
 

メモ：rw 実際の配列あるいはハッシュがないけれども素晴らしいスターによっての個別の要素がパスしたトレイトが自動的に配られるコンテナ。 いっそう正確には、素晴らしいスターは宣言された仮引数ではないが見なしたことを意味する、読み取り専用；ただその要素だけがそうだ。 下にパラメータと引数を見ろ。

もし sub のブロックがプレースホルダー変数を含むなら、同じくそれに注意しろ（そんなものけれども$^foo あるいは$:bar）、それらが、このような場合そうで、すでに仮パラメータであるためにだと見なされる@_ あるいは%_ 比類がない引数を吸い取ることについてのロールを満たせ。 すなわち、もしそれらのコンテナが中で明示的に言及されるなら、体、それらは素晴らしいパラメータとして加えられる。 これは認められないパラメータの上にあなたが容易にあなたのエラーメッセージをカスタマイズすることを可能にする。 もしそれらが存在するなら、主要部で言及されないで、それらはシグネチャーに加えられていない、そして、もしシグネチャーがバインドされることができないなら、標準のディスパッチルールがただ失敗するだろう。

生のブロックは Perl 6 に同じく実行可能なコード構造だ。

すべてのブロックが型のオブジェクトを定義するBlock （それdoes Callable）、すぐに実行されるか、あるいはパスされるかもしれない as a Block オブジェクト。 ブロックが解析される方法はコンテキスト依存だ。

現在の（人たち・もの）が構造、そんなものを文 - とり壊す演算子があるところが通り過ぎて現在の展開式を終えて、そして多分ブロックと解析されると期待したそのままのブロックif あるいはwhile. 　（ない場合文構造がそこ（に・で）ブロックを探している、それは構文エラーだ。） 後置が期待されるそのままのブロックがハッシュ添え字として取り扱われるから、この種のそのままのブロックは先行する空白文字を必要とする。

項が期待されるそのままのブロックがただ生産するBlock オブジェクト。 もし項のそのままのブロックがリスト、それで起こるなら、コンマによってすぐに後に続かれないなら、そのリストの最終の要素だと見なされるあるいはコロン（介入する\h* あるいは「unspace」が許される）。

意味的に矢演算子-> ほとんど同義語が賛成であるsub それがあなたにコードのブロックでシグネチャーを宣言することを許す限りにおいて、匿名のサブルーチンを宣言するために使われるようにキーワード。 しかしながら、 pointy ブロックの引数リストは括弧を必要としない、そして pointy ブロックがトレイトを与えられないかもしれない。 けれどもたいていの点で、 pointy ブロックがいっそう公式のサブルーチンのようによりそのままのブロックのように処理される。 統語論上、 pointy ブロックがどこでも使われるかもしれない、そのままのブロックが使われることができた：

my $sq = -> $val { $val**2 };
say $sq(10); # 100

my @list = 1..3;
for @list -> $elem {
    say $elem; # prints "1\n2\n3\n"
}
 

それはコントロールの例外に関して同じくブロックのように振る舞う。 もしあなたreturn pointy ブロックの中から、ブロックは、復帰に；それが囲んで一番奥の（人たち・もの）から戻るであろう透明だsub あるいはmethod （およびその他）、ブロックからではなく、それ自身. それは通り過ぎて参照される&?BLOCKそうじゃない&?ROUTINE.

ブロックがパラメータデフォルトである標準の pointy readonlyただパラメータのように、標準の sub 宣言に。 しかしながら、変形がパラメータを支払不能とするダブル - pointy rw：

for @list <-> $elem {
    $elem++;
}
 

この形式は適用されるrw すべての引数に：

for @kv <-> $key, $value {
    $key ~= ".jpg";
    $value *= 2 if $key ~~ :e;
}
 

実際にそれを定義しないでサブルーチンを前もって宣言するために、「切り株ブロック」を使え：

sub foo {...}     # Yes, those three dots are part of the actual syntax
 

古い Perl 5 フォーム：

sub foo;
 

コンパイル時エラーが Perl 6 にある（それがそれを暗示するであろうから、サブルーチンの主要部はファイルの終わりにその文から拡張する、けれどもclass そしてmodule 宣言がする）。 形式が宣言するはずであるセミコロンの唯一の許可の使用MAIN sub － 下のメインサブルーチンを宣言して見ろ。

切り株サブルーチンを再定義することはエラーを作り出さない、しかしすでに定義されたサブルーチンを再定義することはそうする。 もしあなたが定義された sub を再定義することを望むなら、あなたは明示的に使わなくちゃならない「supersede」宣言詞. （もしそれがすでに前の定義を約束したなら、コンパイラはこれをすることを拒否するかもしれない。）

... 実行可能だが、失敗を返す「yadayadayada」演算子だ。 同じく使用権限：??? 警告を作り出すために、あるいは!!! 常に死ぬために。 これらは同じく公式に切り株ブロックを定義する。 これらの yada 演算子の Any は、もしブロックで最初の文の主な演算子として使用されるなら切り株と思われるだろう。 （文修飾子がその文に入ることを許される。） yada 演算子は sub foo の「Unimplementedな切り株がそうであった次のようなメッセージへのすべてのデフォルトが実行したそのそれらでの（彼・それ）らのそれぞれの名指された関数とは違う」。

それは論じられたそれ... あなたが同じくドキュメントの中でメタ構文のためにそれを使うことを望むかもしれないとき、リテラルの構文が紛らわしい（とき・から・につれて・ように）。 一般にこれはコンテキストで問題じゃない；それは決してプログラム自身の問題とそれが証拠書類で問題であり得た少数の場所じゃない、コメントが同じぐらい上記の意志を明確化するのに役立つだろう。 時の残り、リーダーがつくかどうかは本当に重要じゃない... 同じぐらいリテラルだ、あるいはそうじゃない、目的からの... あなたがそれをどちらの方法でとるとしても、何かが欠けていることを示すはずだ。

サブルーチンと変数がグローバルなネームスペース（あるいはグローバルなネームスペースでのどんなパッケージでも）に宣言されることができて、そして GLOBAL パッケージ（あるいはその subpackages の1つ）としてのプログラムでどこでもその後目に見える。 それらが輸入によって直接目に見えさせられるかもしれない、しかしさもなければそのままの識別子で呼び出されないかもしれない、サブルーチンディスパッチからレキシカルスコープでただ見るだけだ。

サブルーチンと変数がそれら識別子に前接続して通常通り過ぎて言及されるグローバル* ダイナミックにスコープ宣言されたオーバライドを許すために、 twigil しろ。

GLOBAL::<$next_id> = 0;
sub GLOBAL::saith($text)  { say "Yea verily, $text" }

module A {
    my $next_id = 2;     # hides any global or package $next_id
    &*saith($next_id);   # print the lexical $next_id;
    &*saith($*next_id);  # print the dynamic $next_id;
}
 

ダイナミックなオーバライドを拒否するために、あなたは直接グローバルにアクセスしなくちゃならない：

GLOBAL::saith($GLOBAL::next_id);
 

これが冗長であるという事実は特徴であると解釈される。 代わる代わる、あなたはこのようなエイリアシングいたずらをしてもよい：

module B {
    import GLOBAL <&saith $next_id>;
    saith($next_id);    # Unambiguously the global definitions
}
 

サブルーチンディスパッチがただレキシカルスコープで見ることだけをするにもかかわらず、もしそれに語彙のエイリアスがあるなら、あなたは常に直接パッケージサブルーチンを呼び出すことができる、 as the our 宣言詞がそうする：

module C;
our sub saith($text)  { say "Yea verily, $text" }
saith("I do!")      # okay
C::saith("I do!")   # also okay
 

同様に、あなたは動的にスコープ宣言されたサブルーチンを定義してもよい：

my sub myfunc ($x) is dynamic { ... }
my sub &*myfunc ($x) { ... }        # same thing
 

これはそれから訴えられるかもしれない、ダイナミックな変数の間：構文として

&*myfunc(42);
 

左辺値サブルーチンがそれが割り当てられることができる「プロクシ」オブジェクトを返す。 オブジェクトが通常、サブルーチン呼び出しについて目的あるいは結果を表すから、それは代理として知られている。

サブルーチンが、左辺値を使っているとして、指定されるis rw トレイト。

左辺値サブルーチンが変数を返すかもしれない：

my $lastval;
sub lastval () is rw { return $lastval }
 

あるいはいくらかの結果は左辺値サブルーチンに呼び出しをネストした：

sub prevval () is rw { return lastval() }
 

あるいは特別に代理オブジェクト、とタイすでふさわしくプログラムするFETCH そしてSTORE メソッド：

sub checklastval ($passwd) is rw {
    return new Proxy:
            FETCH => method {
                        return lastval();
                     },
            STORE => method ($val) {
                        die unless check($passwd);
                        lastval() = $val;
                     };
}
 

メソッドがそうであるかもしれない他がテンポラリ化するような専門的な目的でプロクシの値を定義した。

演算子はただ特殊名を持っているサブルーチンと有効範囲規則に過ぎない。 演算子名が通り過ぎてコロンが後に続いたシングルによって後に続かれて文法的なカテゴリー名から成り立つ、それが1かそれ以上の文字列であるかのように、演算子名が指定した。 それでこれらの何でも同じ二進加算演算子を示す：

infix:<+>
infix:«+»
infix:<<+>>
infix:['+']
infix:["+"]
 

使用& シギルがただあなたとして普通の sub にそうするだろう。

演算子が定義される Unary prefix あるいはpostfix：

sub prefix:<OPNAME>  ($operand) {...}
sub postfix:<OPNAME> ($operand) {...}
 

演算子が定義される Binary infix：

sub infix:<OPNAME> ($leftop, $rightop) {...}
 

演算子が定義される Bracketing circumfix 項が期待されるあるいはpostcircumfix 後置が期待されるところ。 先行する、そして後続する区切り文字を含んでいる2要素の断片は演算子の名前だ。

sub circumfix:<LEFTDELIM RIGHTDELIM> ($contents) {...}
sub circumfix:['LEFTDELIM','RIGHTDELIM'] ($contents) {...}
 

Apocalypse 6に反して、そこ（に・で）、文字の偶数を分割することについて、もう何かではなくが統治か。 あなたは2要素の断片を使わなくちゃならない。 このような名前はシンボルテーブルの中で一つのフォームに canonicalized される、それで、もしあなたが望むなら、あなたは正規名を使わなくちゃならない、から直接シンボルテーブルを添え字化しろ（同じぐらい中にPKG::{'infix:<+>'}）. さもなければ形式がするであろう何も。 （直接の添え字がそれらからパージングプロセスを体験する（とき・から・につれて・ように）、象徴的な参照が数えない。） 標準形は常に角括弧を使うそしてスライス要素の間にシングルスペースで印字する. 要素はそれほど、括弧に、エスケープされるPKG::circumfix:['<','>'] canonicalized はそうするはずだPKG::{'circumfix:<\< \>>'}そして decanonicalizing が常に左から右にされるかもしれない.

演算子名は非空白文字の文字について Unicode 文字を含めてどんな連続でもであり得る。 例：

sub infix:<(c)> ($text, $owner) { return $text but Copyright($owner) }
method prefix:<±> (Num $x --> Num) { return +$x | -$x }
multi sub postfix:<!> (Int $n) { $n < 2 ?? 1 !! $n*($n-1)! }
macro circumfix:«<!-- -->» ($text) is parsed / .*? / { "" }

my $document = $text (c) $me;

my $tolerance = ±7!;

<!-- This is now a comment -->
 

空白文字が決して名前の一部じゃないかもしれない（セパレータとして以外中で<...> あるいは«...» 上記の例のように、添え字を薄く切る）.

A　ゼロの演算子名が数値から始まるトークンのように、認識されることができる、固定されている文字列がないとき、有用なその構文カテゴリのために空あるいは空白文字演算子じゃなくてデフォルトのマッチしているサブルールを定義する。 このような不可欠を供給する演算子is parsed トレイト。 Perl 文法は賛成のデフォルトサブルールを使う:1st:2nd:3rdなど正規表現修飾子、このような何か：

sub regex_mod_external:<> ($x) is parsed(token { \d+[st|nd|rd|th] }) {...}
 

このようなデフォルトルールは申告されたオーダーで試みられる。 （それらが常に、最も長いトークン - 最初の規則によって、周知の接頭辞でどんなルールにでも従う。）

演算子の名前が何の中にでもインストールされ得るけれども、パッケージあるいは語彙のネームスペース、演算子宣言の構文的な効果は常にレキシカルスコープなだ。 水準の（の・もの・人）以外のものが中にインストールされるべきじゃない演算子* ネームスペース。 常に書き出しを非標準の構文を他のスコープに提供するために使え。

Perl 6 サブルーチンがパラメーターリストで宣言されるかもしれない。

デフォルトまでに、すべてのパラメータは（彼・それ）らの対応する引数に読み取り専用エイリアスだ － パラメータはただもう1つのオリジナルの引数の名前に過ぎない、しかし引数はそれを通して修正されることができない。 これは値のためにぼんやりと真だ、それらが存在しないかもしれないときからの引数が何ででも場合を修正した。 しかしながら、デフォルトは何でも強制する、同じく存在するコンテナ引数が不変の値としておごった。 これはたった1つのレベル下がって拡張する；もしそれがそれほど選択するなら、不変のコンテナが常に変更可能な要素を返すかもしれない。 （この目的でではないがトップレベルのオブジェクトがスカラー変数の中でデフォルトによって不変であると見なされるように、けれども、その単数形のオブジェクトのコンテナだと見なしたスカラー変数。 Perl 6 は Perl 5 がする同じセンスに参照を持っていない。）

使用修正を許すことis rw トレイト。 これは引数（あるいは数種類の、配列によって返されるかもしれないように、可変オブジェクト、そんなものに変換されることができる型オブジェクトあるいはどのように新しい要素を autovivify するべきか知っているハッシュ）として可変オブジェクトあるいはコンテナを必要とする。 シグネチャーがバインドし損ねる別のこととルーチンがそうであるはずがないこの候補者で、この特定の呼び出しにサービスを提供することに対して、見なした。 （もしそれらであるなら、他の多候補者、もし何も、が成功するかもしれないそうする必要とするrw このパラメータのために。） 何でも場合、バインドすることに関しての失敗がひとりでに例外をスローされさせない；それは完全に配車係次第だ。

使用コピー渡しにis copy トレイト。 オリジナルの（人たち・もの）が変更可能か否かにかかわらず、オブジェクトコンテナがクローンされるだろう、他方（不変の）値がふさわしく変更可能なコンテナにコピーされるだろう。 パラメータは何にでもパラメータの他の類型学の制約を満たす引数をバインドするかもしれない。

もしあなたが読み取り専用パラメータを持っているなら$roそれ決してパスされないかもしれないrw subcall の、パラメータかどうか$ro 変更可能なオブジェクトに現在バインドされる。 それはただ読み取り専用に再境界であるか、あるいはパラメータをコピーするかもしれない。 それは区画パラメータに同じく再境界であるかもしれない（見ろ「is parcel」下に）、修正以外不変の値がに境界であるケースのように失敗するだろうparcel パラメータ。

別名の$ro 明示的に生み出されるか否かにかかわらず、同じく読み取り専用であrde:= あるいは暗黙のうちに中だCapture （（彼・それ）ら自身不変である）オブジェクト。

同じく、$ro 左辺値サブルーチンあるいはメソッドから返されないかもしれない。

パラメータが必要とされるか、あるいはオプションであるかもしれない。 それらがポジションによって、あるいは名前によってパスされるかもしれない。 個別のパラメータが項目を授けるか、あるいはコンテキストを（彼・それ）らの対応する引数にリストするかもしれない、しかし Perl 5 の場合と異なり、これは時間をバインドしてパラメータでいい加減に決定される。

必要とされるポジショナルパラメータになる運命の引数が任意のポジショナルパラメータにバインドされてそれらに優先しなくちゃならない。 名指されたパラメータになる運命の引数が前に、そして／あるいはポジショナルパラメータの後に来るかもしれない。 （混乱を避けるために、すべてのポジショナルパラメータが呼び出し構文で連続的に保たれることは大いに推薦されている、けれども実施されたこのではないと注文製の arg リストプロセッサは最終の素晴らしいあるいは arglist の変数にバインドされるそれらの引数に確かに可能だ。）

シグネチャーを限定している名前衝突がコンパイル時間エラーだと見なされる。 名前衝突がポジショナルパラメータの間に、名指されたパラメータの間に、あるいは定位置パラメタと名指された（の・もの・人）の間に起こることができる。 ではないが、2つのポジショナルパラメータに関しては以外、このような比較で見なしたシギル － 言い換えれば、2かそれ以上のパラメータがシギル以外同一であるシグネチャーがまだ問題がない（けれどもあなたはその名前によって値をパスすることが可能じゃないだろう）。

:($a, $a)       # wrong, two $a
:($a, @a)       # OK (but don't do that)
:($a, :a($b))   # wrong, one a, one a through renaming
:($a, :a(@b))   # wrong 
:(:$a, :@a)     # wrong
 

名指された引数が「コンマ」レベルで統語論上識別される。 パラメータが識別子を使って識別されるから、認められたシンタクスは問題の識別子が明白であるものだ。 あなたはいずれか、副詞の形、を使ってもよい:name($value)あるいは自動的に引用された矢書式、name => $value. 　これらはトップの「コンマ」レベルで起こるに違いない、そして他のどのようなフォームもデフォルトによって名指されたペアと思われない。 Pair は、位置であると同じように、引数が名指された引数よりむしろ余分の括弧によってあるいは自（己・動）引用を隠すために明示的にキーを引用することによって、示されるかもしれないことを意図した：

doit :when<now>,1,2,3;      # always a named arg
doit (:when<now>),1,2,3;    # always a positional arg

doit when => 'now',1,2,3;   # always a named arg
doit (when => 'now'),1,2,3; # always a positional arg
doit 'when' => 'now',1,2,3; # always a positional arg
 

ただ正当な識別子名を持ったそのままのキーだけが名指された引数として認知される：

doit when => 'now';         # always a named arg
doit 'when' => 'now';       # always a positional arg
doit 123  => 'now';         # always a positional arg
doit :123<now>;             # always a positional arg
 

他の方法、対のように見えない名指された引数が開始されなくちゃならないように、意図されたペアに行く| 演算子を前接続しろ：

$pair = :when<now>;
doit $pair,1,2,3;                # always a positional arg
doit |$pair,1,2,3;               # always a named arg
doit |get_pair(),1,2,3;          # always a named arg
doit |('when' => 'now'),1,2,3;   # always a named arg
 

括弧が優先のために最後の1（人・つ）に関して必要であることに注意を払え。

同じく、もしあなたがハッシュをパスして、そしてあなたが一緒にそれをデリファレンスしなくちゃならない名指された引数として扱われたその参加者を持つことを望むなら|：

%pairs = (:when<now>, :what<any>);
doit %pairs,1,2,3;               # always a positional arg
doit |%pairs,1,2,3;              # always named args
doit |%(get_pair()),1,2,3;       # always a named arg
doit |%('when' => 'now'),1,2,3;  # always a named arg
 

変数で: あなたが同じくこれを言うことができるように、右辺値でコンテキスト自（己・動）生成対を前接続しろ：

$when = 'now';
doit $when,1,2,3;   # always a positional arg of 'now'
doit :$when,1,2,3;  # always a named arg of :when<now>
 

言い換えれば:$when 速記は賛成だ:when($when). 　これは何にでもシギルをもたらす：

:$what      :what($what)
:@what      :what(@what)
:%what      :what(%what)
:&what      :what(&what)
 

それが1対かどうかにかかわらず、普通のハッシュ表記法がただハッシュ項目の値を位置の引数としてパスするだろう。 共に重要にパスするために、そして位置の対、使用としてハッシュがなくなっている値:p その代わりに：

doit %hash<a>:p,1,2,3;
doit %hash{'b'}:p,1,2,3;
 

:p 「守備じゃない」「ペア」を表す:p 副詞が何の上にでも置かれるかもしれないAssociative それを「値」の代わりに「対」を意味させるために添え字にアクセスしろ。 もしあなたがあなたがそれと一緒プレフィックス変換によってそうするかもしれない、引数と命名されるように、解釈される二人（あるいは対）を必要とするならprefix:<|> 演算子：

doit |(%hash<a>:p),1,2,3;
doit |(%hash{'b'}:p),1,2,3;
 

（括弧はもつことを必要とされる:p そうするための付着することからの副詞prefix:<|> 演算子。）

Pair コンストラクタが呼び出しレベルで統語論上識別されて、そして名指されたスロットに入れられるのCapture 構造。 従ってそれらが位置の同じぐらい普通じゃない名前によってだけ positionals にバインドされるかもしれないPair オブジェクト。 残りの名指された引数が素晴らしいハッシュの中に音をたてて飲まれることができる。

名指された、そして位置の引数が自由に入り混ざり得るから、プログラマーは常に括弧あるいはクォートで名指された引数からペアリテラルのあいまいさを排除する必要がある：

# Named argument "a"
push @array, 1, 2, :a<b>;

# Pair object (a=>'b')
push @array, 1, 2, (:a<b>);
push @array, 1, 2, 'a' => 'b';
 

Perl 6 は多数の同じ - 名指された引数を許して、そして同一名で引数の相対オーダーを記録する。 1つの引数以上、あるとき@ 引数リストでのシギルが引数を連結されさせる：

sub fun (Int @x) { ... }
fun( x => 1, x => 2 );              # @x := (1, 2)
fun( x => (1, 2), x => (3, 4) );    # @x := (1, 2, 3, 4)
 

他のシギルがただ最後までその名前：を持っている引数をバインドする

sub fun (Int $x) { ... }
fun( x => 1, x => 2 );              # $x := 2
fun( x => (1, 2), x => (3, 4) );    # $x := (3, 4)
 

これはデフォルト値を持っているハッシュがハッシュコンストラクタが機能する方法に類似している周知の名指されたパラメータに優先しなくちゃならないことを意味する：

# Allow "x" and "y" in %defaults to be overridden
f( |%defaults, x => 1, y => 2 );
 

メソッドインボカントが（コンマよりむしろ）それのすぐ後に、コロンで、引数リストで最初のパラメータとして明示されるかもしれない：

method get_name ($self:) {...}
method set_name ($_: $newname) {...}
 

対応する引数（インボカント）は項目コンテキストで評価されて、そしてメソッド呼び出し演算子の左オペランドとしてパスされる：

print $obj.get_name();
$obj.set_name("Sam");
 

インボカントは最初の位置引数として実際に記憶されるのCapture オブジェクト。 それはただ配車係に特別だ、さもなければそれはただ標準の位置の引数に過ぎない。

一つのディスパッチの意味規則が同じく、コロンがインボカント引数を求めているという状態で、間接的なオブジェクト構文を使うことによって、求められるかもしれない。 コロンはただコンマの特殊形式であって、そして同じ優先を持っている：

set_name $obj: "Sam";
$obj.set_name("Sam");   # same as the above
 

もしその仮引数が名前で宣言されるなら、インボカントが対応するメソッドのトピックだ$_. 　メソッドのインボカントは常に別名を持っているself. 　self のスタイルが一緒に宣言されることができる他self プラグマ。

もしあなたが形式の呼び出しを持っているなら：

foo(|$capture)
 

コンパイラは、供給された（人たち・もの）か否かにかかわらず、それをメソッドあるいは上にディスパッチベースの関数として扱うべきかどうかについての決定を延期しなくちゃならないCapture「s最初の引数はインボカントとして記録されている。 なぜなら、しかしながら、これが常に決定されることができる普通の呼び出しが時間をコンパイルするから。

記録されているルーチンでmulti マルチディスパッチのと見なされるためにそのパラメータの一部を記録を残すことができる。 これらは longnames と呼び出される；多数のディスパッチの意味規則についてさらに多くのために S12 を見ろ。

あなたは部分的に選択することができるのmulti「最後の1（人・つ）の後に二重のセミコロンを記入することによって、その longname であるsパラメータ：

multi sub handle_event ($window, $event;; $mode) {...}
multi method set_name ($self: $name;; $nick) {...}
 

引数リストがせいぜい1つの二重のセミコロンを持っているかもしれない；それの後のパラメータが決して多数のディスパッチ（もちろんそのそれらがまだもしを「拒否する」ことができることを除いて数あるいは型が組み合わせを誤るそれら）に関して見なされない。

［推測：一つのセミコロンによって区切られて、多数のロングネームを宣伝することはルーチンにとって可能であるかもしれない。 詳細のために S12 を見ろ。］

もし賛成の引数リストであるならmulti 重要なパラメータのリストを区切るためにセミコロンを含んでいない、それですべてのポジショナルパラメータは重要であると見なされる。 もしそれmulti method あるいはmulti submethod追加の暗黙が匿名であるという状態でself 最初のパラメータがコロンで明示的に記録されていないなら、インボカントがシグネチャーリストに加えられる。

Required パラメータがサブルーチンの引数リストのスタートで指定される：

sub numcmp ($x, $y) { return $x <=> $y }
 

Required パラメータがオプションとして後置で宣言されるかもしれない!それがすでにデフォルトであるけれども、ポジショナルパラメータで：

sub numcmp ($x!, $y!) { return $x <=> $y }
 

対応する引数は項目コンテキストで評価されて、そして positionally に、あるいは名指しでパスするかもしれない。 パスするために、引数が名指しで、それを1対として明示する：parameter_name => argument_value.

$comparison = numcmp(2,7);
$comparison = numcmp(x=>2, y=>7);
$comparison = numcmp(y=>7, x=>2);
 

Pair は副詞のペア表記で同じくパスするかもしれない：

$comparison = numcmp(:x(2), :y(7));
$comparison = numcmp(:y(7), :x(2));
 

パスして、標準のサブルーチンへの必要とされる引数の間違った番号は致命的エラーだ。 パスして、標準のサブルーチンにバインドされることができない名指された引数が同じく致命的エラーだ。 （メソッドは異なっている。）

サブルーチンが持つ必須パラメータの数は、呼び出すことによって、決定され得るそ.arity メソッド：

$args_required = &foo.arity;



 

任意のポジショナルパラメータが結局のところ指定されるパラメータとそれぞれが記録される必要とされる（人たち・もの）? パラメータの後に：

sub my_substr ($str, $from?, $len?) {...}
 

代わる代わる、オプションのフィールドはデフォルト値を供給して通り過ぎて記録されているかもしれない。 = サインがデフォルト値を開始する：

sub my_substr ($str, $from = 0, $len = Inf) {...}
 

デフォルト値が実行時と計算されることができる。 それらが前のパラメータの値を使いさえするかもしれない：

sub xml_tag ($tag, $endtag = matching_tag($tag) ) {...}
 

任意パラメタに対応する引数が項目コンテキストで評価される。 それらが除かれることができる、名前：によって positionally にパスしたか、あるいはパスした

my_substr("foobar");            # $from is 0, $len is infinite
my_substr("foobar",1);          # $from is 1, $len is infinite
my_substr("foobar",1,3);        # $from is 1, $len is 3
my_substr("foobar",len=>3);     # $from is 0, $len is 3
 

もしそれらがデフォルトを持っていないなら、それらデフォルト値に、あるいは未定義の値にオプションの引数デフォルトをミスする。 （未定義のではないである供給された引数が欠けているために見なした、そして従ってデフォルトを引き起こさない。 使用//= 体の中でそれのために。）

あなたは呼び出すことによって任意パラメタが何かにバインドされたかどうか調べてもよいVAR($param).defined.

－ に名前をつけたただパラメータがシグネチャーで必要とされる何もあるいは任意パラメタの後に続く。 それらは接頭辞によって記録されている:：

sub formalize($text, :$case, :$justify) {...}
 

これは実際は賛成の速記だ：

sub formalize($text, :case($case), :justify($justify)) {...}
 

もし手書き形式が使われるなら、ラベル名と変数名は異なり得る：

sub formalize($text, :case($required_case), :justify($justification)) {...}
 

あなたが名指された引数に都合悪く長い外部ラベルを押し付けないでいっそう記述的な内部の parameter name を使うことができるように。 マルチ名包装がされるかもしれない；これはあなたがショートと長い外部名両方を与えることを可能にする：

sub globalize (:g(:global($gl))) {...}
 

あるいは等しく：

sub globalize (:g(:$global)) {...}
 

名指されたパラメータに対応する引数が項目コンテキストで評価される。 それらがただ名前によってパスされることができるだけだ、それでそれらで何があなたがパスするように命ずるかは重要じゃない：

$formal = formalize($title, case=>'upper');
$formal = formalize($title, justify=>'left');
$formal = formalize($title, :justify<right>, :case<title>);
 

副詞の形と矢表記の間に連絡のために S02 を見ろ。

名指された間とポジション引数が混ぜられるかもしれない、あなたが明快さがあなたが良い理由を持っていないならそうしないように1つの場所ですべての positionals を続けることは提案される。 これはありそうな良くないスタイルだ：

$formal = formalize(:justify<right>, $title, :case<title>, $date);
 

名指されたパラメータは崇拝者と一緒に記録されていないなら、任意だ!. 　任意の名指されたパラメータのためのデフォルト値が、ポジショナルパラメータについては同じように定義される、しかしすでにバインドされたパラメータの値を含めて、存在する値にだけ依存するかもしれない。 任意パラメタをデフォルトと命名するそうすることNil もしそれらがデフォルトを持っていないなら。 その名前の引数対が供給されない限り、名指された必須パラメータが失敗する。

バインディングが論理的に、呼び出しオーダーではなく、宣言オーダーで起きる、それでデフォルトがそうするかもしれない何でもシグネチャーで左に仮パラメータの上に確実に依存する。

もう1つのこのポリシーの利益が、それを許すルーチンのために、名指された引数がポジショナルパラメータにバインドされるかもしれないということだ。 （これはいずれかで明示的に宣言されるルーチンでだけ入ることを許されるproto あるいはonly 宣言詞。） もし最初の定位置パラメタが名前をつけられるなら$a例えば、そうすることはバインドするだろう:a() 最初の位置の引数までの優先の引数。

明示への制限proto そしてonly 宣言 API 純粋と効率両方に対する願望によって動機付けを与えられる. 標準だmulti あるいはsub 宣言と標準のメソッド宣言が positionals に名指されたバインディングを探そうと試みない。 せいぜいそこ（に・で）何かのためにディスパッチをバインドする1つのそのようなものだ、それが初めにいつを呼び出すかproto （あるいは明示only）. proto その内部マルチディスパッチャーを呼び出す前に、バインダ（sub あるいはメソッドのために）が positionals に自動的にこのような名指されたパラメータを再マップしなくちゃならない（通り過ぎて表された（の・もの・人）{*}）. ケースでのproto sub 、このマッピングは呼び出しのポイントでされることができて、それ以来そこ（に・で）ただそうであることができるだけだ、位置の名前のセットと呼び出される proto が知られていることができる可能な1が（外のスコープで CANDO 宣言の absense で）時間をコンパイルする。 それで後で

proto foo ($x, $y, :$bar, :$baz) {*}
multi foo ($a, $b, :$bar, :$baz) {...}
multi foo ($n, $m, :$bar, :$baz) {...}

foo :y(2), :x(1);   # can turn into foo(1,2)
 

そうするための呼び出しfoo 純粋な位置の呼び出しに変えられることができる to the proto （それがスタンダードを使っているから、それは今度はインライン化されることができる{*} 配車係 － そして同じくメソッドのために、クラスを含んでいることであるときproto finalizable であることが知られている）. 同じくマルチ定義が決して、それ以来後で、ポジショナルパラメータのために同じ parameter name を使うことを必要とされないことを注意するproto バインディングがされる、名前（もし何も）は決して再び positionals のために使われない。

$x そして$y 上記の名前が中にただそれらが存在するから名前をつけられた公共の API の一部であるproto. 　定位置パラメタ名が、明示的に使用可能じゃないなら、決して広告された API の一部じゃない。 明示proto そのままのシギルで positionals を declararing することによって、容易に広告名を抑えるかもしれない：

proto foo ($, $, :$bar, :$baz) {*}
multi foo ($x, $y, :$bar, :$baz) {...}

foo :x(1), :y(2);   # illegal
 

（そしてonly ルーチンがただ、使うことによって、位置の API をコントロールするかもしれないsub その代わりに、あるいは定義することによってproto シングルでmulti もしより素晴らしいなら、制御が切望される。）

直感で知られた proto が決してポジショナルパラメータの API 名を供給することについて頭を悩まさなくてもよいことはこのすべてから続く。 そして proto が今までに、 multis それらディスパッチの positionals で名前を conficting することについて、何にでも、から再マッピングがそれの前に扱われることを心配しなくてもよい。

リストパラメータがデータの可変長フィールドリストを取り込む。 それらサブルーチンで使われる好むprint引数の数が柔軟である必要があるところ。 それら、それらが引数の変数数を所有するから、同じく「variadic パラメータ」と呼び出される. けれども一般に、それらが引数を音を立てて飲むから、我々はそれらの「素晴らしい」パラメータを呼び出す。

素晴らしいパラメータが必要とされる何もあるいは任意パラメタの後に続く。 それらが通り過ぎて記録されている* パラメータの前に：

sub duplicate($n, *%flag, *@data) {...}
 

名指された引数が素晴らしいハッシュにバインドされる（*%flag 上記の例で）. このような引数は項目コンテキストで評価される。 Any の残っている variadic 引数が終わりに引数リストについて素晴らしい配列にバインドされる（*@data 上に）そしてリストコンテキストで評価される.

例：

duplicate(3, reverse => 1, collate => 0, 2, 3, 5, 7, 11, 14);
duplicate(3, :reverse, :!collate, 2, 3, 5, 7, 11, 14);  # same

# The @data parameter receives [2, 3, 5, 7, 11, 14]
# The %flag parameter receives { reverse => 1, collate => 0 }
 

素晴らしいスカラーパラメータがさもなければ variadic 配列の最初の要素であろうものをとらえる：

sub head(*$head, *@tail)         { return $head }
sub neck(*$head, *$neck, *@tail) { return $neck }
sub tail(*$head, *@tail)         { return @tail }

head(1, 2, 3, 4, 5);        # $head parameter receives 1
                            # @tail parameter receives [2, 3, 4, 5]

neck(1, 2, 3, 4, 5);        # $head parameter receives 1
                            # $neck parameter receives 2
                            # @tail parameter receives [3, 4, 5]
 

素晴らしいスカラーがまだそれら引数にリストコンテキストを課す。

一つの素晴らしいパラメータがいい加減に扱われる － 個別の要素が実際にアクセスされるとき、リストはただ配列の中に平らにされるだけだ：

@fromtwo = tail(1..Inf);        # @fromtwo contains a lazy [2..Inf]
 

［推測：しかしながら、もしあなたがシグネチャーで2かそれ以上の素晴らしい配列を使うなら、リストはその代わりに超コンテキストで評価されて、そしてそれ自身をそれほど宣言された slurpies の数に対応しているリストの数に分けるように依頼されるだろう. 超有能でないリストがこの激しい演算のために失敗を返すだろう、それでシグネチャーはただ parallelizable の上にリスト演算をバインドするだけであるべきだ。 同じく「割れるにはあまりにも短い」リストが失敗する、からもし我々がそのように「あまりにも短い」を定義するなら、別個のシグネチャーが空リストと多分 singletons とマッチするかもしれないように、バインドしろ。］

あなたは素晴らしいパラメータの名前にバインドすることができない：あなたが体の中でそれを参照することができるように、名前はただそこにある。

sub foo(*%flag, *@data) {...}

foo(:flag{ a => 1 }, :data[ 1, 2, 3 ]);
    # %flag has elements (flag => (a => 1)) and (data => [1,2,3])
    # @data has nothing
 

素晴らしいブロックを宣言することは同じく可能だ：*&block. 　それは指定された無名のブロック通り過ぎて何でも音を立てて飲む{...}現在の位置の場所あるいは構文的なリストの終わりに。 もしあなたが最初にあるいは最後に引数にブロックを入れる選択を欲するなら、それを第一におけ。 もしあなたがそれに最後の引数として入ってくることを強いることを望むなら、最後にそれを置け。

基礎をなしている（人たち・もの）Capture オブジェクトがシングルにバインドされるかもしれないパラメータが一緒に記録を残したスカラー|.

sub bar ($a,$b,$c,:$mice) { say $mice }
sub foo (|$args) { say $args.perl; &bar.callwith(|$args); }
 

これは印刷する：

foo 1,2,3,:mice<blind>;     # says "\(1,2,3,:mice<blind>)" then "blind"
 

上に示されるように、キャプチャはもう1つの呼び出しの引数の中に間にはさまれるかもしれない。 （| 接頭辞が次のセクションで記述される。） 使えcallwith ルーチンが当局者を開始しないで呼び出されることを可能にするCALLER フレーム。 なぜならさらに多くが下に「包装」を見るから。

それはシグネチャーの中で、しかしキャプチャ引数の subsignature としてだけ再製本、パラメータ、に許される：

sub compare (|$args (Num $x, Num $y --> Bool)) { ... }
 

すべての標準の宣言部分目的（例えば invocants と多数のディスパッチ型）で、内部のシグネチャーはシグネチャー全体として扱われる：

method addto (|$args ($self: @x)) { trace($args); $self += [+] @x }
 

非 － のために必要とされる内部のシグネチャーではないmultisはそれ以来そこ（に・で）ただ1人の候補者であることができるだけだ、しかし多数のディスパッチのために内部のシグネチャーは少なくともその型のために必要とされる、あるいは宣言は何のシグネチャーに対してマッチするべきか知らないだろう。

multi foo (|$args (Int, Bool?, *@, *%)) { reallyintfoo($args) }
multi foo (|$args (Str, Bool?, *@, *%)) { reallystrfoo($args) }
 

それはとしてさらにいっそう生の形式で引数リストをバインドすることが可能であるParcel オブジェクト。 区画が宣言されなくちゃならないキャプチャへのシグネチャー：

sub foo (\|$parcel) { ... }
 

この一つの区画パラメータはこのようなシグネチャーで（戻型を別として）許された唯一のものだ。 実装があるいは、キャプチャから、オリジナルの区画オブジェクトを再建することができなければならない、あるいはコンパイラはいつ proto 宣言に基づいてオリジナルの区画オブジェクトをセーブして、そして／あるいは間接参照を呼び出すべきか知るのに十分スマートに違いない。

単項の（人たち・もの）| 演算子がそうするためのその引数を投げるCapture オブジェクト、それが起こる引数リストの中にそれからそのキャプチャを継ぐ。 あなたが使うことができる多数の引数に対する同じ効果を得ること|« 超演算子。

Pair そしてHash 引数という名前になれ：

|(x=>1);          # Pair, becomes \(x=>1)
|{x=>1, y=>2};    # Hash, becomes \(x=>1, y=>2)
 

そうな他の何もIterable ただ位置引数に変えられる：

|(1,2,3);         # Seq, becomes \(1,2,3)
|(1..3);          # Range, becomes \(1,2,3)
|(1..2, 3);       # Parcel, becomes \(1,2,3)
|([x=>1, x=>2]);  # List (from an Array), becomes \((x=>1), (x=>2))
 

例：

sub foo($x, $y, $z) {...}    # expects three scalars
@onetothree = 1..3;          # array stores three scalars

foo(1,2,3);                  # okay:  three args found
foo(@onetothree);            # error: only one arg
foo(|@onetothree);           # okay:  @onetothree flattened to three args
 

| 演算子がいい加減に平らになる － 平らになることはサブルーチンの中で実際に必要とされる場合に限り、配列は平らにされる。 リストがサブルーチンの中にさえ通過して、使用である前に、平らになることflat リスト演算子：

foo(|flat 1,2,3 Z 4,5,6);    # zip list flattened before interpolation
foo |(1,2,3 Z 4,5,6).flat    # same thing



 

若干の関数が位置の、そして／あるいは名指された引数の1以上のリスト、1つのリストの中に平らにされないそのそれら願望をとる。 例えば、zip() 配列とハッシュ添え字がプロセスに多次元のスライスを欲する間に、並列にいくつかのリストを反復することを望む。 セットは原因となっている引数リストについて一つの配列にバインドされるかもしれない、パラメータが二塁打で宣言した** マーカー：

sub foo (**@slice) { ... }
 

これが異なっている重要性

sub foo (|$slice) { ... }
 

限りにおいて|$slice その構造を処理することへの約束をしない（そして多分まだそれ自身の構造を知りさえしない）一つの引数 - リストオブジェクトにバインドされる、他方**@slice 配列の次元に入ってくる次元のリストをバインドする配列を作って、そして、多次元のリストを期待している構造が多次元が意図であることを知っているように、その約束をシギルとしてのスコープの残りを使って見えさせなければならない。

それは帰りの型を指定することを許される：

sub foo (**@slice --> Num) { ... }
 

インボカントはそれほど、多次元の引数リストで、参加しないself 中に存在しているではない**@slice 下に：

method foo (**@slice) { ... }
 

** マーカーがただ変形に過ぎないの* 終わる目標がバインディングであるとき要求側区画上がる（根本的に呼び出している.getarg） flatening として個別の要素を求めるよりむしろ* 雌鹿（根本的に呼び出している.get）.

もしあなたが括弧なしで関数を呼び出して、そして引数を供給しないなら、引数リストはゼロ - 次元のスライスになる。 それは異なるから\() いくつかの意味で：

sub foo (**@slice) {...}
foo;        # +@slice == 0
foo();      # +@slice == 1

sub bar (|$args = \(1,2,3)) {...}
bar;        # $args === \(1,2,3)
bar();      # $args === \()
 

飼料演算子のいずれかを使うことによって、 variadic リストはサブルーチン呼び出しについて標準の引数リストから別にパスされることができる：<== あるいは==>. 　Syntactically 、演算子がどちらかの端に文を見いだすために期待する飼料。 Any 文がソースの終わりで起こることができる；しかしながら、すべての文が送信の流しの終わりの使用のために適切であるわけじゃない。

演算子が variadic レシーバーへの呼び出しをその「鮮明な」終わりで、そして値のリストをその「率直な」終わりに見いだすために期待するそれぞれ：

grep { $_ % 2 } <== @data;

@data ==> grep { $_ % 2 };
 

それは鮮明な終わりで鈍い終わりから受話器の素晴らしいパラメータまで（潜在的にいい加減な）リストをバインドする。 variadic 関数であるレシーバーに関しては、飼料はその素晴らしいリストの一部として受け取られる。 それで上の呼び出しの両方ともが同等の値：だ

grep { $_ % 2 }, @data;
 

すべてのそのような送信（そして本当にすべていい加減な引数リスト）がリストを作り出しているコードが、コードがリストを受け取るという状態で、並列に実行するかもしれないという暗黙の約束を供給することに注意を払え。 （放送、超演算子とジャンクションがすべて共通で parallelizability のこの約束を持っているが、接合点で異なる。 これらの約束を破るコードは誤っていて、そして、 parallelized されるとき、未定義の結果を産み出すだろう。）

しかしながら、放送が明示的に平行した自制：それらを実施することにおいて普通のいい加減なリストが率直な終わりを（多分協力的な） subthread を始めるクローンされたクロージャとして取り扱うより少しさらに行く。 クロージャがクローンされる、そして subthread が生成される時に目に見える内面的なスコープによって外の範囲と共有された唯一の変数が外の範囲に宣言されたそれらの語彙の変数だ。 そんなものの使用が、変数が自動的に transactional 保護の適用を受けるだろうという考えを共有した（そして間接費を関連づけた）。 語彙の名前として前もって宣言されないなら、パッケージ変数がクローンされないでour. 　率直な終わりの中で宣言された変数は外に目に見えない、そして実際ではないがどうにかしてカーリーで囲った率直な終わりで語彙を宣言することは非合法だ。

放送がいい加減なパイプと定義されるから、供給装置のチェーンが始まって、そして何らかの種類の熱心なシーケンスポイントなしで同じ配列で終わらないかもしれない。 すなわち、これはうまくいくことを保証されない：

@data <== grep { $_ % 2 } <== @data;
 

これらのいずれかがそうする：

@data <== grep { $_ % 2 } <== eager @data;
@data <== eager grep { $_ % 2 } <== @data;
 

推測：もしプロセスが熱心に繰り返すクローニング@dataそれ働くことを強いられることができる. 普通のクローンがただ、値ではなく、コンテナをクローンするから、もしこれが望ましいなら、きれいになるな。

左方の送信は演算のチェーンを通して明示的に典型的な右から左のデータの流れを示す都合が良い方法だ：

@oddsquares = map { $_**2 }, sort grep { $_ % 2 }, @nums;

# perhaps more clearly written as...

@oddsquares = do {
    map { $_**2 } <== sort <== grep { $_ % 2 } <== @nums;
}
 

右への送信は左から右にそれを読ませる、演算のチェーンで、標準のデータフローを逆にする都合が良い方法だ：

@oddsquares = do {
    @nums ==> grep { $_ % 2 } ==> sort ==> map { $_**2 };
}
 

何かが好むことを注意するdo 供給装置が文レベルで稼働するから、必要だ。 文が内部に期待されるから、括弧が同じく働くだろう：

@oddsquares = (
    @nums ==> grep { $_ % 2 } ==> sort ==> map { $_**2 };
);
 

けれども下記のように、あなたは同じくただ書くことができる：

@nums ==> grep { $_ % 2 } ==> sort ==> map { $_**2 } ==> @oddsquares;
 

もし送信の鮮明な終わりのオペランドが variadic 演算に呼び出しじゃないなら、それはリストレシーバー、あるいはそうであり得る展開式がそれがするオブジェクトを作成するために評価したスカラーとして解釈されることができる他に何かに違いないKitchenSink ロール、そんなものけれどもIO オブジェクト。 このようなオブジェクトは供給する.clear そして.push 送信データに適切に呼び出されるであろうメソッド。 （それに注意するIO シンクとして使用されたオブジェクトがそのパイプラインで熱心な評価を強制するだろう、それで、ファイルが閉じられるまで、次の文は走らないことを保証される。 それと対照的に、Array シンクとして使用されたオブジェクトがいい加減な配列に変わる。）

Any 非 variadic オブジェクト（そんなものけれどもArray あるいはIO オブジェクト）、2つの送信の間のフィルターが特別にただデータ en passant を取り込む軽打として取り扱われる（とき・から・につれて・ように）、使う. あなたは意味規則を変えないで安全にこのような蛇口を拡張されたパイプラインにインストールすることができる。 IO 意欲がその代わりに下流の放送によってコントロールされるから、盗聴器として使用されたオブジェクトが熱心な評価を強制しない。

Any 接頭辞リスト演算子が variadic 演算だと見なされる、それで通常リスト演算子が何でもそのリストの終わりにインプットを入れると付け加える。 しかし時々あなた何でも contextualizer するそれほど、ほかのところに、補間挿入するべき渇望* 引数が一時的な配列の使用なしで放送のターゲットを示すために使われるかもしれない（とき・から・につれて・ように）：

foo() ==> say @(*), " is what I meant";
bar() ==> @(*).baz();
 

Likewise, an Array 軽打が区別されるかもしれないように、使うArray 翻訳関数として使用された：

numbers() ==> @array ==> bar()          # tap
numbers() ==> @array[@(*)] ==> bar()    # translation
 

次のシンクに多数のソースを付加するために、角度を2倍にしろ：

my $sink;
0..*       ==>  $sink;
'a'..*     ==>> $sink;
pidigits() ==>> $sink;

# outputs "(0, 'a', 3)\n"...
for $sink.zip { .perl.say }
 

おのおののそのような付加が、シンクに、もう1つのスライス要素（すなわち、区画）を加える。 （オリジナルの飼料は同じく区画を作った。）

あなたは変数（あるいは変数宣言）を管財人として使ってもよい、そしてその場合リスト値は変数の「todo」としてバインドされる。 （付加形式は受話器のするべきことのリストに付加 todos をバインドする。） また、普通のバインディングとして、それを割り当てであると考えなくはない。 それをイテレータ作成であると考えろ。 スカラー変数に関しては、その変数はそれ自身新たに作成されたイテレータを含んでいる。 配列に関しては、配列を拡張することに対して、新しいイテレータはメソッドとしてインストールされている。 割り当てと同じように、古いするべきことのリストは激しく打たれる；付加形式をそれを避けて、そして推薦意味規則を得るために使え。 何ででも配列を食べさせている場合が常に平らになる。 あなたはスカラー形式をスライス情報を維持するために使わなくちゃならない。

一般にあなたはあなたが等しく何でも書くことができる、それほど、チェーンの結果を表すこととしてただ受話器配列について考えることができる：

my @oddsquares <== map { $_**2 } <== sort <== grep { $_ % 2 } <== @nums;

my @oddsquares
    <== map { $_**2 }
    <== sort
    <== grep { $_ % 2 }
    <== @nums;

@nums ==> grep { $_ % 2 } ==> sort ==> map { $_**2 } ==> my @oddsquares;

@nums
==> grep { $_ % 2 }
==> sort
==> map { $_**2 }
==> my @oddsquares;
 

飼料イテレータが最終の変数の中にバインドされるから、変数は値を作成している送信と同じぐらいいい加減であり得る。

放送が「推薦」意味規則で配列にバインドされるとき、あなたは多数の放送のためにレシーバーを持っていることができる：

my @foo;
0..2       ==>  @foo;
'a'..'c'   ==>> @foo;
say @foo;   # 0,1,2,'a','b','c'
 

放送がどのように中に連結されるかに注意しろ@foo それでそれ@foo 6つの要素のリストだ。 これは省略時動作だ。 どんなに、時々、あなたが欲するとしても、キャプチャに2つのイテレータ、すなわち、2（人・つ）を表す2つのイテレータのリストとしてのアウトプットは放送を入力する。 権限：が、その代わりにスカラーを使うことによって、それらで2つのイテレータを得る、それはそうであり得る構造がとしてスライス、そんなものとしてどのように区画のリストを取り扱うべきか知っているどんな演算にでも入ったスライスを保存するだろうzip：

0..*       ==>  $foo;
'a'..*     ==>> $foo;
pidigits() ==>> $foo;

for $foo.zip { .say }

    [0,'a',3]
    [1,'b',1]
    [2,'c',4]
    [3,'d',1]
    [4,'e',5]
    [5,'f',9]
    ...
 

ここで$foo それほど、3つの区画のリストだ

$foo.zip
 

匹敵するものはそうするはずだ

my (@a,@b,@c) := |$foo;
zip(@a; @b; @c)
 

括弧の中のセミコロンが入念にまとめあげられた放送と等しい。 上記のコードは書き直されることができたけれども :

(0..*; 'a'..*; pidigits()) ==> my $foo;
for $foo.zip { .say }
 

順番に同等であるそうすること

for zip(0..*; 'a'..*; pidigits()) { .say }
 

あなたが普通のリスト演算子じゃない展開式に入ることを望み、そしてあなたが飼料の目的地がどこにあるはずであるか明確であることを望むとき、名指された受話器配列が有用だ：

picklist() ==> my @baz;
my @foo = @bar[@baz];
 

種々のコンテキストが多次元のスライスあるいは供給装置を期待しているかもしれない、あるいはそうしないかもしれない。 配列が平らにされる普通のデフォルトまでに素晴らしいコンテキスト、すなわち、それらが「リスト」意味規則を持っている。 もしあなたが言うなら

(0..2; 'a'..'c') ==> my @tmp;
for @tmp { .say }
 

それからあなたは0,1,2、「a’」、をb’に連れて行く」、c’。 もしあなたが多薄暗い配列を持っている、あなたがそうすることができるなら、明示的に意味規則を平らにすることを招けflat：

(0..2; 'a'..'c') ==> my $tmp;
for $tmp.flat { .say }
 

我々がそれより前に、「活気」を見た（とき・から・につれて・ように）、それぞれのリストからのOR素子を、順番に、そうにすることによって、インタリーブされた結果を産み出す

(0..2; 'a'..'c') ==> my $tmp;
for $tmp.zip { .say }
 

0、「1」、1インチ、b’、2インチ、c’を作り出す。

もしあなたが活気の結果を subarrays のリストとして望むなら、あなたは「ずんぐりした」に活気自身を注ぐ必要があるLoL その代わりにコンテキスト：

(0..2; 'a'..'c') ==> my $tmp;
for $tmp.zip.lol { .say }
 

これはそれぞれのラインの上に2つの値を作り出す。 けれども通常、あなたがただシグネチャーに直接それをバインドすることができるように、あなたは平らな形式を欲する：

for $tmp.zip -> $i, $a { say "$i: $a" }
 

さもなければあなたはこれを言わなければならないだろう：

for $tmp.zip.lol -> [$i, $a] { say "$i: $a" }
 

推測で：スライスが多数の添え字に変わるように、添え字の中に放送を補間挿入するために、あなたは使う必要があるprefix:<||>それが、フラットなリストレベルよりむしろ：スライスレベルにおいて補間挿入されること以外どちらが prefix:<|> とまったく同じように効果があるか

(0..10; 0..10).zip
zip(0..10; 0..10)
(0..10; 0..10) ==> zip( ||@(*) )
(0..10; 0..10) ==> $feed; zip( ||$feed )
 

通常ただメソッド形式を使うほうが良い。

現在の定義で、放送の命令が管財人のポジションにかかわらず一般に左から右に維持されることに注意を払え。

それで

('a'..*; 0..*) ==> $feed;
 for $feed.zip <== @foo) -> $a, $i, $x { ... }
 

同じであるけれども

'a'..* ==> $feed;
 0..*  ==>> $feed;
 for $feed.zip <== @foo) -> $a, $i, $x { ... }
 

同じがどちらとしてか

for zip('a'..*; 0..*; @foo) -> $a, $i, $x { ... }
 

普通の配列のために同一であるために同じくこれらが出て来ることに注意を払え：

@foo.zip
@foo.cat
 

パラメータが宣言したで& シギルがブロック、クロージャ、あるいはサブルーチンをそれら引数として連れて行く。 クロージャパラメータが必要とされることができる、名指されているか、あるいは素晴らしいオプション。

sub limited_grep (Int $count, &block, *@list) {...}

# and later...

@first_three = limited_grep 3, {$_<10}, @data;
 

（コンマはクロージャの後に必要とされる。）

サブルーチンの中で、パラメータがそうであり得るクロージャは何のようにでも他のレキシカルにスコープ宣言されたサブルーチンを使った：

sub limited_grep (Int $count, &block, *@list) {
    ...
    if block($nextelem) {...}
    ...
}
 

クロージャパラメータは型仕様のそれ自身のシグネチャーが書かれるようにすることができる:(...)：

sub limited_Dog_grep ($count, &block:(Dog), Dog *@list) {...}
 

そして帰りの型さえ：

sub limited_Dog_grep ($count, &block:(Dog --> Bool), Dog *@list) {...}
 

引数がこの種類のシグネチャーを持っているクロージャパラメータにパスされるとき、引数はそうに違いないCode 互換性がある引数リストのオブジェクトとリターン型。

標準のパラメータと異なり、型パラメータがしばしば実際の（人たち・もの）に便乗されて入ってくる、「種類」とあなたとしての値が方法が欲しい、からすぐにキャプチャが値とその種類両方が欲しい。 （「種類」は記憶域型、すなわち、クラスあるいはオブジェクトがそうであることを可能にされる型だ。 公式に制限されたあるいは contravariant の型を雇うことを許されたオブジェクトではない。） 型変数がどこでも使われることができる、型名が型をホールに入れて、しかし、値がそうしなくちゃならないと断言する代わりに、詳細に順応させる、それはオブジェクトの実際の「種類」をとらえて、そして同じくパッケージ / 型を（それによって）あなたがシグネチャーあるいは体遅くにその種類を参照することができる名前だと宣言する。 付加、それでキャプチャ、何もの名目上のタイピング、が名目上の型を関連づけた。 例えば、もし、それらが同じ種類の（こと・もの）である限り、あなたが2がつきまとう何かとマッチすることを望んだなら、あなたは言うことができる：

sub matchedset (Dog ::T $fido, T $spot) {...}
 

これは実際にさらに多くが好きである何かに変わる

sub matchedset (Dog ::T $fido, Dog $spot where T) {...}
 

それに注意しろ::T 含んでいるために必要とされるではないDogただそれがそれと互換性がある型Dog. 　、名目上の人たちがタイプするとは、同じく注意しろDog同じく意味に含められのT実際の型が記憶域型とマッチするに違いない概念とともに$fido.

:: 準シギルは同じようにそれで「サブセット」の省略だ& 「sub」の省略だ。 同じぐらい& 同じく、それほど、コードについて親切な何にでも名前をつけるために使われることができる:: 何でも型の種類と命名するために使われることができる。 それらが異なった構文的なスポットを埋めるけれども、それらの両方ともがそのままの識別子をシンボルテーブルに挿入する。

あなたがそれを欲しないなら、オブジェクトがクラスと結び付けたキャプチャに必要とされてそれがそうじゃないことに注意を払え。 上の sub は書かれることができたけれども

sub matchedset (Dog ::T, T) {...}
 

もし我々が中に興味を持っていないなら$fido あるいは$spot. 　あるいはただ

sub matchedset (::T, T) {...}
 

もし我々がマッチしている（人たち・もの）以外の何のことも気にかけないなら。 2番目のパラメータが最初よりさらに多くによって得られているかもしれないとは、ここで注意しろ。 もしあなたがそれらを同一であるために必要とするなら、あなたは何かが好むと言わなくちゃならない

sub matchedset (::T, $ where { $_.WHAT === T }
 

配列パラメータを配列として明示する代わりに：

sub quicksort (@data, $reverse?, $inplace?) {
    my $pivot := shift @data;
    ...
}
 

それはパラメータの、それが匿名の配列であるかのように、パラメータを指定することによってのシグネチャーのコンポーネントの中に壊されるかもしれない：

sub quicksort ([$pivot, *@data], $reverse?, $inplace?) {
    ...
}
 

このサブルーチンはただ最初のバージョンのように、その最初の引数としてまだ配列を期待する。

素晴らしいリストの最初の要素とマッチするために、「素晴らしい」スカラーを使え：

sub quicksort (:$reverse, :$inplace, *$pivot, *@data)
 

権限：が、ノード自身の宣言の後に子ノードと属性のバインディングを括弧に同封することによって、ハッシュ値と種々のその通りにやる方法でのツリーノードをアンパックする：

sub traverse ( BinTree $top ( $left, $right ) ) {
    traverse($left);
    traverse($right);
}
 

これで、$left そして$right 木の左と右のノードに自動的に境界だ。 もし$top 普通のオブジェクトが、それはバインドするということである$top.left そして$top.right 属性。 もしそれがハッシュが、それはバインドするということであるなら$top<left> そして$top<right>. 　もしBinTree 型と $top がそうであるシグネチャーであるCapture （引数リスト）オブジェクト、シグネチャーの子型は実際の（人たち・もの）に適用される、引数での引数がオブジェクトをリストする。 （あなたが位置の引数で裏返しにしてそれらをコンストラクタだと見なすことができるとは、シグネチャー型が、変換が逆戻り可能であり得るように利益を持っている。）

しかしながら、シグネチャーのフルの力は当てはまられることができる、ある場合には逆の変換ではない derivable であるけれども、パターンがただ何についてでも引数あるいは引数のセットとマッチする。 例えば、から名指された子供たちについて配列にバインドしろ.kids あるいは.<kids>使用何かが好む：

proto traverse ($) {*}
multi traverse ( NAry $top ( :kids [$eldest, *@siblings] ) ) {
    traverse($eldest);
    traverse(:kids(@siblings));  # (binds @siblings to $top)
}
multi traverse ( $leaf ) {...}
 

パラメータがその両方にバインドされることができない場合に限り、2番目の候補者は呼び出される$top そしてサブパラメータを解析している「子供たち」に。

同じく、ハッシュにノードの要素をバインドして、そして次にキーにそれで名前：によってのハッシュをバインドするために

sub traverse ( AttrNode $top ( :%attr{ :$vocalic, :$tense } ) ) {
    say "Has {+%attr} attributes, of which";
    say "vocalic = $vocalic";
    say "tense = $tense";
}
 

もしあなたがシグネチャーを示すために括弧にコロンを前接続するなら、あなたはトップの変数を除いてもよい。 さもなければあなたは少なくとも変数のシギルを置かなくちゃならない、あるいは我々は正確に区別をつけることができない：

my Dog ($fido, $spot)   := twodogs();       # list of two dogs
my Dog $ ($fido, $spot) := twodogs();       # one twodog object
my Dog :($fido, $spot)  := twodogs();       # one twodog object
 

sub シグネチャーが使用方法によって正規表現の中で直接合われることができる:(...) 注釈。

push @a, "foo";
push @a, \(1,2,3);
push @a, "bar";
...
my ($i, $j, $k);
@a ~~ rx/
        <,>                         # match initial elem boundary
        :(Int $i,Int $j,Int? $k)    # match lists with 2 or 3 ints
        <,>                         # match final elem boundary
      /;
say "i = $<i>";
say "j = $<j>";
say "k = $<k>" if defined $<k>;
 

もしあなたがパラメータを欲するなら、バインドしろ$/あなた言わなければならない$<i> シグネチャーの中で。 さもなければそれは外部をバインドしようとするだろう$i その代わりに、そしてもしこのようなどの変数も宣言されないなら、失敗しろ。

sub 宣言と異なり、正規表現 - 埋め込みのシグネチャーが関連づけられた「帰り」の構文的なスロットを持たない、それであなたが使わなければならないことに注意を払え--> 指定するべきシグネチャーの中でof arglist としてのシグネチャー、あるいはマッチの型：

:(Num, Num --> Coord)
:(\Coord(Num, Num))
 

あなたが一緒にオブジェクトの型とマッチすることができる形式がそうである後者の結果:(\Dog) そのコンポーネントの中に実際にそれを壊さないで。 しかしながら、それが言うために同等じゃないとは注意しろ

:(--> Dog)
 

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

:(\Dog())
 

すなわち、型の nullary 関数とマッチするDog. 　同様にそれは同等じゃないそうすること

:(Dog)
 

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

:(\Any(Dog))
 

そして型 Dog の一つのパラメータをとっている関数とマッチする。

同じくそれほどそのままに注意しろ\(1,2,3) 最初の（エスケープされた）括弧が文字通りにマッチしようとするであろうときから、正規表現で決して正当じゃない。

もしパラメータがそれと共に宣言されるサブメソッドの. あるいは! （属性のような）シギルの後に：

submethod initialize($.name, $!age) {}
 

それで引数はオブジェクトの同一名の属性に直接バインドされる。 これはコードを書くべき頻繁な必要を避ける：

submethod initialize($name, $age) {
    $.name = $name;
    $!age  = $age;
}
 

属性の初期化は特別な処理がカプセル化を維持することを必要とする；そのために属性を表わすパラメータのためのデフォルトは意味規則、それが、指定されるかのように、ある値だis copy. 　従って、上のサブメソッドは本当にもっと多くの同種のものだ：

submethod initialize($name is copy, $age is copy) {
    $.name := $name;      # or maybe = here, since it's a parent's attr
    $!age  := $age;       # or maybe only $! parameters work really
}
 

もしあなたがユーザーが参照までに属性を初期化することを可能にすることを望むなら、あなたは明示的にあなた自身の初期化演算子サブメソッドを書くか、あるいはただあなたが一緒にあの方角を働かせることを望む属性に記録を残してもよいis ref：

has $!age is ref;   # BUILD will automatically use ref binding, not copy
 

属性パラメータを改名するために、あなたは明示的なペア形式を使うことができる：

submethod initialize(:moniker($.name), :youth($!age)) {}
 

:$name ショートカットが結合されるかもしれないで$.name ショートカットした、しかし twigil はそれほど、引数名のために、無視される

submethod initialize(:$.name, :$!age) {}
 

同じであるけれども :

submethod initialize(:name($.name), :age($!age)) {}
 

それに注意しろ$!age 実際にプライベートに言及する「has」いずれかと呼ばれることができる変数$age あるいは$!age.

すべてのそのままのブロックがクロージャであるけれども、そのままのブロックが明示的なパラメーターリストを持つことができない。 その代わりに、それらがキャレットによって記録されている「プレースホルダー」変数を使う（^）あるいはコロン（:）それらシギルの後に. キャレットは守備のプレースホルダーを記録を残す、他方コロンは名指されたプレースホルダーを記録を残す。

ブロックでプレースホルダーを使うことは暗黙の引数リストを定義する。 シグネチャーは通り過ぎて、 Unicode オーダーでソートされて、続いて、異なった守備のプレースホルダー名のリストだ、何での名指されたプレースホルダー名でも命令する。 それで：

{ say "woof" if $:dog; $^y < $^z && $^x != 2 }
 

賛成の速記：だ

-> $x,$y,$z,:$dog { say "woof" if $dog; $y < $z && $x != 2 }
 

プレースホルダー変数が統語論上型制約を持っていることができないとは、注意しろ。 同じく、すでにシグネチャーを持っているブロックでプレースホルダー変数を使うことは非合法だ、なぜなら自動的に生み出されたシグネチャーはそれと対立するだろうから。 我々が卑劣であるからではなく、一つの大文字の英字から成り立っている守備のプレースホルダー名が拒否される、しかしそれが我々に手を貸すから、 Perl 5 変数を時代遅れにする参照のためにそんなものを捕えろ$^O.

$_ ブロック何なしででも他のプレースホルダーのプレースホルダーとしての変数関数、あるいはシグネチャー。 Any はそのままのブロックプレースホルダーなしで本当にこのようなパラメータを持っている：

-> \$_ = OUTER::<$_> { .mumble }
 

（しかしながら、文制御if これに気付いて、そして、それほど、引数をパスしない$_ 外の（人たち・もの）にバインドされることになる$_ とにかく。）

ブロックが同じくいずれかに言及するかもしれない@_ あるいは%_ あるいは両方とも、どちらが増やされるであろうかのそれぞれは標準の読み取り専用の素晴らしい pararmeter としてシグネチャーを生成した：

{ say $:what; warn "bad option: $_\n" for keys %_; }
 

中に変わる

-> :$what, *%_ { say $what; warn "bad option: $_\n" for keys %_; }
 

もし使われないなら、それらは付加的、そして間違えてパッチを当てられたパラメータを持っているディスパッチの意志ではなくが衰えるということだ。

P5ish の使用@_ signatureless で sub が当然これから落ちる：

sub sayall { .say for @_ }
 

それほどこの場合、注意しろ$_ すでにあるから、ではないがプレースホルダーとしておごった@_ プレースホルダー。 そして@_ ただ sub が公式のシグネチャーを持っていないから、プレースホルダーだ。 さもなければ、（明示的に宣言されないなら）、それは非合法だろう。

プレースホルダーは同じく正式のシグネチャーを持っていないメソッドのボディーで使われるかもしれない。 インボカントは常に最初に取り去られる、それで最初のプレースホルダー引数は常に最初の非インボカントの引数に言及する。 @_ 決してインボカントを含んでいないだろう。 インボカントは常に利用可能であるとしてselfもちろん。

プレースホルダーが twigil なしでパラメータ変数を宣言するから、 twigil はただブロックの中で変数の最初の発生の上に必要とされる。 その変数の次の投稿が twigil を除くかもしれない。 内部の入れ子ブロックの中で、それが不当に内側ブロックに付着するであろうときから、 twigil は除かれなくちゃならない。

Perl 5 の場合と異なり、それに注意しろ@_ 内側ブロックの中で外側ブロックの引数に言及するために使われないかもしれない：

sub say-or-print {
    if $SAYIT {
        say @_;     # WRONG
    }
    else {
        print @_;   # WRONG
    }
}
 

なぜならこの desugars 値：

sub say-or-print {
    if $SAYIT -> *@_ {
        say @_;
    }
    else -> *@_ {
        print @_;
    }
}
 

Perl 5 の翻訳者がこれを心に留めておく必要があるだろう。

プロパティがそうであるコンパイル時が「トレイト」を呼び出した。 is NAME (DATA) 構文がコンテナとサブルーチンの上のトレイトを、それら宣言の一部と定義する：

constant $pi is Approximated = 3;   # variable $pi has Approximated trait

my $key is Persistent(:file<.key>);

sub fib is cached {...}
 

will NAME BLOCK 構文が同義語である賛成is NAME (BLOCK)：

my $fh will undo { close $fh };    # Same as: my $fh is undo({ close $fh });
 

but NAME (DATA) 構文が値に実行時プロパティを指定する：

constant $pi = 3 but Inexact;       # value 3 has Inexact property

sub system {
    ...
    return $error but False if $error;
    return 0 but True;
}
 

プロパティがロールとして前もって宣言されて、そしてミキシンとして実装される － S12 を見ろ。

これらのトレイトは全体としてサブルーチンで宣言されるかもしれない（個別のパラメータが他のトレイトをとる）。 トレイト構文はあなたが使う特定の補助員の上、しかし賛成に依存するis次の構文は副詞の構文とまったく同じだが、そのコロンが除かれるか、あるいは2倍にされるかもしれないこと以外上に依存して、あいまい性の学位は望んだ：

sub x() is ::Foo[...]       # definitely a parameterized typename
sub x() is :Foo[...]        # definitely a pair with a list
sub x() is Foo[...]         # depends on whether Foo is predeclared as type
 

is signature

サブルーチンのシグネチャー。 通常、引数リストそして／あるいは戻型を提供することによって、暗黙のうちに宣言される。

as/ is as

inner ルーチンがその帰りの値に押し付ける型ぎごちなさ。

of/ is of

of ルーチンの公式の帰りの型である型。 あるいはあなたは "of" を正式の外の / と考えることができる。 もし内部の型がないなら、外の型は帰りの値を拘束するために同じく内部の型として勤める。

will do

サブルーチンが呼び出されるとき、コードのブロックは実行した。 通常、サブルーチンのシグネチャー鮮明度の後にブロックを供給することによって、暗黙的に宣言される。

is rw

左辺値を返すとして、サブルーチンを記録を残す。

is parsed

（それによって）マクロ呼び出しが解析されるサブルールを指定する。 解析は常にマクロの最初のトークンの後に始まる。 もし演算子が2つの部分（接周辞あるいは後置接周辞）を持っているなら、最終のトークンは同じく自動的に一致されて、そして供給された正規表現によって一致されるべきじゃない。

is reparsed

同じく（それによって）マクロ呼出しが解析されるサブルールを指定するが、通常あなたが解析をすることを望むからそれが期待する存在する規則を最初のトークンをくまなく渡り歩くために使って、マクロの最初のトークンの前に解析を再開する。 もし演算子が2つの部分（接周辞あるいは後置接周辞）を持っているなら、最終のトークンは同じく明示的に供給された正規表現によって合われなくちゃならない。

is cached

メモ化されるとして、あるいは最少の memoizable でサブルーチンを記録を残す。 抽象的に、入ってくる引数である場合は、この隠し場所はただハッシュに過ぎないCapturesが値を返すために地図に表わされる。 もしCapture ハッシュで見いだされる、帰りの値は計算し直される必要がない。 もしあなたがこのトレイトを使うなら、コンパイラは2つのことを仮定するだろう：

• 既定の事実Capture 常に同じ帰りの値を計算するだろう。 すなわち、呼び出しのダイナミックスコープの中で隠されるステートがない。

• キャッシュルックアップは、あるいはたいていの uncachedな呼び出しがより遅いであろうから、少なくとも若干のケースで値を計算し直すよりいっそう効率的である可能性が高い（そしてスループットを減らす）、あるいはあなたは重要な数の容認できないほどゆっくり進行する病理学上のケースを避ける（そして潜伏期を増やそう）としている。

このトレイトはキャッシングが問題がないというコンパイラへの提案だ。 コンパイラは（非 - 期限が切れること、ランダム、 lru 、擬似 lru 、あるいは適応性がある algoritms 、あるいはまったくアルゴリズムをキャッシュすることさえ含めて）まあアルゴリズムをキャッシュして何も選択しないために無料だ。 実行時システムは無料だ、から記憶と使用法パターンの傾向の有効性の上に依存して何でもまあ言わば最大キャッシュのサイズに選べ。 あなたは特定の隠し場所がパスすることによって数の引数のサイズを定めることを提案するかもしれない（最大値を表すのユニークCapture 許された値）、そしてアルゴリズムが注意を払うかもしれない可能性のいくらかそれ. あなたは同じくパスするかもしれない* 大きさが non-expiring キャッシュ（完全な memoization）を求めるために。 コンパイラは同じくこれを無視することが自由だ。

このトレイトの意志は業績が何も義務化しないで正確な振る舞いをヒンティング処理することを明示することだ。 このトレイトの適切な使用がプログラムの意味規則を変えるべきじゃない；それは一種の「プラグマ」として機能する。 このトレイトは同じ影響を達成する他の存在する方法で再発明するために延長されないだろう。 もっと多くの管理を増して、いっそう特定のトレイトの、用途にそんなものを許すべきあなた自身のトレイト調教師に手紙を書くこと「is lru(42)」. 代わる代わる、ただ sub の引数キャプチャに調律された公式のハッシュをあなたのサブルーチンの周りにサブルーチン自身の中から、あるいはラッパーの中から完全なコントロールであなた自身の memoization を書くために使え。

is tighter/ is looser/ is equiv

存在する演算子と比較して演算子の優先を指定する。 tighter そしてlooser 優先が、左連想であることに、デフォルトを平らにする。 どのそれらかについて、それらが優先レベルよりもっときついか、あるいはもっと緩い新しい優先レベル slighty を定義する基礎を置かれる. 両方ともtighter そしてlooser 指定されるかもしれない、指定されたレベルの間に新しい優先レベルがどちらのケースに中途で生成されるか。

同じ優先導出を使った2つの異なった宣言が同じ優先レベルにおいて終わる、かのようにequiv その代わりに指定されのtighter/ looserそして2番目の意志クローン、最初の結合性。 もし第2が明示的に初めから異なる結合性を指定するなら、意外なパージング競合が結果として生じるかもしれない。 （S03 を見ろ。）

優先レベルを複製することに加えて、equiv それが新しい演算子が等しい演算子と同じであるためにデフォルト結合性を指定するように、同じく他のトレイトをクローンする。 もしいずれもなら、次のことは種々の構文カテゴリのためにデフォルト同等物だequiv 同様にassoc 指定される。 （これらの多くが優先の必要を持っていない、あるいは結合性がそれらが存在するから特別に解析をした。 にもかかわらず、equiv これらの演算子の他のトレイトをクローンすることに役立つかもしれない。）

category:<prefix>
circumfix:<( )>
dotty:<.>
infix:<+>
infix_circumfix_meta_operator:['»','«']
infix_postfix_meta_operator:<=>
infix_prefix_meta_operator:<!>
package_declarator:<class>
postcircumfix:<( )>
postfix:<++>
postfix_prefix_meta_operator:['»']
prefix:<++>
prefix_circumfix_meta_operator:['[',']']
prefix_postfix_meta_operator:['«']
q_backslash:<\\>
qq_backslash:<n>
quote_mod:<c>
quote:<q>
regex_assertion:<?>
regex_backslash:<w>
regex_metachar:<.>
regex_mod_internal:<i>
routine_declarator:<sub>
scope_declarator:<my>
sigil:<$>
special_variable:<$!>
statement_control:<if>
statement_mod_cond:<if>
statement_mod_loop:<while>
statement_prefix:<do>
term:<*>
trait_auxiliary:<is>
trait_verb:<of>
twigil:<?>
type_declarator:<subset>
version:<v>
 

存在する演算子は関数オブジェクトとしてあるいは完全な機能名で使われるであろう（の・もの・人）と等しい文字列引数として指定されるかもしれない。 文字列形式で構文カテゴリは新しい宣言と同じだと考えられるだろう。 そのためにこれらはすべて同じ影響を持っている：

sub postfix:<!> ($x) is equiv(&postfix:<++>) {...}
sub postfix:<!> ($x) is equiv<++> {...}
sub postfix:<!> ($x) {...}      # since equiv<++> is the default
 

識別子である Prefix 演算子が特別に扱われる。 1つの引数と一緒の形式は自（己・動）増加優先の代わりに名指された単項の優先をデフォルトとする：

sub prefix:<foo> ($x) {...}
foo 1, 2, 3;        # means foo(1), 2, 3
 

同じくメソッドのように呼び出しのように見える後置演算子が呼び出しをメソッドの優先にデフォルト設定することを強いられる。 たとえそれが識別子じゃないとしても、多数の引数を必要とする Any 接頭辞演算子がリスト演算優先をデフォルトとする：

sub prefix:<☎> ($x,$y) {...}
☎ 1;                # ERROR, too few arguments
☎ 1, 2;             # okay
☎ 1, 2, 3;          # ERROR, too many arguments
 

あなたは使わなくちゃならないprefix:<foo> 名指された単項演算子と解析するべき文法を突然変異させるためにできろ。 標準で、関数定義が決して一つの引数で文法を変えて、そして呼び出されるとき、たとえ定義されているとしても、常に listops として解析できない：

sub foo ($x) {...}  # a listop
foo(1), 2, 3;       # okay
(foo 1), 2, 3;      # okay
foo 1, 2, 3;        # ERROR, too many arguments
 

同じく0 - ary 関数が listops として解析をする。 使用term:<foo> （あるいは定数あるいは列挙型宣言）引数を期待しない項を宣言すること.

is assoc

明示的に演算子の結合性を指定する。 正当な値がそうだ：

Tag         Examples        Meaning of $a op $b op $c       Default equiv
===         ========        =========================       =============
left        + - * / x       ($a op $b) op $c                +
right       ** =            $a op ($b op $c)                **
non         cmp <=> ..      ILLEGAL                         cmp
chain       == eq ~~        ($a op $b) and ($b op $c)       eqv
list        | & ^ Z         op($a; $b; $c)                  |
 

それほど演算子的に注意する「equiv」リレーショナルに自動的に連鎖法演算子だと見なされる. レベル、連鎖法が有無によって決定される新しい優先順位を作るとき、「is assoc<chain>」そしてそのレベルで定義された他の演算子同じことであるように要求される.

指定するassoc 明示なしでequiv デフォルトを代用するequiv 結合性と矛盾しなくて、上記の最終のコラムで同じぐらい見せられている。

PRE/ POST

前に / サブルーチンのの後に無条件に実行されるはずであるこれらのフェーザ宣言文あるいはブロックdo ブロック。 それらが真の値を返さなくちゃならない、さもなければ例外がスローされる。

メソッドに適用されるとき、意味規則は OO プログラミングの「契約によってのデザイン」スタイルにサポートを提供する：もしすべてであるなら、特定のメソッドの前提条件が満たされるPRE そのメソッドと結び付けられるフェーザが真に戻る。 さもなければ、前提条件は満たされたもしだall 親クラスについて前提条件が満たされる（どちらが、もしそれらが回帰的に失敗するなどするなら、それら親クラスの前提条件を含むかもしれないか）

それと対照的に、もしすべてのメソッドのであるなら、メソッドの事後条件は満たされるPOST フェーザが真に戻る、そしてそのすべての親の後件は回帰的に同じく満たされる。

POST フェーザ（そして「will post」移相器トレイト）中で宣言するPRE あるいはENTER ブロックが外へ同時に他として呼び出されるために自動的に持ち上げられるPOST フェーザ。 これは、プリレキシカルスコープの中でポストレキシカルスコープをラップすることによって、好都合に「circum」に意味規則を与える。 すなわち、POST たとえそのスコープが時までになくなっているとしても、その外の範囲を包み込むPOST 動かされる。

method push ($new_item) {
    ENTER {
        my $old_height = self.height;
        POST { self.height == $old_height + 1 }
    }

    $new_item ==> push @.items;
}

method pop () {
    ENTER {
        my $old_height = self.height;
        POST { self.height == $old_height - 1 }
    }

    return pop @.items;
}
 

それに注意しろself メソッドの中で定義されたフェーザで利用可能だ。

不変量が一緒に宣言されるクラスPRE/ POST フェーザの代わりの submethods 。

不変量が一緒に宣言される Module PRE/ POST sub あるいは protos 。

［推測：記録を残すことによって、いっそう選択的に用いられたクラスとモジュール不変量の容器PRE/ POST 宣言でselective このモジュールのルーチンがそうであるそれが（不変量の一時的な違反を許すかもしれない）内部の呼び出し上で走るのを阻止するが、何でもとき、不変量を強いるトレイトが、どんなにそれが定義されるとしても、「外部」から最新のモジュールあるいは型と呼び出される。 このトレイトに外国のことのコンセプトを精製することができた引数があり得た。］

ENTER/ LEAVE/ KEEP/ UNDO/ など。

これらのフェーザはサブルーチンのの前か後に条件付きで実行されるはずであるコードを供給するdo ブロック（ただもしサブルーチンの中で最も外側のレベルで使われるなら；専門的に、これらは上にブロックトレイトに加えられるdo サブルーチンではなく、ブロックが反対する）。 これらのフェーザは一般にそれら副作用のためにだけ使われる、なぜならたいていの帰りの値が無視されるだろうから。 （しかしながら、標準の実行の前に走る Phasers がそれら値のために使われるかもしれない。）

次のトレイトはパラメータの多くの型に応用であり得る。

is readonly

パラメータが修正されることができないことを明示する（例えば、割り当てたから、増加する）. それはパラメータのためにデフォルトだ。 すでに不変の値である引数にそれはランタイムにおいての無操作命令だ；もし制約がコンパイル時間に完全に実施されることができないならそれが不変のエイリアスを作る必要があるかもしれない変更可能なコンテナ、変更可能なオブジェクト、の上。 読み取り専用パラメータへのバインディングが決して autovivification を引き起こさない。

is rw

パラメータが修正されることができることを明示する（割り当てられた、から、増加するなどした）. 対応する引数が左辺値であるか、あるいは1（人・つ）に変換されることができることを要求する。 必要とされる引数、それがそうすることができない力がそれと共存するこの選択から? マークが引数をオプションにする。 （それはそうするかもしれない、しかしながら、使われろ= デフォルトを示して、けれどもデフォルト展開式がコンパイル時間に名前が出せる何かとその容器を表す場合に限り、として左辺値、そんなものとしてバインドするCALLER::<$/> あるいはOUTER::<$_>.）

variadic パラメータに、応用されるとき、rw トレイトがリストのそれぞれの要素に申し込む：

sub incr (*@vars is rw) { $_++ for @vars }
 

（variadic 配列全体は常に modifiable だ、しかしこのような修正はオリジナルの引数リストに影響を与えない。）

is parcel

パラメータが「区画」としてパスされる、すなわち、生の参照として「挿入句のセル」あるいは「解析リスト」に、まだコンテキストを持っていなかった引数オブジェクトが押し付けたことを明示する。 （それは実際にそうであるかもしれない、あるいはそうしないかもしれないのParcel 型、それ以来Parcel 自動的にたった1つのオブジェクトを含んでいることは直接そのオブジェクトであるためにそれ自身の包みを解く。） 言い換えれば、これは関数呼び出しを通してさえいい加減な contextualization を提供する。 これは後にそのコンテキストを決定するであろう他の何かに前進的なパラメータでもしあなたがパスすることを望むなら重要だ。

あなたは引数が、異なり、すでに適切な左辺値である引数、しかしただもしだけを修正してもよいrwautovivification への試みはなし、もしあなたがルーチンのボディーの中でそれらを修正しようとするなら、左辺値が例外をスローするだろうほど不適当で、作られる. すなわち、もし autovivification が起きるなら、それは、バインディングのポイントでではなく、使用のポイントで起きる。

もっと良くビジュアル特質のために、このようなパラメータは、使うことによって、よりむしろバックスラッシュでプレフィックス変換によって宣言されるis parcel 直接。 バックスラッシュは同じくもっと多くの succint だ；トレイトは内省のために主にそこにある。

is copy

パラメータがオリジナルの引数の別の、読まれた - 書き込み可能なコピーを受け取ることを明示する。 これは一般に「値渡し」として知られている。

sub reprint ($text, $count is copy) {
    print $text while $count-- > 0;
}
 

コピーパラメータへのバインディングが決して autovivification を引き起こさない。

is dynamic

パラメータが「環境の」変数、すなわち、ダイナミックスコープからアクセス可能な語彙として取り扱われるはずであることを明示する（S02 参照）。

ASignature オブジェクトがパラメータの細部の外に、期待されるように、それが定義されることに気付くために introspected されることができる。 .params メソッドが戻るだろうParcel のParameter 次の読み取り専用プロパティを持っているオブジェクト：

  name           The name of the lexical variable to bind to, if any
  type           The main type (the one multi-dispatch sorts by)
  constraints    Any further type constraints
  type_captures  List of names the argument type is captured into
  readonly       True if the parameter has C<is readonly> trait
  rw             True if the parameter has C<is rw> trait
  copy           True if the parameter has C<is copy> trait
  named          True if the parameter is to be passed named
  named_names    List of names a named parameter can be passed as
  capture        True if the paramater binds the caller's Capture
  parcel         True if the parameter is too lazy to contextualize
  slurpy         True if the parameter is slurpy
  optional       True if the parameter is optional
  default        A closure returning the default value
  invocant       True if the parameter is a method invocant
  multi_invocant True if the parameter is a multi invocant
  signature      A nested signature to bind the argument against
 

それに注意しろconstraints もしそれがそうであるかもしれないという多くの制約があるなら、もしそれが定義されるなら；反対でスマートマッチされることができる何かだろうJunction ある種について、しかしもしただ1（人・つ）があるなら、それはただその1つのことであるかもしれない。

オリジナルの書面のシグネチャーに現われるそれ以上の、種々のものが少し deconstructed されてしまっているだろう。 例えば、シグネチャーが好む：

  :(1)
 

introspect を遺贈しろ：

  :(Int $ where 1)
 

そしてもし我々がそうしたなら：

  subset Odd of Int where { $^n % 2 };
  sub foo(Odd $x) { ... }
 

それで foo のシグネチャーは同等だろう、から何かが好む：

  :(Int $x where { $^n % 2 })
 

すなわち、詳細化型は名目上の型のそれほど多数のディスパッチが候補と追加の制約をソートするために使う部分に deconstructed されてしまっているだろう。

それは、もし特に求められるなら左辺値がただ上がって戻って来るべきである一般的なポリシー、ダイナミックな呼び出し山、だ。 そのために、返送された引数が共に最後の文から暗黙のリターンのためにこれを適用するために、処理されているデフォルトまでに何でも、次のような演算子によってされた明示的な復帰と同様、ブロックする

return
leave
take
 

特に、この処理は返送された区画の引数を調べることを必要とする、そして何でもデリファレンスすること、それをコンテナの値で置き換えて、左辺値として使われることができたコンテナ。

ルーチンのためにこの処理をオーバーライドするために、それは宣言されなくちゃならないrwあるいは形式return-rw 使われなくちゃならない。

賛成のオーバライドにgather使用gather-rw instead, or take-rw 個別の撮影で。

ブロックが一般にトレイトを持っていないから、あなたは使わなくちゃならないleave-rw パスするために、ブロックの終了の外の左辺値。

return 関数が観念的にそれが同封してレキシカルに流れによってとらえられるコントロールの例外をスローするRoutine 中間ブロックが作成する何の制御論理コードを通しての帰りでも強制するために。 （すなわち、それはこのルーチンに属している適切なレキシカルスコープに動的有効範囲の山をほどかなくちゃならない。） 標準のブロックで（決まった場所で自動的に実行されるそれらなぜならそれら知られているからコンパイラ）このくつろぐことは多分「行け」に離れて最適化されることができる. すべてRoutine 宣言が明示的な宣言詞を持っているようsub あるいはmethodそのままのブロックと「pointy」ブロックが決してその意味で定常課程であると見なされない。 ブロック、使用から戻るためにleave その代わりに － 下を見ろ。

return 関数がその引数リストを維持する as a Capture オブジェクト、そして左手に反応するSignature バインディングで。 これは名指された復帰を許す、値もし呼び出し側は1（人・つ）を期待する：

sub f () { return :x<1> }
sub g ($x) { print $x }

my $x := |(f);  # binds 1 to $x, via a named argument
g(|(f));        # prints 1, via a named argument
 

リテラルを返すためにPair オブジェクトが、常に括弧の追加のセットにそれを入れた：

return( (:x<1>), (:y<2>) ); # two positional Pair objects
 

関数呼び出しの上の後置括弧が、「追加である」として、数えないとは、注意しろ。 しかしながら、何とでも同じように、関数、後で空白文字return キーワードがその解釈を防いで、そしてそれをその代わりにリスト演算子に変える：

return :x<1>, :y<2>; # two named arguments (if caller uses |)
return ( :x<1>, :y<2> ); # two positional Pair objects
 

もし関数が明示なしで展開式で終わるならreturn展開式が同じくであるために獲得されるCaptureちょうど展開式が引数であるかのようにそうすることreturn （空白文字で）演算子をリストしろ：

sub f { :x<1> } # named-argument binding (if caller uses |)
sub f { (:x<1>) } # always just one positional Pair object
 

曜日で指定呼び出し側のが終わる、Capture リストコンテキストで新しい引数リストが配列とほとんど同じように、すなわち、項目コンテキストの中の品目として、そしてリストとしてであろう何の中にでも補間挿入される。 これは振る舞い、しかし呼び出し側が使うかもしれないデフォルトだprefix:<|> 新しい引数リストの一部としてリターン値をインライン化するために。 呼び出し側は同じく返送された（人たち・もの）をバインドするかもしれないCapture 直接。

関数がただ1度だけその時で呼び出されるCapture それが（一度ならず起きることができた）後の境界であるときではなく、オブジェクトが生み出される。

callframe 関数が照合回路のリストを受けて、そして現在の呼フレームから呼び出し山、現在の呼めがね枠自身あるいはそ（れ・こ）から現在フレームが呼び出された若干の列の場所までナビゲーション道としてそれらを解釈する。 もしこのようなどのスコープもないなら、それはあの特定の呼び出しフレームを記述するオブジェクト、あるいは偽の値を返す。 引数が数でない引数スキャンである間に外へフレームのために引数に合って省略するべきフレームの数として解釈される Numeric スマートマッチする.

現在フレームは空白引数リストでアクセスされる。

say " file ", callframe().file,
    " line ", callframe().line;
 

それは同等の値：だ

say " file ", DYNAMIC::<$?FILE>,
    " line ", DYNAMIC::<$?LINE>;
 

このフレームの即刻の呼び出し側は、1つのレベルを省略することによって、アクセスされる：

say " file ", callframe(1).file,
    " line ", callframe(1).line;
 

あなたはそれが現在の関数の呼び出し側に違いないと思うかもしれない、しかしそれは必ずしもそうじゃない。 これは我々自身のルーチン、あるいは我々のブロックのためにコントロール演算子を実装するほかのところの若干の関数でさえ外側ブロックを返すかもしれない。 あなたの最新のルーチンの外に出るために、見ろcaller 下。

callframe 関数がそれにどのより高い範囲を探すべきか教えている引数を与えられるかもしれない。 それぞれの引数が左から右に、順に、処理される。 それに注意しろAny そして0 無操作命令だ：

$ctx = callframe();        # currently running frame for &?BLOCK
$ctx = callframe(Any);     # currently running frame for &?BLOCK
$ctx = callframe(Any,Any); # currently running frame for &?BLOCK
$ctx = callframe(1);       # my frame's caller
$ctx = callframe(2);       # my frame's caller's caller
$ctx = callframe(3);       # my frame's caller's caller's caller
$ctx = callframe(1,0,1,1); # my frames's caller's caller's caller
$ctx = callframe($i);      # $i'th caller
 

同じく、あなたが存在する呼び出しスタックの範囲に留まる限り、負数が許されることに注意を払え：

$ctx = callframe(4,-1);    # my frames's caller's caller's caller
 

あなたが現在のレベルを省略するために1を点在させないなら、何でもスマートマッチする繰り返すことはただ再び同じフレームとマッチする：

$ctx = callframe(Method);              # nearest frame that is method
$ctx = callframe(Method,Method);       # nearest frame that is method
$ctx = callframe(Method,1,Method);     # 2nd nearest method frame
$ctx = callframe(Method,1,Method,1)    # caller of that 2nd nearest method
$ctx = callframe(1,Block);             # nearest outer frame that is block
$ctx = callframe(Sub,1,Sub,1,Sub);     # 3rd nearest sub frame
$ctx = callframe({ .labels.any eq 'Foo' }); # nearest frame labeled 'Foo'
 

答えが戻ったこれが最後に潜在的に違う注目

Foo.callframe
 

それは一番奥の（人たち・もの）のフレームを返すFoo ダイナミックスコープよりむしろレキシカルスコープをふさげ。 骨格が同じく反応する呼び出し.callframe メソッド、それで所定のフレームがそれ以上のナビゲーションの基盤として使われるかもしれない：

$ctx = callframe(Method,1,Method);
$ctx = callframe(Method).callframe(1).callframe(Method);     # same
 

あなたはそれ以来、どこでもほかに、得るべき引数を供給しなくちゃならない.callframe すでにである何かの上に呼び出されるとき、識別情報は演算子であるContext：

$ctx = callframe;
$ctx = callframe.callframe.callframe.callframe;                # same
 

caller 関数ははるかに十分にただ外側に行くためにスペシャルによってケースに入れられた、から最初に「インラインである」ふりをして埋め込みであるか、あるいは違っている内部のブロック何でも無視した後で、現在のルーチンスコープから、エスケープしろ：

&caller ::= &callframe.assuming({ !.inline }, 1);
 

これが通常同じである重要性callframe(&?ROUTINE,1)しかし常にではなく。 返送されたクロージャへの呼び出しがそうしさえしなかったかもしれない&?ROUTINE そのダイナミックスコープでもう、しかしそれはまだ呼び出し側を持っている。

それで最新のルーチンがどこ（で・に）呼び出されたか見いだすために、あなたは言うことができる：

say " file ", caller.file,
    " line ", caller.line;
 

それは同等の値：だ

say " file ", CALLER::<$?FILE>,
    " line ", CALLER::<$?LINE>;
 

そうするための追加の引数caller 通話フレームからナビゲーションであるとして扱われる。 あなたの現在のルーチンではないから出た1つのフレームがそうであることを約束したRoutine フレーム。 あなたは言わなくちゃならないcaller(Routine) 次の大部分の人たち - 内部のルーチンに到着するために。

それに注意しろcaller(Routine).line 呼び出されてあなたにあなたの最新のルーチンがそうであった行番号を与えないであろう；あなたはそのブロックが呼び出しを含むその外のルーチンの中で実行している最高のブロックの行番号をあなたのルーチンに持って行く可能性がどちらかと言うと高い。

いずれかのためにcallframe あるいはcaller少なくともオブジェクトがサポートする戻って来た CallFrame 次のメソッド：

.callframe
.caller
.leave
.inline
.package
.file
.line
.my
.hints
.args
 

.callframe そして.caller そのそれら以外の関数がインボカントとして供給されたフレームに相対的であるのと同じように、メソッドが働く。 .leave メソッドが指定された呼び出しフレームから即時復帰を追い出すことができる。

.inline メソッドがこの区画が暗黙的に若干の周囲の制御構造によって入られたかどうか言う。 あなたが明示的にブロックあるいはルーチンに訴える Any 時間.() これは偽だ。 しかしながら、ブロックが配車係レベルプリミティブを使ってそんなものに入った何のための真もであることは定義される.callwith.callsame.nextwithあるいは.nextsame.

.my メソッドがアクセスを提供する、から既定の事実と結び付けられる語彙のネームスペースは呼び出しフレームの現在の位置を提供する。 それはそのレキシカルスコープで普通の語彙の変数を検索するために使われるかもしれない。 それは読み取り専用として記録されているどんな語彙の変数でも変えるために使われてはならない。

.hints 呼び出しが元来コンパイルされたとき、メソッドが呼び出しのポイントで有効なコンパイラシンボルのスナップショットにアクセスを与える。 （例えば、caller.hints('&?ROUTINE') あなたに呼び出し側のルーチンオブジェクトを与えるだろう。） このような値は常に読み取り専用であって、（上の呼び出し側のルーチンのような）いくらかに関してはけれどもにもかかわらず変更可能な固定されているオブジェクトを返すかもしれない。

want 関数はなくなっている。 もしあなたがコンテキストに特定された振る舞いを欲するなら、その代わりにそれに応じて種々の文脈上のメソッドに返答するオブジェクトを返せ。

（推測：将来我々はこのようなオブジェクトを作ることをより容易にする若干の構文的な構文糖を提供することを望むかもしれない。 あるいは多分、あなたが書くことができるように、種々のコンテキストのために値あるいはコード参照をとる型

   return ContextProxy.new:
    Int   => 3,
    item  => { @.list.join(', ') },
    list  => { ...               },
    ;
 

あるいは類似の何か。）

上に、言及されるようにreturn 呼び出しが一番奥の周囲のサブルーチン、メソッド、統治、トークン、返すべき（キーワードとしての）正規表現あるいはマクロを起こす。 ただ明示的な宣言詞キーワードを持っている宣言だけ（subsubmethodmethodmacroregextokenそしてrule）返されるかもしれないから. 文がそんなものを前接続するdo そしてtry そのカテゴリーに分類されない。 あなたは使うことができないreturn から直接ループ、そのままのブロック、 pointy ブロックからの周囲のコンテキスト、あるいは quotelike 演算子の中にそんなものをエスケープしろrx//；return 人たちの1人以内に構造が外へ戻るべき「適切な」ルーチンを捜し続けるだろう。 プロパティからの収益がそんなものを妨げるあなたもそうしないかもしれないBEGIN あるいはCATCH （ルーチンの語彙の、そしてダイナミックな範囲の中で実行しているブロックがもちろんそれから戻ることができるけれども外のルーチン、それあなたが常に戻ることができる手段CATCH あるいはFIRST, しかし never からBEGIN あるいはINIT.）

定常課程じゃないブロックから戻るために、leave メソッドがその代わりに使われる。 （それは適切に「立ち去れ」あるいは「あなたの後継者に遺言で譲れ」を意味するためにとられることができる。） オブジェクトは去るためにスコープを指定する、そしてメソッドの引数はリターン値を指定する。 もしオブジェクトが（関数の使用あるいはリスト演算フォームによって）除かれるなら、一番奥のブロックは出られる。 あなたが何かを使わなくちゃならない別のことcallframe あるいは&?BLOCK あるいはダイナミックな変数があなたが終了することを望むスコープを指定する。 前に同じくレキシカルスコープで見られた（ループラベルのような）ラベルが一種の singleton dynamic オブジェクトとして機能する：それは現在のダイナミックスコープで外のレキシカルスコープとしてもそしてフレームとしても共に勤めている文を名指す。

と同じようにreturn引数がであるために獲得されるCapture 帰りの値を持つ。

leave;                      # return from innermost block of any kind
callframe(Method).leave;    # return from innermost calling method
&?ROUTINE.leave(1,2,3);     # Return from current sub. Same as: return 1,2,3
&?ROUTINE.leave <== 1,2,3;  # same thing, force return as feed
OUTER.leave;                # Return from OUTER label in lexical scope
&foo.leave: 1,2,3;          # Return from innermost surrounding call to &foo
 

これらが制御流れに関して同等であるとは、注意しろ：

COUNT.leave;
last COUNT;
 

しかしながら、最初のフォームは明示的にリターンを設定する、暗黙のうちに第2である間にループ全体のための値がリスト理解としてすべての前の成功したループを繰り返し値リターンする。 （それは、実際、帰りを設定するにはあまりにも遅くもしそれがいい加減に評価されているならループのための値であるかもしれない！） Aleave 内側ループからブロックが、しかしながら、その繰り返しのためにただ返値を指定する：

for 1..10 { leave $_ * 2 }   # 2..20
 

それほどこれ的に注意しろ：

leave COUNT;
 

常に、それが戻るように、メソッドではなく、関数として連れて行かれるだろうCOUNT 一番奥のブロックからのオブジェクト。 メソッドの間接的なオブジェクト形式は常にコロンを必要とする：

leave COUNT: ;
 

temp マクロが一時的に存在する変数、サブルーチン、関数呼び出しのコンテキスト、あるいは所定のスコープでの他のオブジェクトの値を置き換える：

{
   temp $*foo = 'foo';      # Temporarily replace global $foo
   temp &bar := sub {...};  # Temporarily replace sub &bar
   ...
} # Old values of $*foo and &bar reinstated at this point
 

temp その引数のに訴える.TEMP メソッド。 メソッドは戻るために期待されるCallable 後にオブジェクトの現在の値を復活させることができるオブジェクト。 レキシカルスコープの終わりにどちらでtemp 通り過ぎて、サブルーチンが返送されているという状態で、応用される.TEMP メソッドが実行される。

デフォルト.TEMP メソッドが変数のためにただ変数のプリに － 割り当てるクロージャを作るtemp 変数に戻っている値。

新しい種類の temporization が（彼・それ）ら自身のもので執筆記憶クラスによって作成されることができる.TEMP メソッド：

class LoudArray is Array {
    method TEMP {
        print "Replacing $.WHICH() at {caller.location}\n";
        my $restorer = callsame;
        return {
            print "Restoring $.WHICH() at {caller.location}\n";
            $restorer();
        };
    }
}
 

権限：が同じく行動を変更するのテンポラリ化するそれらを与えることによってのコード構造TEMP ブロック。 と同じように.TEMP メソッド、このブロックはサブルーチンをそのプリ － に戻すために実行されるであろうクロージャを指定期間の末、テンポラリ化している範囲、リターンするために期待されるtemp ステート：

my $next = 0;
sub next {
    my $curr = $next++;
    TEMP {{ $next = $curr }}  # TEMP block returns the closure { $next = $curr }
    return $curr;
}

# and later...

say next();     # prints 0; $next == 1
say next();     # prints 1; $next == 2
say next();     # prints 2; $next == 3
if ($hiccough) {
    say temp next();  # prints 3; closes $curr at 3; $next == 4
    say next();       # prints 4; $next == 5
    say next();       # prints 5; $next == 6
}                     # $next = 3
say next();     # prints 3; $next == 4
say next();     # prints 4; $next == 5
 

それに注意しろtemp 関数が何かに国営変更をもたらす前に、 temporization が手配されなくちゃならないから、関数よりむしろマクロに違いない、そしてもしそれがそうであったなら、正規関数、国営変更への引数がであろう法線が前に起きるtemp 制御を得た。

再ストアクロージャがただ失敗に関して呼び出されること以外、仮説の変数が同じメカニズムを使う。

ダイナミックな変数がテンポラリ化したより良い解決であるかもしれないとはマルチスレッドに直面してのグローバルに注意しろ。

すべてのRoutine オブジェクトがそうした.wrap メソッド。 このメソッドはシングルを期待するCallable 引数。 コード、スペシャルの中でcallsamecallwithnextsame そしてnextwith 関数がオリジナルのルーチンを呼び出すだろう、しかし当局者を開始するなCALLER フレーム：

sub thermo ($t) {...}   # set temperature in Celsius, returns old value

# Add a wrapper to convert from Fahrenheit...
$handle = &thermo.wrap( { callwith( ($^t-32)/1.8 ) } );
 

callwith 関数があなたに巻いた関数にあなた自身の引数をパスさせる。 callsame 関数が引数をとらない；それは暗黙のうちに変化していない状態でオリジナルの引数リストをパスする。 callsame そしてnextsame 関数は賛成で本当に短い：

callwith( |callframe(Routine).args )
nextwith( |callframe(Routine).args )
 

そうするための呼び出し.wrap オリジナルの（人たち・もの）に取って代わるRoutine「sdo プロパティでCallable 引数、そして何でもコールするように手はずを整えるそうすることcallsamecallwithnextsame あるいはnextwith ルーチンの前バージョンに訴える。 言い換えれば、そうするための呼び出し.wrap 多かれ少なかれ同じ影響を持つけれども :

my &old_thermo := &thermo;
&thermo = sub ($t) { old_thermo( ($t-32)/1.8 ) }
 

それに注意しろ&thermo.WHICH 後で同じことを停止させる.wrapそれが等価物で割り当てをする（とき・から・につれて・ように）割り当てからそうすることを示すRoutine 抑制されている（人たち・もの）を変えて、コンテナのように働くdo コンテナではなく、プロパティ自身。

そうするための呼び出し.wrap それが持っているユニークなハンドルを返すrestore 包装を元に戻すであろうメソッド：

$handle.restore;
 

これは他の包装がルーチンに置いた何にも影響を与えない。

包装が同じく temporization で特定のダイナミックスコープに制限されることができる：

# Add a wrapper to convert from Kelvin
# wrapper self-unwraps at end of current scope
temp &thermo.wrap( { callwith($^t + 273.16) } );
 

リストがへバインディングまでに獲得されるかもしれない引数全体Capture パラメータ。 そうすることはその時パスし得るcallwith その名前：を使って

# Double the return value for &thermo
&thermo.wrap( -> |$args { callwith(|$args) * 2 } );
 

この場合ただ帰りの値だけが変えられる。

包み紙ではないがオリジナルのルーチンを呼び出すように要求される；それはもう1（つ・人）を呼び出すことができるCallable パスすることによってのオブジェクトCapture そうすることそcallwith メソッド：

# Transparently redirect all calls to &thermo to &other_thermo
&thermo.wrap( sub (|$args) { &other_thermo.callwith(|$args) } );
 

あるいはいっそう手短かに：

&thermo.wrap( { &other_thermo.callsame } );
 

メソッドバージョンからのcallsamecallwithnextsameそしてnextwith 明示的な目的地を指定しろ、それら意味規則が包み紙の外で変更ではなくする。 しかしながら、対応する関数は明示的な目的地を持っていない、それでその代わりにそれらが暗黙のうちに次 - 最もありそうなメソッドあるいは多 sub を呼び出して；詳細のために S12 を見る。

何とでも同じように値、あなたが返送された（人たち・もの）を捕えるかもしれない報告Capture のcall バインディングまでに：

my |$retval := callwith(|$args);
... # postprocessing
return |$retval;
 

代わる代わる、あなたは妨げるかもしれない、何でも、変形を使うことによって、まったく戻るnextsame そしてnextwith. 　引数はただパスすると同じようにcallsame そしてcallwithしかし尾呼び出し明示的に実施される；何でも下記をコード化する、目的地ルーチンに呼び出す前に、呼び出しはリターンがそこに実行されたかのように、 unreached されるだろう.

普通のメソッドディスパッチの中でこれらの関数は我々の親の1人（あるいは年上の兄弟）でのメソッドが分類する同じを呼び出すことへの一般にうまくいく巻いた関数としての配車係の候補傾きの残りを扱う。 同じく多数のディスパッチの中で最新のルーチンは候補者リストからもっとはるかに下方の候補者に従うかもしれない。 必ずしもクラス階層によって話されないけれども、このような後の候補はいっそう一般的で、そして従って（多分）種々の思いがけない状態を扱うことが可能である可能性がいっそう高いと見なされる。

ルーチンが（デフォルトまでに）そうであるすべてが見なした注目で、インライン化している、そして一定の折り畳めることの候補であれ。 オプティマイザはメインプログラムのの後にこれらの最適化をし始めることを許されるCHECK 時、しかし前にではなく。 何の後にでもルーチンが「激しく」インライン化される、あるいは定数が折られる、それは不変として明示的に再タイプされる；何でもラップしようと試みる、不変のルーチンが打ち上げ呼び出しの失敗に終わるだろう。 不変のルーチンが型に配役を振り替えることによってそれほど記録されているHardRoutineサブクラスのRoutine.

他方、明示的にルーチンに変更可能であるという記録を残すことは同じく可能だ、そして次にそれをラップする能力は後でさえ維持されているに違いないCHECK 時間。 これは配役を振り替えることによってそうするためにされるSoftRoutine. 　明示的にルーチンに変更可能であるか、あるいは不変であるという記録を残すことは永久であると見なされるべきだ。 柔らかいルーチンをインライン化することはまだ可能だ、しかしただもし間接参照の可能性が同様にインラインで検出される、そして準備が、包み紙を取り扱うことに対して、（インラインか、あるいは外部ルーチンを書き直すこととしてに）されるなら。

従って、ルーチンが前に柔らかいというマークを付けた何もCHECK 時間は難しいか、あるいは折り畳み式のインライン化することを免除されている。 それがオプティマイザの仕事だから、どんなにメソッドがルーチンに難しいという記録を残すために提供されないとしても、ルーチンに柔らかいという記録を残すことについてのいくつかのメソッドがある。 ルーチンが、柔らかいと同じように、記録されているかもしれない：

• もしそれが明示的に "our" 使うと宣言されるなら

• もしそれが引数リストで言及されるならのuse soft プラグマ、

• もしその名前がワイルドカードパターン（TBD）で何かとマッチするならuse soft

• もしそれが定義されるモジュールあるいはクラスが言及されるなら中にいるuse soft

• あるいはもし将官がいるならuse soft *; ランタイムに基本的に、すべてのために AOP をオンにする宣言。 これがあなたのオプティマイザを「pessimizer」のさらに多くに変えるかもしれないことを知っていろ。

何のためにでも標準のスタンドアロンアプリケーション、何もuse soft それが前に行なわれるなら、プラグマがそれが参加するプログラム全体に当てはまるCHECK 時間。 オプティマイザはそれでソフトなままでいるために求められなかった何でも固くするかもしれない。

Web サーバのためのような、プラグイン方式が個別のプラグインが、独立が、オプティマイザに独立して個別のプラグインを固めさせることによって、プログラムする（とき・から・につれて・ように）、振る舞うか、あるいは、すべてのプラグインを緩和することによって、すべてのプラグインを同じプログラムの一部として取り扱うことを可能にするために同様選択するかもしれない。 （類似の考慮が closed/final.) にクラスを最適化することに当てはまる

それが前に包み紙をインストールしているのに注意しろCHECK タイムが特に方法の1つじゃない、から1ルーチンマークが同じぐらい柔らかい。 このようなルーチンがまだ堅くなっているかもしれないでCHECK コンパイル時間の間に巻いていたにもかかわらず、時間。

&?ROUTINE レキシカルに一番奥の（人たち・もの）のために常に別名だRoutine （それはそうであるかもしれないSubMethodあるいはSubmethod）、あなたが、匿名の sub に：再帰を指定することができるように

my $anonfactorial = sub (Int $n) {
                        return 1 if $n<2;
                        return $n * &?ROUTINE($n-1);
                    };
 

あなたは、呼び出すことによって、最新のルーチンのために名前を手に入れることができる&?ROUTINE.name. 　何の外ででも sub 宣言、この呼び出しは失敗を返す。

それに注意しろ&?ROUTINE たとえそれが宣言されるとしても、現在の一つの sub に言及するmulti. 　呼び出すべき名指された形態を所定の短い名前、ただ使用の下のスイート全体に再び緊急派遣するためにprotoそれ以来そこ（に・で） anonymous じゃないmultis．。

&?BLOCK 現在ブロックで常に別名だ、それであなたは匿名のブロックの上に再帰を指定することができる：

my $anonfactorial = -> Int $n { $n < 2
                                    ?? 1
                                    !! $n * &?BLOCK($n-1)
                              };
 

&?BLOCK.labels 現在ブロックのすべてのラベルのリストを含んでいる。 これは、言うことによって、典型的にマッチされる

if &?BLOCK.labels.any eq 'Foo' {...}
 

一番奥の語彙のブロックがたまたまメイン区画であるもしRoutineそれから&?BLOCK ただ戻るBlock オブジェクト、そうじゃないRoutine それを含んでいるオブジェクト。

［注意しろ：何でも示すために$? あるいは&? sub あるいはブロックがコンパイルされている時における変数、使用COMPILING:: 擬似パッケージ。］

すべてのCallable オブジェクトがそうした.assuming メソッド。 このメソッドはシグネチャーに引数のセットの部分的なバインディングをして、そしてただ残っている引数だけをとる新しい関数を返す。

&textfrom := &substr.assuming(str=>$text, len=>Inf);
 

あるいは等しく：

&textfrom := &substr.assuming(:str($text) :len(Inf));
 

あるいはさらに：

&textfrom := &substr.assuming:str($text):len(Inf);
 

それは戻るCallable 値がパスしたオリジナルのサブルーチンと同じ行動を実装するが、そうしたオブジェクト.assuming すでに対応するパラメータにバインドされた：

$all  = textfrom(0);   # same as: $all  = substr($text,0,Inf);
$some = textfrom(50);  # same as: $some = substr($text,50,Inf);
$last = textfrom(-1);  # same as: $last = substr($text,-1,Inf);
 

結果のuse 文がそれが同じく持つ（コンパイル時）オブジェクトである.assuming 同時にすべてのモジュールのサブルーチン / メソッド / でパラメータをバインドするユーザーなどを許しているメソッド：

(use IO::Logging).assuming(logfile => ".log");
 

この特殊形式は一般に名指されたパラメータに制限されるべきだ。

詳細をカリー化するためにmulti 変形、そのパラメータの1人以上が一つの関数を選び出すことは型を指定するために必要であるかもしれない：

&woof ::= &bark:(Dog).assuming :pitch<low>;
&pine ::= &bark:(Tree).assuming :pitch<yes>;
 

それら引数が解析されるとすぐに（もしそうでなければより早く）、マクロはコンパイラによって呼び出される関数あるいは演算子だ。 マクロ宣言あるいは輸入の構文的な効果は、たとえマクロの名前がほかのところに目に見えるとしても、常にレキシカルにスコープ宣言される。 普通の演算子と同じように、マクロが（彼・それ）らの文法的なカテゴリーによって分類されるかもしれない。 既定の事実のために文法的なカテゴリー、デフォルト構文解析規則あるいはルールのセットが使われる、しかしまだ、マクロキーワードあるいはトークンが見られるときまでに、「使われなかった」ルールがそうすることができる人たちは「解析される」トレイトの使用によって置き換えられる。 （これは、例えば、インフィックス演算子が解析ルールをその左オペランドではなく、その右オペランドと交換することができることを意味する。）

それと反対のシグネチャーがないときには、それが現在のマッチオブジェクトにメソッドであるかのように、マクロが減少していて文法規則から返されて呼び出される；すなわち、すべての最新の解析情報は、おごることによって、利用可能だself それがそうであるかのように$/ オブジェクト。 ［推測：もし引数が特定の AST 型で宣言されるなら、代わりの表示は利用可能であるかもしれない。］

マクロが再び解析される文字列、あるいはそれ以上解析しないことを必要とする構文ツリーを返すかもしれない。 原文のフォームは有用だ、しかし構文木形式は、それがパーサーとデバッガがもっと良いエラーメッセージを与えることを可能にするから、一般に好まれる。 他方の原文の置換がユーザーに不透明なエラーメッセージを譲り渡す傾向がある。 それらがリバーシブルであるから、構文ツリーは一般に同じくもっと良い、それで構文 highlighters のようなものがオリジナルの言語に戻って、そしてどの得られたプログラムの一部がプログラムのユーザーのビューのどの部分から来るか知ることができる。 にもかかわらず、片寄った構造のために構文ツリーを返すことは難しい、そしてこのような場合原文のマクロがあなたがしようとしている不快なことのいっそう明確な展開式であるかもしれない。

もしあなたがマクロを呼び出すなら、ランタイムに、マクロの結果は再び自動的に評価される、それで下の2つの呼び出しは同じことをプリントする：

macro f { '1 + 1' }
say f();    # compile-time call to &f
say &f();   # runtime call to &f
 

戻ることについての支援で構文ツリー、 Perl はクォートを使って「半ば引用すること」メカニズムを提供するquasiAST を表すように意図されたブロックによって：後に続かれた

return quasi { say "foo" };
 

そうするための変換機quasi 演算を修正することができる：

:ast(MyAst)         # Default :ast(AST)
:lang(Ruby)         # Default :lang($?PARSER)
:unquote<[: :]>     # Default "triple rule"
 

1以内半ば引用しろ、変数と関数が、マクロ定義のレキシカルスコープによれば、決心に名前をつける. マクロがコンパイルされているとき、それが使われているときではなく、認識されないシンボルがエラーを上げる。

マクロ引数の使用で半ば引用する、 unquoting しないで、これがエラーである可能性が非常に高い（とき・から・につれて・ように）、警告を提供するべきである.

# Oops; size of the AST of the argument
macro mouse ($arg) { quasi { $arg.elems } }
 

使用で、マクロ呼び出しの（部分的にコンパイルされた）範囲にシンボルを確認させることCOMPILING:: 疑似パッケージ：

macro moose () { quasi { $COMPILING::x } }

moose(); # macro-call-time error
my $x;
moose(); # resolves to 'my $x'
 

もしあなたがスコープからシンボルに言及することを望むなら、マクロ呼び出しについて、読み込み構文を修飾子としてそうするために使えquasi：

:COMPILING<$x>      # $x always refers to $x in caller's scope
:COMPILING          # All free variables fallback to caller's scope
 

もしそれらのシンボルがコンパイルしているスコープの範囲に身を委ねないなら、コンパイル時の例外が時マクロ呼び出しでスローされる。

同様に、あなたがあるいは言及するかもしれないマクロ本体で$x マクロ呼出しの範囲に宣言するけれども$COMPILING::xあるいはバインド、明示的に：それらへ

my $x := $COMPILING::x;
 

あなたは同じく移入リストをマクロのレキシカルスコープの中に多数のシンボルをバインドするために使うかもしれない：

require COMPILING <$x $y $z>;
 

あなたが実行時を使う必要があることに注意を払えrequire 形式、そうじゃないuseマクロ呼び出し側のコンパイル時がマクロのランタイムであるから。

（マクロへの引数のような）変数が直接継がれないかもしれないそのままの AST それらが標準であると思われるであろうからバインディングを半ば引用する. 同じく、差し込まれるプログラム本体文字列は特別に記録されている必要がある、あるいはそれらが通常バインドされるだろう。 中でいずれかの型の「unquoted」展開式を差し込むこと半ば引用する、使用、典型的に、3倍にされた区切り文字に、ある種について：クォートをかっこでくくることを半ば引用する

return quasi { say $a + {{{ $ast }}} }
return quasi [ say $a + [[[ $ast ]]] ]
return quasi < say $a + <<< $ast >>> >
return quasi ( say $a + ((( $ast ))) )
 

区切り文字はクォートをかっこでくくっていなくてもよい、しかし次のことがおそらく良くないスタイル：と解釈されるはずだ

return quasi / say $a + /// $ast /// /
 

（履行者に注意しろ：これは、最終の終わりの区切り文字と前処理を見いだすことによって、実装されてはならない、あるいは我々は我々の1パス構文解析規則に違反するだろう。 Perl 6 構文解析規則は（彼・それ）らの終わりの区切り文字を知るためにパラメータ化されている、それで冒頭の区切り文字を加えることは困難であるべきじゃない。 代わる代わる冒頭の区切り文字は終わりの区切り文字から推論されることができる。 続けて3つの冒頭の区切り文字を探す規則を書くことは問題であるべきじゃない。 けれども、特殊な文法規則じゃなければならない、我々が異なった区切り文字でコードブロックをネストすることが可能である必要があるときからの固定されているトークンじゃない。 同じく、内部の展開式を解析するとき、内部のパーサーサブルールはそのことを知るためにパラメータ化されている}}} あるいはその終わりの区切り文字であるものは何も。）

Unquoted 展開式が変数の型に依存して適切に差し込まれる、そしてそれは構文ツリーあるいは文字列であるかもしれない。 （再び、構文の木が好まれる。） ケースは中から呼び出されてマクロのそれに類似している、その結果が、何が補間挿入された変数の後に続くかについて、パーサーの期待を変えることができないように、定義時間を半ば引用して、再び解析をすることはただマクロ呼び出しのこのような再解析が起きるという補間の、それ以外の文字列版と共に起きるだけである限りにおいてマクロよりむしろ時間を測定する.

従って、他方それ自身を半ば引用する解析されている、 unquotedな展開式の構文的な書き入れ中に常に演算子下記の期待の結果を半ば引用する」. （もしあなたが他の何かを期待することを望むなら、あなたは submacro に呼び出しを使わなくちゃならない。） もちろん、その構文カテゴリによれば、マクロ定義は全体としてそれがその後好きであるものは何でも期待することができる。 （一般に、項が次の後置を期待する、あるいはインフィックス演算子と演算子が次の項あるいは接頭辞演算子を期待する。 これは、しかしながら、テキストの再解析が次の期待を決定するから原文のマクロのために重要じゃない。）

衛生的な語彙の有効範囲規則へ、クロージャとまったく同じような Quasiquotes デフォルト。 語彙の変数の視界はデフォルトによって準展開式に制限される。 変数宣言が外部から目に見える使用方法にされることができるCOMPILING:: 疑似パッケージ。 個別の変数がトップレベルの変数宣言が使って露出し得る visible 、あるいはすべてにされることができるquasi :COMPILING できろ。

下の両方の例が付け加えるだろう$new_variable マクロ呼出しのレキシカルスコープに：

  quasi {  my $COMPILING::new_variable;   my $private_var; ... }
  quasi :COMPILING { my $new_variable; { my $private_var; ... } }
 

（それに注意しろ:COMPILING Macros で記述される追加の効果を持つ。）

{...} 常にブロックだ。 どんなに、もしそれが完全に空であるか、あるいはその最初の要素がハッシュあるいは1対である一つのリストから成り立つなら、それが構成するためにすぐに実行されるとしてもHash オブジェクト。

標準pair 演算子がそれと等しいリスト：

sub pair (*@LIST) {
    my @pairs;
    for @LIST -> $key, $val {
        push @pairs, $key => $val;
    }
    return @pairs;
}
 

あるいはいっそう簡潔に（そしていい加減に）：

sub pair (*@LIST) {
    gather for @LIST -> $key, $val {
        take $key => $val;
    }
}
 

標準hash 演算子がそれと等しいリスト：

sub hash (*@LIST) {
    return { pair @LIST };
}
 

それであなたは使ってもよいsub あるいはhash あるいはpair そうすることあいまいさを排除しろ：

$obj =  sub { 1, 2, 3, 4, 5, 6 };   # Anonymous sub returning list
$obj =      { 1, 2, 3, 4, 5, 6 };   # Anonymous sub returning list
$obj =      { 1=>2, 3=>4, 5=>6 };   # Anonymous hash
$obj =      { 1=>2, 3, 4, 5, 6 };   # Anonymous hash
$obj =  hash( 1, 2, 3, 4, 5, 6 );   # Anonymous hash
$obj =  hash  1, 2, 3, 4, 5, 6  ;   # Anonymous hash
$obj = { pair 1, 2, 3, 4, 5, 6 };   # Anonymous hash



 

それらが不変だから、 Pair オブジェクトが直接割り当てられないかもしれない：

(key => $var) = "value";    # ERROR
 

しかしながら、バインディングが対になるとき、「上へマッチする」左辺値に名前が使われることができる、そして右辺値はあなたが左側をシグネチャー使用方法として書くならだ:(...) 表記法：

:(:who($name), :why($reason)) := (why => $because, who => "me");
 

（さもなければパーサーは、それがそうすることができるまで、それが普通の展開式としてではなく、シグネチャーとして胃腸を解析するべきであることを知らない:=そしてそれ良くないだろう. Alternately, the my 宣言詞がシグネチャーとして同じくその引数の取り扱いを強制することができる。）

GLOBAL::<$varname> 指定する$varname 宣言する中にいる* ネームスペース。 あるいは多分それはその逆だ・・・。

CALLER::<$varname> 指定する$varname 変数が振る舞うそ（れ・こ）から現在ブロック / クロージャ / サブルーチンが呼び出されて、供給されたダイナミックスコープで目に見える「dynamic」トレイト. （すべての変数で* twigil はトレイトで自動的に記録されている。 同じくある特定の暗黙の語彙（$_$/そして$!）それほど記録されている。）

DYNAMIC::<$varname> 指定する$varname それが一緒に変数を宣言する一番奥のダイナミックスコープで目に見える「is dynamic」トレイト、あるいはそれが持つ名前で* twigil 。

MY::<$varname> 語彙を指定する$varname 現在のレキシカルスコープに宣言される。

OUR::<$varname> 指定する$varname 現在のパッケージのネームスペースに宣言される。

COMPILING::<$varname> 指定する$varname 宣言された（か、あるいは宣言されようとした）現在コンパイルされているレキシカルスコープで.

OUTER::<$varname> 指定する$varname 現在のレキシカルスコープ（すなわち現在ブロックが定義されたスコープ）を取り巻いているレキシカルスコープに宣言される。

通常トップレベルの Perl 「台本」がただその匿名の主回線コードを評価して、そして去る。 主回線コード、引数が生のフォームで利用可能なプログラムのの間に@*ARGS 配列。 主回線コードの終わりに、しかしながら、MAIN サブルーチンがコマンドライン引数が残留するものは何ででも呼び出されるだろう@*ARGS. 　この呼び出しは行なわれるもし :

a)

コンパイル単位は、もう1つのコンパイル単位によって必要とされることによって、よりむしろ直接訴えられた、そして

b）

コンパイル単位は宣言するRoutine 名前をつけられた」MAIN」そして

c）

主回線コードではないが明示的な呼び出しでそうするためのように、早々に終えられるexitあるいは uncaught の例外。

引数（あるいは主回線処理の後にそれらから残っているもの）が魔法のようにそうであるラインが変換したコマンドCapture そしてパスしたそうすることMAIN その引数として、それで、プログラムへの名指された引数と他の引数がポジショナルパラメータあるいは素晴らしい配列にバインドされるかもしれない（とき・から・につれて・ように）、スイッチがバインドされるかもしれない：

sub MAIN ($directory, :$verbose, *%other, *@filenames) {
    for @filenames { ... }
}
 

引数が自動的にそうである着信がパスしたそれぞれval() それらが多メソッドディスパッチで使われるかもしれないように、 texual 引数の型を直感で知ろうと試みるであろう関数。 もしMAIN セットとして宣言されのmulti sub 、多ディスパッチが行なわれる、そして型情報が通り過ぎて直感で知られるval() 異なったシグネチャーを区別するために使われるかもしれない：

multi MAIN (Int $i) {...}   # foo 1
multi MAIN (Rat $i) {...}   # foo 1/2
multi MAIN (Num $i) {...}   # foo 1e6
multi MAIN ($i) {...}       # foo bar
 

モジュールとクラス宣言と同じように、もしそれが最初のこのような宣言であるなら、セミコロンで終わっている sub 宣言が最も外側のファイル有効範囲において許される、その場合ファイルの残りが体だ：

sub MAIN ($directory, :$verbose, *%other, *@filenames);
for @filenames { ... }
 

この形式は名指された単純な sub だけに割り当てられるMAIN それはコマンドラインから走らせられて存在するために意図的だ。 Aproto あるいはmulti 定義がセミコロンフォームに書かれないかもしれなくて、また、そうしないかもしれないMAIN モジュールあるいはクラスの中の sub がセミコロンフォームに書かれる。 （AMAIN ルーチンがモジュールの中で許される、あるいはクラス、しかしではないが、ファイルが直接走らせられない限り、通常訴えられる（見ろ上に）. これは Perl 5 の「呼び出し側じゃないなら」慣用句に対応する。） 一般に、あなたはただファイル全体をコントロールする1つのセミコロン風の宣言だけを持っていてもよい。

もし未遂のディスパッチであるならそうするためにMAIN 失敗、USAGE ルーチンが呼び出される。 もしノーがあるならUSAGE ルーチン、デフォルトメッセージが標準誤りにプリントされる。 もし--help コマンドライン・オプションとしてプログラムにパスされる、使用法メッセージはその代わりに標準出力にプリントされる。

通信が自動的にシグネチャー（あるいはシグネチャー）から表示されるこの用法MAIN. 　このメッセージはコンパイル時間に生成される、そして後の回何においてでも従って利用可能だけれども$?USAGE.

共通の Unix コマンドライン協定が次のようにキャプチャにマップされる：

Assuming C<-n> is the short name for C<--name>,
On command line...         $*ARGS capture gets...

# Short names
-n                         :name
-n=value                   :name<value>
-n="spacey value"          :name«'spacey value'»
-n='spacey value'          :name«'spacey value'»
-n=val1,'val 2',etc        :name«val1 'val 2' etc»

# Long names
--name                     :name
--name=value               :name<value>

--name="spacey value"      :name«'spacey value'»
--name "spacey value"      :name«'spacey value'»
--name='spacey value'      :name«'spacey value'»
--name=val1,'val 2',etc    :name«val1 'val 2' etc»
--                                          # end named argument processing

# Negation
--/name                    :!name
--/name=value              :name<value> but False
--/name="spacey value"     :name«'spacey value'» but False
--/name='spacey value'     :name«'spacey value'» but False
--/name=val1,'val 2',etc   :name«val1 'val 2' etc» but False

# Native
:name                      :name
:/name                     :!name
:name=value                :name<value>
:name="spacey value"       :name«'spacey value'»
:name='spacey value'       :name«'spacey value'»
:name=val1,'val 2',etc     :name«val1 'val 2' etc»
 

正確な Perl 6 フォームは、もしシェル処理から引用されるなら問題がない：

':name<value>'             :name<value>
':name(42)'                :name(42)
 

保全理由で、ただ定数だけがしかしながら、引数として、許される。

デフォルトCapture マッパーが宣言に注意を払うのMAIN「sパラメータがある特定のあいまい性を解決する。 A--foo コマンドラインからの次の言葉を引数として取り扱うべきかどうか知る必要を取り替えろ。 （spacey 形式を許すことは引数にさまざまなことをする殻スペースを与える。） ショート-foo 形式が決して別個の引数を想定しない、そしてあなたは使わなくちゃならない=. 　賛成だ--foo もしスイッチ名に対応している名指されたパラメータがあり、そしてそれが型の（こと・もの）であるなら、できろBoolそれから、引数が期待されない。 さもなければ引数が期待される。 もしパラメータが次のコマンドラインまで素晴らしくない配列型、すべての次の言葉を持っているなら、スイッチ（あるいはリストの端）がそのパラメータにバインドされる。

いつものように、スイッチが、最初の非スイッチの後に、最初とすべてだと考えられる、あるいは何でも後で乗り換える--positionals として扱われるか、あるいは素晴らしい配列に入る（たとえそれらであるとしてもスイッチのように見える）. ポリシーが呼び出して容易に通り過ぎて開始されるかもしれない他MAIN 明示的に。 例えば、あなたは文法であなたの引数を解析して、そして結果として生じることをパスすることができるMatch オブジェクト as a Capture そうするためにMAIN：

@*ARGS ~~ /<MyGrammar::top>/;
MAIN(|$/);
exit;

sub MAIN ($frompart, $topart, *@rest) {
    if $frompart<foo> { ... }
    if $topart<bar><baz> { ... }
}
 

これは名指されたパラメータに好都合にトップレベルの名指されたマッチをバインドするだろう、しかしそれでもあなたがネストされてアクセスする弾力性が、ただ何としてでも、それらのパラメータを通してマッチするMatch オブジェクトがそうするだろう。 もちろん、この例で、名前をつけられる sub がある特定の理由がないMAIN.

両方ともに長いそして短いスイッチ名を与えるために、あなたはペア表記法を同じパラメータのいくつかの名前をインストールするために使うかもしれない。 もし名前の何かが単一文字であるなら、それは短いスイッチ名だと見なされるだろう、他方他のすべてのパラメータ名が長いスイッチ名と見なされる。 それでもし前の宣言がそうであったなら：

sub MAIN (:f(:$frompart), :t(:$topart), *@rest)
 

それからあなたはいずれかでプログラムに訴えることができた-f あるいは--frompart 最初のパラメータを指定するために。 同じくあなたはいずれかを使うことができた-t あるいは--topart 2番目のパラメータのために。

セクションが使用を記述する前の（人たち・もの）MAIN ユーザーにコードがある。 暗黙が同じくあるかもしれないMAIN 現在のコンパイル単位を設定することによって供給されたルーチン。 （-n そして-p コマンドラインスイッチがこのように実装される。） この場合ユーザーの主回線コードではないは自動的に実行した；その代わりに、実行が設定のによってコントロールされるMAIN ルーチン。 それほどルーチン的な呼び出し{YOU_ARE_HERE} ユーザーのコードが（抽象的に）レキシカルに挿入されるはずである時点で。 環境が同じく電話をするかもしれない{YOU_ARE_HERE} 以外にMAIN ルーチン、それがどちらのケースに、標準の環境として、作用するかそして{YOU_ARE_HERE} ただユーザーのコードがどこに論理的に行くかを示す。 （あるいはコンパイラの見地、賛成でスナップショットをダンプするべきレキシカルスコープ後にどちらかから異なったコンパイル単位の設定としてのコンパイラによる使用。） この場合利用者識別コードの実行は同じぐらい標準に進む。 実際、CORE 後方一致をセットする{YOU_ARE_HERE} 廃棄物を捨てることCORE 標準的な環境としてのレキシカルスコープ。 この意味で、CORE 普通の前兆としての関数。

もしMAIN ルーチンが設定でもそしてユーザーのコード、設定のでも共に宣言されるMAIN 実際の主回線入り口点としての関数。 ユーザーのMAIN 環境が援用である埋め込みのファッション；での関数{YOU_ARE_HERE} ユーザーのコード、そしてユーザーの見地からの主な祈りとしての関数MAIN ルーチンがそれぞれの呼び出しの終わりに呼び出されるだろうそうすること{YOU_ARE_HERE}.

（そのために）自動的に通すことを実装するべき自然の方法multi sub 存在するからただ junctional シグネチャーを持て（受け入れることができる（の・もの・人）Mu あるいは同様にジャンクションけれどもAny パラメータ）非を自動的にスレッドするバージョンよりいっそう大ざっぱにマッチして、そして多数のディスパッチにシグネチャーに基づいて適切な sub を見いださせる. それらの一般的なルーチンはそれから一人一人をいっそう特定の（人たち・もの）に再び緊急派遣することになる。

他方、自然の実装のonly sub 効率で直接問題の sub を呼び出す（そしてある場合には多分それをインライン化しさえする）はずである. 効率が、結局のところ、ただすべての sub を作らない主な理由であることmulti. 　しかしながら、自動的にスレッドすることを許すべき願望を持っているこれほど直接の呼び出し競合。 下にただすべてのために多ディスパッチを作って、そして次にそれを言うことは誘惑的であるかもしれないonly 宣言が、もしあなたが再び宣言するなら、ただあなたがエラーを得ることを意味する。 そして多分、もし多数のディスパッチメカニズムが十分に高速であるなら、それは正当なアプローチだ。

しかしながら、直接の呼び出しがまだ正確にそのパラメータにその引数をバインドする必要がある、そしてそれはどうにかしてバインドすることに関しての失敗のケースを扱わなければならない。 それでそれは自動的に通すことを実装することが可能に同じくだonly バインディング失敗からのフェイルオーバに基づいた sub 。 これはあるいはフェイルオーバがへ変換によって後に続いたワンショットであり得たmulti 呼び出し、あるいはそれがそうすることができた毎回あなたが自動装填に試みるフェイルオーバ. もし我々がバインドするべき失敗するコストと比較して junctional 処理がほとんどいつもかなりずっしり重い可能性が高いと想定するなら、それは毎回にわたって失敗することに賛成する傾向がある。 これは同じく、インライン化された呼び出しを書き直すことが難しいから、インライン化することにいっそう貢献する。 何ででも場合、最近proto 宣言が種類であると見なされるのonly 、もしシグネチャーであるなら、 similaraly を自動的にスレッドすることを扱うべき sub と必要proto ジャンクションを除外する。

このセクションはメソッドがそのルーチンの内面的な仕事の内省を許すルーチンオブジェクトによって実装されたと述べる。

.candidates

このメソッドは最新のルーチンと結び付けられる候補の（潜在的にいい加減な）リストを返す。 ルーチンがそれ自身を一つの品目としてリストをリターンするべきである "only" .

.signature

このメソッドは最新のルーチンのシグネチャーを返す。

.cando （\$capture）

このメソッドは最も良いマッチで最初に、マッチの良好によって、順序づけられた所定のキャプチャとマッチする候補の（潜在的にいい加減な）リストを返す。

.push （$candidate）

付け加える$candidate これの候補のリストにproto中にこのメソッドを呼び出すonly ルーチンが失敗に終わるべきだ。 それは賛成で同じく受け入れられているmultisが候補のリストを完成させて、そしてここで同じく失敗を返すためにソースコードで宣言した。 ただProtosが、呼び出すことによって、作られるProto.new() 有能であるべきである実行時において候補を加える.

セクション Signature Introspection を見ろ。