Synopsis 2：ビットと小片

Larry Wall <larry@wall.org>
 

Created: 10 Aug 2004

Last Modified: 8 Aug 2011
Version: 238
 

このドキュメントは小規模の語彙の条項と類型学の問題をカバーする Apocalypse 2を要約する。 （これらの Synopses は「歴史のドキュメント」としてやがての長い間、氷のように冷たい Apocalypse と異なった Perl 6 の進化するデザインを反映するために同じく更新を含む。 これらの更新は記録されていない － もし Synopsis がその Apocalypse と共に不一致であるなら、 Synopsis が正しいと想定しろ。）

部分言語のパーサーによって許されたエクステントに、 Perl はワンパス、予測型構文解析器を使って解析される。 すなわち、1つの「最も長いトークン」よりいっそう多くの先読みは落胆している。 現在これの周知の例外がパーサがそうしなくちゃならないところだ：

• シギルから始めて、そして括弧で終わるかもしれない、あるいはそうしないかもしれない補間挿入された展開式の終端を見つけろ。

• 減算演算子が本当に始まっていないことを認識する[...] 生成するもの。

抽象的に、 Perl は Unicode で書かれる、そして基礎をなしている文字列内部表現にかかわらず一貫した Unicode 意味規則を持っている。 デフォルトまでに Perl は「NFG」形式で Unicode を提出する、そしてそこでそれぞれの書記素が文字を1（人・つ）として勘定に入れる。 A　書記素は初心者が（彼・それ）らの標準の日常生活で文字であると考えるであろうもの、何でも含めて発音記号だ。

Perl は Unicode ラインとパラグラフセパレータをラインマーカとして勘定に入れることができる、しかしその振る舞いは、 Perl の行番号の考えがあなたのエディタが Unicode ラインについて考えることとマッチするように、設定可能である方が良い。

Unicode 水平空白が空白文字として勘定に入れられる、しかしそれらがトークンに隣接することを一つのトークンのように見えさせるであろう細いスペースを使わないほうが良い。 他方、 Perl は字下げを構文として使用しない、あなたがどんな量の空白文字でも使うことが自由であるように、どこでもその空白文字は意味をなす。 コメントは常に空白文字として扱われる。

若干の構文的な目的で、 Perl は括弧文字を括弧でないから区別する。 文字がそうである Bracketing が双方向性のミラーリングあるいは Ps/Pe/Pi/Pf プロパティでどんな Unicode 文字とでも定義される。

実際は、けれども、あなたは Ps/Pe/Pi/Pf プロパティでマッチしている文字を使って最も安全だ、 ASCIIのアングル括弧が、それらから、顕著な例外であるけれどもで双方向性だが、 Ps/Pe/Pi/Pf セットでじゃない。

対応する終わりの文字がない文字が括弧の開始として修飾しない。 これは Unicode BidiMirroring データ表の2番目の項を含む。

もし文字がすでに Ps/Pe/Pi/Pf マッピング、それから何かで使われるなら、 BidiMirroring の入力が無視される（共に前進的な、そして後ろ向きのマッピング）。 何のためにも Ps 文字という条件のもとで、たとえそれがあなたが左右対称性を使って推測するかもしれないことじゃないとしても、次の Pe 符号位置（数値順に）はそのマッチしている文字だと考えられる。 そのためにU+298D マップ先U+298EそうじゃないU+2990そしてU+298F マップ先U+2990そうじゃないU+298E. 　いずれもU+298E 同様にU+2990 BidiMirroring テーブルで逆のマッピングを持ったにもかかわらず、正当な括弧開始だ。

U+301D 符号位置が代替物を閉じている2を持っているU+301E そしてU+301F；6がただそれと共に（の・もの・人）を認識するだけである Perl がより低いという状態で、ポイント番号をコードする、U+301E閉じ括弧として。 このポリシーは同じく将来開始された新しい1対多のマッピングに当てはまる。

しかしながら、多対1マッピングは素晴らしい；多数の冒頭の文字が同じに終わりの文字をマップするかもしれない。 例えば、U+2018U+201AそしてU+201B すべては賛成で開始として使われるかもしれないU+2019 閉じ。 開始と閉じを数える Constructs は、ただ所定の開始だけが特別であると想定する。 すなわち、もしあなたが代替物の1つで始めるなら、他のすべての代替物がその構造の中で括弧でない文字として扱われる。

Pod のセクションが Perl 6 に確実に複数行コメントとして使用されるかもしれない。 Perl 5 、構文が今あなたに使わせる Pod の場合と異なり=begin comment そして=end comment 賛成の必要性なしで正確に Pod ブロックを区切れ=cut. 　（実際、=cut 今なくなっている。） フォーマット名はそうじゃなくてもよいcomment － 認められないフォーマット名がそれをコメントにするためにするであろう何も。 （しかしながら、そのままだ=begin そして=end おそらく十分に良くなくて、すべてがそれらでコメントするからフォーマット済み出力の中で現われるだろう）

我々は段落が一緒にコメントするシングルを打つ=for comment 同様に。 それほど賃貸物件的だ=for その意味を同等物として保持すの=begin そして=end 結合された。 と同じように=begin そして=endその後コード化するコード化が逆戻りするという始まられたコメント。

最初の前に改行があるから=改行と等しい空白文字としてのコメントカウントの Pod 形式。 埋め込みのドキュメンテーションでさらに多くのために S26 を見ろ。

リテラルのクォートの中で以外 , a # 文字が常に Perl 6 にコメントを開始する。 上に基礎を置かれたコメントの2つのフォームがある#. 　コメントが必要とする Embedded # backtick によって後に続かれること（`）1つ以上の冒頭の括弧文字を足した.

他が使うすべて# ただ Perl 5 のようにうまくいく単一行コメントとして解釈される、皮切り# 次の改行の文字と終末。 それらが分離の目的で改行と等しい空白文字として扱われる。 Perl 5 の場合と異なり、# 構造を引用することにおいて区切り文字として使用されないかもしれない。

埋め込みのコメントが、構文を引用することについて、変形としてサポートされて、通り過ぎて開始される#` そしてどんなユーザーが選択した括弧文字（Bracketing に定義されると同じように、上の文字）でも：

say #`( embedded comment ) "hello, world!";

$object\#`{ embedded comments }.say;

$object\ #`「
    embedded comments
」.say;
 

括弧が普通のクォート括弧と同じポリシーの後に、ネストされるかもしれない。

中間のスペースがあってはならない#` そして括弧開始文字。 （上記の若干の二倍幅文字のため、しかしながらカギ括弧のような、スペースの外見があるかもしれない。）

複数行コメントのために共に視覚の明快さのために2かそれ以上の括弧を使うことと、コメントするとき、あまりに多く内部の括弧計数発見法に頼るのを避けることはコード化する、それが偶然に一つの括弧を数え間違うかもしれないことは推薦されている（しかし必要とされるのではなく）：

#`{{
    say "here is an unmatched } character";
}}
 

しかしながら、それらが暗黙のうちにライン志向であるから、 Pod コメントを使うほうが時々良い。

すべてユーザーが選択した括弧を使う構造を引用することに対して、あなたは閉じ括弧の同数によって閉じられなくちゃならない多数の同一の括弧文字で始めることができる。 ネストされた括弧を数えることは括弧の開始と同じ長さの括弧のペアにだけ当てはまる：

say #`{{
    This comment contains unmatched } and { { { {   (ignored)
    Plus a nested {{ ... }} pair                    (counted)
}} q<< <<woot>> >>   # says " <<woot>> "
 

どんなに接周辞あるいは後置接周辞がそれほどそのままであるとしても、注意しろ<<...>> ではない － が括弧、しかし ASCIIの変形を選んだユーザ«...» 補間ワードリスト。 それ以外の何ものでもなく#` そしてq－ スタイルクォート文字（含むmstrそしてrx）次のユーザーが選択した括弧を可能にする.

Cのような若干の言語がラインを結合するためにあなたに改行文字をエスケープすることを許す。 （正規表現のような）他の言語があなたが種々の理由でスペース文字をバックスラッシュすることを可能にする。 Perl 6 はこの概念を空白文字について親切な何にでも一般化する。 連続的な空白文字が（コメントを含めて）それと一緒それを前接続することによってのパーサから隠されるかもしれない Any \. 　これは「unspace」として知られている。 unspace が Perl にいくつかの空白文字依存の何でも隠すことができる。 例えば、 Perl が中間で空白文字の欠如を必要とするから、 unspace を使っている演算子があなたに確保させる名詞と接尾辞が演算子に後接続する：

%hash\  {$key}
@array\ [$ix]
$subref\($arg)
 

上に使用をサポートするべき特例として、接尾辞が期待されるバックスラッシュが変化した形の unspace だと見なされる。 空白文字ではないが、従って、前にそれを許したことに注意を払え

$subref \($arg)
 

シンタックスエラー（一列に並んだ2つの項）だ。 そして

foo \($arg)
 

リスト演算子と解析されるだろうでCapture 引数：

foo(\($arg))
 

しかしながら、 unspace の他のフォームは有効に空白文字を前もって与えられるかもしれない。 （従ってバックスラッシュの Unary の使用が決して空白文字によって後に続かれないかもしれない、あるいはそれらが unspace と思われるだろう。）

他の接尾辞演算子が同じく unspace を利用するかもしれない：

$number\  ++;
$number\  --;
1+3\      i;
$object\  .say();
$object\#`{ your ad here }.say
 

－ が － これ － が間隔を置くのを見るもう1つの － がそうしないあなたの標準の使用が次のラインにドットを打たれた接尾辞を載せるために典型的にだ：

$object\ # comment
.say

$object\#`[ comment
].say

$object\
.say
 

けれども unspace が主に言語拡張性についてだ：それはあなたに何もの中の行改行が、あなたの現在インストールされたパーサにかかわらず、パーサを混乱させるかもしれない状況を続けさせる。 （もちろん、あなたが unspace 規則自身をオーバーライドしないなら．．．）

我々が unspace がパーサから空白文字を隠すと言うけれども、それはレクサーから空白文字を隠さない。 結果として、と unspace ではないがトークンの中で認めた。 さらに、もし unspace が1つ以上の改行を含んでいるなら、行番号がまだ数えられる。 Pod から、言語への空白文字、それらが同じく unspace によって飲み込まれる（とき・から・につれて・ように）、チャンクが数える。 しかしながら、 Heredoc の境界が隠される、それであなたはこのような過度に長いヒアドキュメントイントロラインを分割することができる：

ok(q:to'CODE', q:to'OUTPUT', \
"Here is a long description", \ # --more--
todo(:parrøt<0.42>, :dötnet<1.2>));
    ...
    CODE
    ...
    OUTPUT
 

それがただ見えるヒアドキュメントパーサに：

ok(q:to'CODE', q:to'OUTPUT', "Here is a long description", todo(:parrøt<0.42>, :dötnet<1.2>));
    ...
    CODE
    ...
    OUTPUT
 

我々がただ接尾辞パージングのケースのように、すべての空白文字ではなく、改行変化を隠そうとすることだけをしているから、これが unspace の前に空白文字を持つことが素晴らしいそれらの事例の1つであることに注意を払え。 （同じくではないの上の例が仕様書にテスト組曲がどのように機能するかを意味したことに注意を払え。 ）

unspace がコメントを含むかもしれない、しかしコメントが unspace を含んでいないかもしれない。 特に、流れ作業の終わりのコメントがバックスラッシュを重要であるとして扱わない。 もしあなたが言うなら：

#`\ (...
 

あるいは

#\ `(...
 

それはラインの終わりのコメントだ、埋め込みのコメントじゃない。 書け：

\ #`(
     ...
    )
 

他のことを意味するために。

一般に、空白文字はそれが一つのトークンあるいは他の構文的な単位と誤解されるであろう構造を分離するために必要とされるところ以外 Perl 6 にオプションだ。 （言い換えれば、 Perl 6 は標準的なか、あるいは大きい構造のケースの最も長いトークンの原理に従う、シフトする方が原理を減らすより好きである. トークンの中に Perl プログラムがどのように分析されるかについて、下にさらに多くのために Grammatical Categories を見ろ。）

これは不変の深い規則だ、しかしそれの表面の波及効果は種々の演算子として変化する、そしてマクロが追加されるか、あるいは言語から取り除かれる、そしてそれを我々が、 Perl 6 が変更可能な言語であるよう設計されるから、起きるために期待する。 特に、接尾辞演算子とインフィックス演算子、項の後にどちらが起こるかもしれないかのいずれかの間に自然の競合がある。 もし所定のトークンが同じぐらい同様解釈されるかもしれないなら接尾辞演算子、あるいはインフィックス演算子、インフィックス演算子はそれの前にスペースを必要とする。 それらが介入しているドットを持っているかもしれないけれども、接尾辞演算子が決して介入しているスペースを持っていないかもしれない。 もしさらなる分離が切望されるなら、空白文字が unspace あるいは埋め込みのコメントの外（に・で）起こらない限り、 unspace あるいは埋め込みのコメントが上記のように使われるかもしれない。

例えば、もしあなたがあなた自身のものを加えるならinfix:<++> 演算子、それからそれはそれの前にスペースを持っていなくちゃならない。 標準の自動的に増加することpostfix:<++> 演算子が決してそれの前にスペースを持っていないかもしれないかもしれない、しかしこれらのフォームの何にでも書かれるかもしれない：

$x++

$x\++

$x.++

$x\ ++

$x\ .++

$x\#`( comment ).++
$x\#`((( comment ))).++

$x\
.++

$x\         # comment
            # inside unspace
.++

$x\         # comment
            # inside unspace
++          # (but without the optional postfix dot)

$x\#`『      comment
            more comment
』.++

$x\#`[   comment 1
comment 2
=begin Podstuff
whatever (Pod comments ignore current parser state)
=end Podstuff
comment 3
].++
 

接尾辞規則の結果が（クォートを区切るか、あるいは unspace を終了させるときを除いて）、それの前の空白文字と一緒のドットが上に常にメソッド呼び出しだと見なされるということだ$_ 項が期待されるところ。 もしこの時点で期待された項ではない、それがそうであるなら構文錯誤。 （もちろん、ドットから始まるその名前のインフィックス演算子がないなら。 あなたは、例えば、 Fortranly を定義することができたinfix:<.EQ.> もし体調が良い（人たち・もの）があなたを連れて行ったなら。 けれどもあなたは常に空白文字をそれの前（に・で）置くことを確かにしなければならないだろう、あるいはそれはその代わりに接尾辞メソッド呼び出しとして解釈されるだろう。）

例えば、

foo .method
 

そして

foo
.method
 

常に解釈されるだろうけれども

foo $_.method
 

ただ決してけれども

foo.method
 

いずれかの変形を使え

foo\
.method
 

もしあなたが接尾辞メソッドに呼び出しを意図するなら。

あなたがもう Num を書かないかもしれないこのすべての結果がである（の・もの・人）42. ただ後続するドットで。 あなたは同様その代わりに言わなくちゃならない42 あるいは42.0. 　言い換えれば、もし次の文字が数値であるなら、数の後に続くドットがただ少数点であることができるだけだ。 さもなければ接尾辞ドットは何らかの種類のメソッド呼び出し構文のスタートであるためにとられるだろう。 （.123 ドットが予想されてまだ許可しかしながら項がいつであるかであって、そして等しい前置でできろ0.123 よりむしろ$_.123.）

Perl 6 はもっと良く運用成績を示すあなたがより安全なコード化を書くのを助けるオプションの型システムを持っている。 コンパイラはあなたが供給する型からそれがそうすることができる何の型情報を推論することが自由だ、しかし、あなたがそれにそうするように頼まないなら、それは欠けている型情報について不平を言わないだろう。

Perl 6 は OO 機関だ、しかしあなたは一般に OO にそれがいつ不便であるか考えるように要求されない。 しかしながら、ファイルハンドルのような若干の組込みコンセプトが Perl 5 によりユーザーに見える方法でいっそうオブジェクト指向だ。

OO カプセル化を支持して、新しい基本的なデータ型がある： P6opaque 。 外部アクセスは不透明なオブジェクトに属性のためにさえ、常にメソッドを通して呼び出しだ。

型が構造同値よりむしろ公式に名前同値を使って比較される。 しかしながら、我々は我々が名前だと見なすことでどちらかと言うとリベラルだ。 例えば、名は、（たとえ型がそれ自身「匿名である」としても）、型を定義しているモジュールと結び付けられるバージョンと権限を含む。 それを越えて、あなたがパラメータを伴う型のインスタンスを作る、引数が結果として生じている型の「ロングネーム」の一部だと見なされる時、それで1（人・つ）Array of Int もう1つと等しいArray of Int. 　（それを見るもう1つの方法が型インスタンス化「ファクトリ」がメモ化されるということだ。） Typename 別名がオリジナルの型と等しいと見なされる。 詳細、でArray of Int 構文がただ構文糖に過ぎない賛成Array:of(Int)それはインスタンスを作られた一般的な型の標準形だ。

パラメータを伴う型のこの名前同値は不変であると見なされることができるパラメータにだけ及ぶ（あるいはそれは少なくとも不変のスナップショットがそれらの所有されるようにすることができる）。 2つの別のクラスが、たとえ、クラスが不変であると見なされないから、それらが同じ属性を持っているとしても、決して同等であると見なされない。

Perl 6 はオブジェクトの各種の上にプロパティの概念をサポートする。 プロパティはオブジェクトのようだ、そのそれら以外の、属性がオブジェクトのクラスのそばによりむしろ個別のオブジェクトによって管理される。

S12 によれば、プロパティが実際に一種のミキシン機構によって実装される、そしてこのようなミキシンはオブジェクトの間（同一の匿名のクラスがすでに存在して、そして安全に共有されることができないなら）個別の匿名のクラスの発生によって達成される。

オブジェクトが、変数とクラスのような、コンパイル時において作成した申し込まれたプロパティが同じくトレイトと呼び出される。 トレイトが実行時において変えられることができない。 コンパイラがトレイトだと宣言されて最適化することができる実行時プロパティに対する変更がその代わりにミキシンとしてで、そうにされる。

変数の型は変数がどんな種類の値を含んでいるかもしれないかを示す束縛だ。 いっそう正確には、オブジェクトあるいはオブジェクトに含まれる項目、変数、が示された「ロール」のメソッドに返答することができることは約束だ。 ロールについてさらに多くのために S12 を見ろ。

# $x can contain only Int objects
my Int $x;
 

変数がそれ自身、それがどんな種類のことを含んでいるか明示しないで、コンテナがどのように作用するか明示するコンテナ型にバインドされるかもしれない。

# $x is implemented by the MyScalar class
my $x is MyScalar;
 

拘束知識とコンテナ型が一緒に使われることができる：

# $x can contain only Int objects,
# and is implemented by the MyScalar class
my Int $x is MyScalar;
 

それに注意しろ$x 同じく初期化される to the Int 型オブジェクト。 これに関してさらに多くのために下を見ろ。

my Dog $spot ひとりでに自動的に電話をするDog コンストラクタ。 それはただ未定義を割り当てるDog オブジェクトのプロトタイプを作れ$spot：

my Dog $spot;           # $spot is initialized with ::Dog
my Dog $spot = Dog;     # same thing

$spot.defined;          # False
say $spot;              # "Dog"
 

値が短くしてその型のプロトタイプのオブジェクト、あるいは型オブジェクトの未定義の実例である（とき・から・につれて・ように）、使われた Any 型名。 それの上にさらに多くのために S12 を見ろ。

右辺値コンテキストでの Any 型名が一つの型値と解析されて、そしてそれの後に引数を期待しない。 しかしながら、もし関数と呼び出しに供給された引数が示されて型に強制される何かが型オブジェクトであったなら、型オブジェクトが関数呼び出し接合点、あなたが括弧で型の名前をもしとして使うかもしれないようにそれに返答する。 もし括弧に引数がないなら、型オブジェクトはそれ自身を返す：

my $type = Num;             # type object as a value
$num = $type($string)       # coerce to Num
 

実数を得るためにDog オブジェクト、コンストラクタメソッドをそんなものと呼べnew：

my Dog $spot .= new;
my Dog $spot = $spot.new;   # .= is rewritten into this
 

権限：が同様にコンストラクタに引数でパスする：

my Dog $cerberus .= new(heads => 3);
my Dog $cerberus = $cerberus.new(heads => 3);   # same thing
 

括弧で括られた形の型自動型変換は型のより広いセットを受け入れるが、狭い型にそれらを強制することが意味をなす宣言で使われるかもしれない。 （これはただ1方法の自動型変換に有効であるだけだ、それであなたは何も申告してはならないrw 強制的な型と一緒の仮引数。） 括弧の外の型は望ましい最終結果と次のコード化が上に依存するかもしれないことを示すそれその型である. 括弧の中の型はバインドされることを可能にされるか、あるいは自動型変換としてのこの場所に割り当てられる型の受容できるセットを示す。 もし広い型が除かれるなら、Any 仮定される。 何ででも場合、広い型はただ強制するべきパーミッションを示しているだけだ；広い型から実際に自動型変換を行なう狭い型までの利用可能な自動型変換ルーチンがまだなくちゃならない。

sub foo (Str(Any) $y) {...}
sub foo (Str()    $y) {...}    # same thing

my Num(Cool) $x = prompt "Gimme a number";
 

もしあなたが言うなら

my int @array is MyArray;
 

あなたはそれを要素だと宣言しているの@array 配列がそれ自身実装されるネイティブの整数、しかしそれであるMyArray クラス。 型宣言されていない配列とハッシュはまだ完全に受容できるが、同じ性能の問題それらが Perl 5 を仕入れるようにする。

使用配列で要素の数を得ること.elems メソッド。 あなたはこれらのメソッドを使って、バイト、符号位置あるいは書記素で、同じく配列の要素の全体の文字列長さを求めることができる.bytes.codes あるいは.graphs それぞれ配列に。 同じメソッドは同様に文字列に申し込む。 （それに注意しろ.bytes エンコーディングが未知であるとき、ではないが明瞭であることを約束した。 同様に、.codes あなたがどの標準化が実施されるか知らないなら明瞭なではない。 従って、もしそれがコンテキストから知られていることができないなら、両方のメソッドがオプションの引数が正確に意味を指定することを可能にする。）

ノーがある.length 配列あるいは文字列のためのメソッド、からlength 単位を指定しない。

組込みオブジェクトタイプが英字を大文字で始める。 これは不変の型を含む（例えば. IntNumComplexRatStrBitRegexSetBlockIteratorSeq）、変更可能な（コンテナ）型と同様、そんなものけれどもScalarArrayHashBufRoutineModuleそしてインスタンス化できないロールようCallableFailureそしてIntegral.

非オブジェクト（ネイティブの）型は小文字だ：intnumcomplexratbufbit. 　ぎっしり詰まった配列記憶域を宣言することに対して、ネイティブの型が主に意図的だ、とすなわち、指定された型の記憶域ロケーションの列がメモリに連続してポインター間接参照なしで並べた。 しかしながら、もしあなたがそのようにそれらを扱うなら、 Perl はそれらを（彼・それ）らの対応する大文字の型のように見えさせようとするだろう。 （言い換えれば、それはオートボクシングをする。 注意しろ、しかしながら、その時々繰り返されたオートボクシングはネイティブの型がそれを速めることができる以上にあなたのプログラムを遅らせることができる。）

若干のオブジェクト型が値型として振る舞うことができる。 すべてのオブジェクトがハッシュコーディングと他の値ベースの比較のためにユニークにオブジェクトを識別する「それ」値を作り出すことができる。 標準のオブジェクトがただそれら識別情報として、しかしもしクラスが、値型、それが定義することができるように、振る舞うことを望むならそれら場所を使う.WHICH 異なったオブジェクトを、もしそれらが同じコンテンツを持っているために起きるなら、同じオブジェクトのように見えさせるメソッド。

我々が標準のオブジェクトがその場所をその識別情報として使うと言うとき、我々は数としてそれがそのアドレスを返すことを意味しない。 第一に、すべてのオブジェクトではなくが同じメモリ空間にいる（例えば NUMA で文献を見る）、そして、ただ単にそれらが同じことで記憶されたという理由で、2つのオブジェクトが2の異なったメモリー空間で埋め合わせられて偶然に同じ識別情報を持つべきじゃない。 我々は同じく本当に数（あるいは文字列、あるいは他のいかなるも世俗的な値型）である値で不慮の識別情報衝突を許すことを望まない。 同様に我々は人々にオブジェクトの場所についてその何での方法もケースと考えるよう奨励しているべきじゃない。 それでWHICH もう1つのオブジェクトよりむしろまだ値を返す、しかし値がスペシャルの（こと・もの）に違いないことObjAt 偶然の混乱を防ぐ型が標準の値型で、そして少なくとも些細なポインタ算術式を思いとどまらせる。

確かに、すべてのこのような空間の中で、すべての可能なアドレスは言うまでもなく、すべての可能なアドレス空間に固有の名を与えることは難しい。 普遍的な命名スキームがないので、2つの異なったスペースからの2つのアドレスが衝突するであろうことはただありそうになくされ得る。 番号がアウトプットの上に現在のアドレススペースを表すかもしれない十分に大きいランダムObjAt 異なったアドレス空間に、あるいはもし YAML あるいはXMLに直列化されるなら。 （この余分の識別情報コンポーネントは、あなたのプロセスが本当に NUMA の下を走っていないなら、それが首尾一貫して同じ大きい数だろうから、現在のアドレス宇宙を負うメッセージをデバッグすることに対して、出力される必要がない。）

代わる代わる、もしオブジェクトがオブジェクト識別性を維持しないフォームに直列化されているなら、ユニークさを維持する要件がない、オブジェクトがこれにあるから、収納ケースが本当に値型表示に翻訳されて、そして異なったユニークなオブジェクトとしての他方の端で再編成されている。

缶が常に未定義値、そんなものを含むネイティブでない型と一緒の変数AnyWhatever そしてFailure オブジェクト。 失敗（すなわちスローされない例外）についてさらに多くのために S04 を見ろ：

my Int $x = Int;    # works
 

ネイティブの型と一緒の変数が未定義をサポートしない：それはそれらに未定義の値を割り当てるために錯誤だ：

my int $y = Int;    # dies
 

それ以来num 値をサポートすることができるNaN 未定義の一般的なコンセプト以外、あなたはこのように未定義の値を強制することができる：

my num $n = computation() // NaN;
 

明示的に定義された値に初期化されないなら、ネイティブでない型の変数が未定義の値を含んでい始める。

すべてのオブジェクトサポートHOW オブジェクトが定義されるかどうかにかかわらず、それを管理しているメタクラス実例を返す関数 / メソッド：

'x'.HOW.methods('x');   # get available methods for strings
Str.HOW.methods(Str);   # same thing with the prototype object Str
HOW(Str).methods(Str);  # same thing as function call

'x'.methods;        # this is likely an error - not a meta object
Str.methods;        # same thing
 

（プロトタイプシステム（非クラスベースのオブジェクトシステム）のために、すべてのオブジェクトはただ同じメタオブジェクトによって管理される。）

Perl は能力あるいはインタフェースを表す呼び出されるもの「ロール」を通しての一般的な型をサポートする。 これらのロールは一般に直接オブジェクトタイプとして使用されない。 すべての数の型が実行する例えばNumeric ロールとすべての文字列型は能力を発揮するStringy ロール、けれども「数の」オブジェクトなどというものはない、これらからインスタンスを作られなくちゃならない一般的な型は生産するべき余分の引数が標準であるという状態で、オブジェクト型か。 共通ロールが次のものを含む：

Stringy
Numeric
Real
Integral
Rational
Callable
Positional
Associative
Buf
Blob
 

Perl 6 は本質的に型宣言のそのシステムを通しての大きい整数と有理数をサポートする。 Int 持株と同様、自動的に随意精度への昇進をサポートするInf そしてNaN 値。 それに注意しろInt それほど、2の補数算術を仮定する+^1 == -2 保証されている。 （ネイティブだint 演算が2のが補完するネイティブでじゃない機械の上にこれをサポートする必要がない。 あなた不可欠変換しろInt このような老朽したハードウェアでポータブルビット演算をするために。）

Num 全速力で走る最も大きいネイティブの浮動小数点フォーマットをサポートしなくちゃならない。 それは随意精度型にバインドされるかもしれない、しかしデフォルトまでにそれはネイティブとして同一性だnum. 　下を見ろ。

Rat 拡張精度有理数算術をサポートする。 分周2Integral オブジェクトが使うinfix:</> 生産するRat一般に、どこでも有用であるNum 有用だ、しかし同じく明示的に投げられるかもしれないそうすることNum. 　（同じく、もしいずれかの側がそうであるならNum すでに、infix:</> あなたを与えるNum 代わりにRat.）

Rat そしてNum 両方ともはそうするReal ロール。

小文字の型が好むint そしてnum それぞれ整数と浮動小数点の数でネイティブのマシン表示を暗示しろ、そして、随意精度に、より大きい表示が常に考慮に入れられるけれども一時的な値を促進するな。 多くのビットで、修飾されないなら、int そしてnum 型が最も大きいネイティブの整数と全速力で走る浮動小数点の型を表す。

型宣言されていない変数での数の値が使うInt そしてNum どちらかと言えば意味規則よりint そしてnum.

しかしながら、実利的な理由で、Rat 値がただあるポイントまで正確であることを保証される。 デフォルトまでに、これは通り過ぎて表されるであろう精度であるRat64 型、エイリアスがどちらのためかRational[Int,uint64]分子を持っているのInt けれども分母に制限されるのuint64. 　ARat64 分母での64ビット以上の記憶域が自動的にあるいはそうするよう変換されることを要求するであろうNum あるいはより小さい精度にRat実装の裁量において。 （ネイティブがそんなものをタイプするけれどもrat64 同じサイズにではないけれども、分子と分母両方の大きさを制限しろ。 分子はユーザ期待をサポートするために一般に分母のサイズの2倍のべきだ。 例えば、rat8 実際はサポートRational[int16,uint8]ナンバーが好むことを認める100.01 表されるために、そしてrat64定義されたけれどもRational[int128,int64]容器アト秒精度で Big Bang から秒後の番号を持つ. 多分アト秒正確度でではないけれども．．．）

上に限界Rat 値がユーザーに見える型にだけ実施されるように意図される。 値が内部的に計算で値を使った Intermediate Rat 演算子がこの精度を超えるか、あるいは負の分母を表すかもしれない。 すなわち、新しい分子と分母が（少なくとも抽象的に）であると計算するのに使われた一時値のInt 型。 新しい分子と分母が（今まで）決定された後、符号付きの何でも分子によってだけ表されることを強いられる。 それからもし分母が使われた符号なし整数の記憶容量を超えるなら、分数は減らされる gcd として. もし結果として生じている分母が静かであるなら、それから、そしてそれ以外の何ものでもなく、記憶容量より大きいそれで精度が減らされるか、からフィットされたRat あるいはNum.

Rat もしその分母がそれほど正確じゃない分母の整数倍であるなら、付加と減法がいっそう正確な引数の分母を維持しようと試みるべきだ。 すなわち、実際的な項で、ドルとセントの柱を加えることは、たとえ42と 3.5 のような値が一部とみなされたとしても、一般に100の分母を持っている結果で終わるべきだ。 他の演算子で、この保証はされることができない；このような場合、ユーザはおそらくとにかく特定の分母に明示的に四捨五入しているべきだ。

性能のコストで、本当に、分子と同様、随意精度分母を必要とするアプリケーションのためにFatRat 使われるかもしれない、確定がどちらとしてかRational[Int,Int]すなわち、随意精度として両方の地域で。 賛成のリテラルの形式がないFatRatそれが使って作成されなくちゃならないようにFatRat.new($nu,$de). 　一般に、ただ少なくとも1を持っている数学演算子だけFatRat 引数がもう1つを返すだろうFatRat偶然の昇進を防ぐためにの適度に速いRat 値の中に独断的に遅いFatRat 値。

gcd アルゴリズムを通して、 Perl が有理数を許すすぐ後に、たいていの有理数実装が（彼・それ）らの最も小さい表示に分数を標準化するか、あるいは「減らす」けれども、いい加減にそうするべきデータ型が分母が精度を使い果たすが、さもなければオーバーヘッドを避けるであろうときはいつものように、そうする必要がある。 従って、あなたが房を加えているもしRat例えばドルとセントを表すs、分母は全部の方法で完全に100のままでいるかもしれない。 .nu そして.de メソッドがこれらの unreducedな値を返すだろう。 権限：の使用$rat.=norm 分数を標準化するために。 （これは同じくサインオン、分母、に確かであることを強いる。） .perl もし分母が10の力、あるいは（すなわち、ただ2と5（そして－1）だけの要因を持っている）10の力に標準化可能であるなら、メソッドが10進数を作り出すだろう。 さもなければそれは形式についてリテラルで有理数を標準化して、そして返すだろう-47/3. 　有理数を文字列化することは、10進法 - 標準化可能な分数、しかしどこ（で・に）かについての同じ結果で、類似の計算をする.perl 生産するだろう-47/3 その代わりに形式、文字列化が変換するそうすることNum そして有理数の内部形式がいくぶん一般に純粋な10進法を見ることをより好むであろう一時的ユーザーに隠されるように、それを文字列化する。

say 1/5;    # 0.2 exactly (not via Num)
say 1/3;    # 0.333333333333333 via Num

say <2/6>.perl
            # 1/3

say 3.14159_26535_89793
            # 3.141592653589793 including last digit

say 111111111111111111111111111111111111111111111.123
            # 111111111111111111111111111111111111111111111.123

say 555555555555555555555555555555555555555555555/5
            # 111111111111111111111111111111111111111111111

say <555555555555555555555555555555555555555555555/5>.perl
            # 111111111111111111111111111111111111111111111/1
 

デフォルトによっての6が標準的な IEEE 浮動小数点コンセプトを目に見える、そんなものであるようにする Perl Inf （無限大）そしてNaN （数ではない）。 レキシカルスコープの中で、プラグマが一時的な値と浮動小数点がどのように種々の状況の下で振る舞うはずであるかの性質を指定するかもしれない。 すべての IEEE 様式はレキシカルに利用可能に違いないそれが型落ちのプラットフォームを迂回する英雄にふさわしい努力を必要とするであろうケース以外でのプラグマとして.

デフォルトの浮動小数点のモードは例外をスローしない、しかしどちらかと言えば Inf と NaN を伝える。 オーバーフローあるいはアンダーフローが起こったオブジェクト型がいっそう詳細な情報を振る舞うかもしれないボックス化された（人たち・もの）。 Perl での Numeric がどこでも同一の答えをするよう設計されない。 それらがほとんどいつも十分良い答えを達成するために典型的なプログラマにツールを与えるよう設計される。 （本当に良いプログラマーが時折さらにいっそううまくやるかもしれない。） 主としてこれはただ十分のビットを使うことを必然的に必要とするので、アルゴリズムの愚かさはあまり重要じゃない。

AStr Unicode 文字列オブジェクトだ。 ネイティブに文通することはできないstr 型。 しかしながら、それ以来Str オブジェクトが多数のロールを満たすかもしれない、我々はそれを言うStr その最小および最大 Unicode 要約レベルを記録・追跡して、そしてうまく理想的な文字、それが若干の言語でバイト、符号位置、書記素、あるいは文字かどうかの現在のレキシカルスコープのアイデアに協力する。

すべての組込み演算、すべてのためにStr ポジションが、整数ではなく、オブジェクトを置くように、報告される。 これらStrPos 直接文字列とポジションを追跡することによって、あるいは、同じ結果を与えるであろう、もし何での同じ文字列にでもコンテキストを用いた文字列の初めからオフセット値の要約 - レベル独立表示を生成することによって、オブジェクトが要約レベルの特定の場所独立の特定の文字列の中にポイントする。 これは文字列がその間修正されないと想定している；StrPos 「目標」とではないが続くのに要したではないが変更可能な文字列に変わる。 例えば、もしあなたが置換によってされたマッチのポジションを求めるなら、答えは修正された文字列の中で、ポジションとしてではなく、オリジナルの文字列（それは今アクセスできないかもしれない！）について項で報告される。

2の減法StrPos オブジェクトを寄贈するStrLen 文字列が2つのポジションの間に同じく単位に依存している多数の整数解釈を持っているから、同じく整数じゃないオブジェクト。 既定の事実StrLen それが18バイト、7つの符号位置、3つの書記素、を表すことを知っているかもしれないそして 1 　それが実際にただ2（人・つ）にしがみつくから、 Malayalam 、しかしそれでの英字がただいい加減にこれを知っているかもしれないStrPos 今度は文字列の中にただいい加減にポイントするかもしれない、あるいはそうしないかもしれない文字列の中の終端。 （いい加減な実装のStrLen たくさんの同種のものであるRange その点でオブジェクト。）

もしあなたが整数をポジションオブジェクトが期待される引数として使うなら、あなたが現在の単位がレキシカルに Unicode 要約レベルをスコープ宣言したことを意味すると想定されるだろう。 （それは書記素をデフォルトとする。） さもなければあなたはプロパーに単位を強制する必要があるだろう：

substr($string, Bytes(42), ArabicChars(1))
 

もちろん、このような次元の数は、もし適切な要約レベルを提供しない文字列で使われるなら失敗するだろう。

もしStrPos あるいはStrLen 強制的に数のコンテキストに追い込まれる、それは現在の Unicode 要約レベルの単位を想定するだろう。 それは間違った単位でそれを解釈するであろうこのようなルーチンへの次元でない数でパスするために、誤っている。

実装ノート： Perl 6 がデフォルト Unicode 処理段階が符号位置よりむしろ書記素を基本的な単位だと見なさなくちゃならないことを命令するから、これは効率的な実装に関して若干の帰結的意味を持っている。 すべての書記素がインプットでユニークな書記素に翻訳されることは提案される数と高速の substr アクセスのために何らかの種類の同一の配列の中で整数として表された. 前もって書かれた形を持っているそれらの書記素のために、その符号位置の使用が提案される。 （これが Latin - 1がまだ 8 ビット整数で内部的に表されることができることを意味するとは、注意しろ。）

前もって書かれた形を持っていない書記素のために、ユニークに書記素を識別する一時的な私的な id が割り当てられるべきだ。 もしこのような id がプロセス全体（で・に）首尾一貫して割り当てられるなら、2つの書記素の比較は id から NFD へのテーブルの中に2つの整数の比較と直接ルックアップと比べて同じ程度に難しい卑しい文字の比較以上に困難であるわけじゃない。

明らかに、何でも一時的であるという状態で、書記素 id がアウトプットで（NFD のような）いずれかの普遍的なフォームに戻って翻訳されなくちゃならない、そして標準の前もって作曲された書記素が望ましいアウトプットで依存してNFCあるいは NFD フォームに変わるかもしれない。 プロセスの人生にわたって特定の書記素 / id マッピングを維持することは、長く続いているプロセスのために、若干の GC 帰結的意味を持っているかもしれない、しかしたいていのプロセスが多分前もって作曲されない書記素の限定された数を見るだろう。

もしプログラムが書記素ビューよりむしろ符号位置ビューを必要とするスコープを持っているなら、そのレキシカルスコープに見える文字列は同じく、ただアウトプット翻訳と同じように、普遍的なフォームに翻訳されなくちゃならない。 代わる代わる、一時的な書記素 id は要約層の後ろに隠されるかもしれない。 何でもケース、符号位置スコープが決してどんな一時的な書記素 id でも見るべきじゃない。 （語彙の符号位置宣言はおそらくそれがどの正規化形式の下で文字列を見ることをより好むか明示するべきだ。 このような宣言は同様にインプット翻訳に応用され得た。）

ABuf 整数の配列の文字列的ビューであって、そして Unicode を持たないあるいは明示的型変換がない文字プロパティ、からいくぶんまあStr.（buf8buf16buf32そしてbuf64 型はネイティブの対応物だ；ネイティブの buf 型がバッファー全体のために連続的な記憶装置を占めるように要求される。） 典型的にBuf バッファーとして勤めるバイトの配列だ。 ビットワイズ演算後にBuf バッファー全体を一つの大きい整数として扱え。 ビットワイズ演算後にStr 一般に失敗しないならStr 質問の容器で、アブストラクトを提供しろBuf どうにかして相互に作用しろ。 そうするための自動型変換Buf 一般にそうするべきである無効にするStr 相互に作用しろ。 一般的なロールとしてBuf 何としてでもインスタンスを作られるかもしれなのbuf8buf16あるいはbuf32 （あるいは何としてでも適切な（人たち・もの）を提供する型Buf インタフェース）、しかし、バッファーを作成するために使われるときBuf そうであるクラスを実装することにしゃれを言うbuf8 （実際にBuf[uint8]）.

同じじゃないStr 型、Buf 型は整数で弦つきのポジションを配って、そしてインデックスとして原因となっているぎっしり詰まった配列に直接これらをマップすることをより好む。 すなわち、これらは必ずしもバイトポジションじゃない － 整数位置がただ基礎をなしているポジションの数の上に重要である、そしてそこで1つのポジションが基礎をなしている整数型の1つのセルを意味する。 上に組込み文字列演算Buf 型が整数を返して、そして、ポジションを扱うとき、整数を期待する。 制限する訴訟として、buf8 ただ旧式のバイトストリングだ、そしてポジションはバイトポジションだ。 けれども、注意しろ、あなたが項の図を作り直すそのもしbuf32 記憶装置がそうだbuf8あなたあなたのすべてのポジションに4を掛けなければならないだろう.

これらのネイティブの型は上に確定ベースであるBuf それが構成されているネイティブの整数型までにパラメータ化されたロール：

Name        Is really
====        =========
buf1        Buf[bit]
buf8        Buf[uint8]
buf16       Buf[uint16]
buf32       Buf[uint32]
buf64       Buf[uint64]
 

ビルトインとして提供された符号付き buf 型がない、しかしあなたは言ってもよい

Buf[int8]
Buf[int16]
Buf[int32]
Buf[int64]
 

符号付き整数のバッファーを得るために。 それは同じく定義することが可能であるBuf 非整数に基づいて、あるいはネイティブでない型に：

Buf[complex64]
Buf[FatRat]
Buf[Int]
 

しかしながら、記憶装置隣接性のどんな保証もネイティブでない型のためにされることができない。

utf8 型が得られるからbuf8付加的でそれがただ理にかなって含んでいるかもしれない束縛が UTF-8 をコード化した。 同じく、utf16 得られるからbuf16そしてutf32 からbuf32.

これらが型だから、名前、括弧が常に、リスト演算書式ではないが強制型変換を考慮に入れたときから、強制するものとしてそれらを呼び出すために使われなくちゃならないことに注意を払え。 すなわち、：

utf8 op $x
 

常に解析されるけれども

(utf8) op $x
 

そして決してけれども

utf8(op $x)
 

* 項キャプチャ、「Whatever」の概念、どちらかの意味がそれが何に引数であるとしてもいい加減に決定されることができる独立型としての文字。 交互に、単項のそれらとそうしない2進法の演算子のために扱うべき世話* （彼・それ）ら自身、それは1つあるいは2つの引数をとるクロージャの中にコンパイル時間に自動的にカリー化されている。 （下を見ろ。）

演算子が、一般に、いつを扱うか* それ自身、それはしばしばその引数ポジションであなたにそれがそうすることができるすべてを与える「グロブ」と考えられることができる。 例えば、ここにそうすることに決める演算子が扱う若干数がある* そしてそれに特別な意味を与えろ：

if $x ~~ 1..* {...}                 # if 1 <= $x <= +Inf
my ($a,$b,$c) = "foo" xx *;         # an arbitrary long list of "foo"
if /foo/ ff * {...}                 # a latching flipflop
@slice = @x[*;0;*];                 # all indexes for 1st and 3rd dimensions
@slice = %x{*;'foo'};               # all keys in domain of 1st dimension
@array[*]                           # list of all values, unlike @array[]
(*, *, $x) = (1, 2, 3);             # skip first two elements
                                    # (same as lvalue "undef" in Perl 5)
 

Whatever オブジェクトが生じた未定義の原型だAny. 　型としてそれは抽象的であって、そして定義されたオブジェクトとしてインスタンスを作られないかもしれない。 特定の MMD ディスパッチのために使われるとき、そしてそうするそれ、それが急送する MMD システムクレームの何もけれどもAny 未定義の値で、そして（我々希望）は建設的に立腹する。

それ以来Whatever オブジェクトは効果的に不変だ、オプティマイザは認知することが自由だ* そして存在がそれがである何の演算子にパスしたかのコンテキストで最適化しろ。 それが扱うことを望む演算子が宣言することができる* あるいは、型の引数を持っているその候補者の少なくとも1人のためにその引数の1つ以上を申告することによってWhateverあるいは、トレイトで、 proto sub に記録を残すことによってis like-Whatever-and-stuff. 　［推測：実際に、これは我々がそれを短くするかもしれない交渉可能な － だis like(Whatever) あるいは何かそのようなもの。 :-)］

単項の何もあるいは、もし演算子が特にではなく要請したなら扱うべきバイナリ演算子（特に、何でも演算子を前接続して、後接続して、そして挿入する）のために* それ自身、コンパイラはコンパイル時間に適切にカリー化されたクロージャに直接翻訳するように要求される。 組込み数値演算子の大部分が、それほど、このカテゴリに分類される：

* - 1
'.' x *
* + *
 

1つのクロージャの中に内部的にカリー化されているあるいは2つの引数：

{ $^x - 1 }
{ '.' x $^y }
{ $^x + $^y }
 

変数がそれらレキシカルスコープで調べられる、そして宣言詞の後にレキシカルスコープ、結果でそれの中にどんな変数でもインストールした後、このリライトは起きる

* + (state $s = 0)
 

効果的にカリー化された中に :

-> $x { $x + (state $OUTER::s = 0) }
 

よりむしろ :

-> $x { $x + (state $s = 0) }
 

言い換えれば、* カリー化することは有用なレキシカルスコープを作らない。 （それが走るとき、それがダイナミックスコープを持っているけれども） これは扱うべき劇的に問題の演算子が突然決定するかどうかに変化を与えることからの意味規則を防ぐWhatever それ自身。

接尾辞演算子、メソッドとして呼び出しは自動的にカリー化されているそれらの演算子の1つだ。 何かが好む：

*.meth(1,2,3)
 

書き直されるけれども :

{ $^x.meth(1,2,3) }
 

メソッドをカリー化することに加えて、インボカントがない呼び出し、このようなカリー化されたメソッドはどこでも有用だ、 smartmatcher が期待される：

@primes = grep *.prime, 2..*;
subset Duck where *.^can('quack');
when !*.defined {...}
 

これらの返送されたクロージャは型の（こと・もの）だWhateverCode:($) あるいはWhateverCode:($,$) 型よりむしろWhateverする構造がそうすることを望むように扱え* あるいはその派生的なクロージャは型までにそれらを区別することができる：

@array[*]    # subscript is type Whatever, returns all elements
@array[*-1]  # subscript is type WhateverCode:($), returns last element

0, 1, *+1 ... *  # counting
0, 1, *+* ... *  # fibonacci
 

何のためにでも接頭辞、接尾辞、あるいは通り過ぎてカリー化されるであろうインフィックス演算子Whatever, a WhateverCode 同じくそれを自動カリー化する、このようなそれほど何も的な名詞句が上に基礎を置かれる* 名詞がそれに関しては過渡的に外へ自動カリー化する頭が外へメタ演算子を通して含めて、意味をなすように。 従って：

* + 2 + 3   # { $^x + 2 + 3 }
* + 2 + *   # { $^x + 2 + $^y }
* + * + *   # { $^x + $^y + $^z }
(-*.abs)i   # { (-$^x.abs)i }
@a «+» *    # { @a «+» $^x }
 

これはそうじゃない演算子のためだけだWhatever－ 気付いている。 そこ（に・で）要件がそれであるWhatever－ 気付いている演算子復帰WhateverCode いつWhatever 引数として使用される；それは本質的な「globbish」の意味を賛成であるようにしない関数のためにただ典型的な振る舞いに過ぎない*. 　もしあなたがこれらの globbish 演算子の1つをカリー化することを望むなら、あなたは明示的なクロージャを書く必要があるだろう、あるいは一緒演算子の上に明示的なカレーをしろ.assuming(). 　このクラスでの演算子、そんなものけれどもinfix:<..> そしてinfix:<xx>典型的に型の引数を自動カリー化するWhateverCode それらが自（己・動）カレーではなくするけれどもWhateverそれで我々はそうした：

"foo" xx *          # infinite supply of "foo"
"foo" xx *-1        # { "foo" xx $^a - 1 }
0 .. *              # half the real number line
0 .. * - 1          # { 0 .. $^a - 1 }
* - 3 .. * - 1      # { $^a - 3 .. $^b - 1 }
 

（もし最後の人が添え字として使われるなら、添え字化するものは2つの引数があることに気付いて、そしてパスする、その次元は2度大きさだ。）

非クロージャの値を返すことが知られている演算子で* 次のものを含む：

0 .. *      # means 0 .. Inf
0 ... *     # means 0 ... Inf
'a' xx *    # means 'a' xx Inf
1,*         # means 1,*  :)

$a = *      # just assigns Whatever
$a ~~ *     # just matches Whatever
 

2が同じく自動カリー化しないその最後を注意しろWhateverCodeプリミティブの基礎となることに対して、割り当てとスマートマッチが本当に標準の2進法の演算子、しかし構文的な構文糖じゃないから。 （このような擬似演算子は同じくそれらに対してメタ演算子が取り組む制約事項を与えるかもしれない。）

また、列演算子をするな&infix:<...> そして&infix:<...^> 自（己・動）カレーWhateverCode我々が WhateverCode クロージャを許すことを望むから、ストッパーとして：

0 ...^ *>5  # means 0, 1, 2, 3, 4, 5
 

［推測：それは可能な、付く上の演算子の大部分のためのそれだ* 平均にInf我々まだ実際にそれがあの特定の引数を支払不能とするクロージャを返すことができるInf. 　しかしながら、これは、クロージャがクロージャを含んでいるリストを返した場合に備えて、ただもし我々がそのリターン値あるいは値で、それが常に何でも呼び出すという意味で、クロージャを禁じる「値リストコンテキスト」にそれがそのリストで見いだして、そして取って代わるクロージャ、リストのクロージャ、を提供し、そして次にそれからの再走査がポイントする（まあテキストマクロのようにそうする）なら、うまくいくだろう. それで例えば、通り過ぎて返されたクロージャ0..* 補間挿入されるだろうRange 呼び出されるとき、リストへのオブジェクト。 代わる代わる、それは戻ることができた0それがするもう1つのクロージャによって後に続かれた1..*. 　さらに... 演算子が多分、我々が毎回最後のN値を覚えているいずれかの方法を理解する限り、それ自身をよみがえらせるクロージャについて項で再定義されることができた。］

何でも場合、インデックスがこのような「値リストコンテキスト」として行儀よく振る舞わなくちゃならない配列、があなたから数以外の何ものでも直接配列にインデックスを付けることができない。 配列の要素が添え字化される決勝戦@a[*-1]添え字化している演算が発見するとき、それを意味するCode:($) オブジェクトが添え字、それのためにそれを呼び出して、そして中に要素の数を示して引数を供給する（その次元の）配列. S09 を見ろ。

変形の* そうである** 型の（こと・もの）である項HyperWhatever. 　それは一般に理解される、から多ディメンション形式であれ* それが意味をなすとき。 向きを変えるであろう演算子によって修正されるとき、* 1つの引数の関数の中に、WhateverCode:($)** その代わりに1つの素晴らしい引数で関数に変わる、Code(*@)多数の引数がある程度の数の内部の whatevers に配られるように。 すなわち、：

* - 1    means                -> $x { $x - 1 }
** - 1   means   -> *@x { map -> $x { $x - 1 }, @x }
 

そのために@array[^**] 表す@array[{ map { ^* }, @_ }]すなわち、配列のすべての要素、いくつの次元かにかかわらず。 （しかしながら、@array[**] 同じことを意味するから（と同じように... 上に）、演算子が解釈するであろう添え字がそのままであるという状態で、** 意味は、次元の大きさのリストではなく、すべての添え字として。 意味のWhatever 常にそれが中にバインドされる最初のコンテキストによってコントロールされる。）

賛成の他の使用* そして** 長い間に疑いもなく（彼・それ）ら自身を提案するだろう。 これらはもしコンパイラじゃないなら、 MMD システムとしての意味を与えられることができる。 一般にWhatever 虚無主義的な「もう気にかけない － ただ私を撃て」としてではなく、その通りにやる方法で自由度を最大にするとして、解釈されるべきだ。

あなたがそれらをオブジェクトとして扱うとき、これらの型と一緒の値が（彼・それ）らの大文字対応者に自動的にボクシングをする：

bit         single native bit
int         native signed integer
uint        native unsigned integer (autoboxes to Int)
buf         native buffer (finite seq of native ints or uints, no Unicode)
rat         native rational
num         native floating point
complex     native complex number
bool        native boolean
 

ネイティブの型が、欠如で、 Perl の未定義の値のコンセプトを表すことができないときから時が NaN にインテジャタイプである間に明示的な初期化、ネイティブの浮動小数点の型デフォルトの（含むことbit）0へのデフォルト. 型が NaN ＋ NaN \iにデフォルト設定する複素数。 周知の大きさの buf 型が0の値の列をデフォルトとする。 もしネイティブの型が明示的に初期化される何も* （Whatever 型）、初期化はなし試みられるそして、記憶装置が割り当てられたとき、あなたはすでにそこ（に・で）であったものは何でも得るだろう.

もし buf 型が初期化されるなら、 Unicode 文字列値で、文字列は Unicode 符号位置と整数要素の中に押しやられたそれぞれの符号位置の中に腐敗している。 もし buf 型ではないのサイズが指定したなら、それは初期化している文字列からその長さをとる。 もしサイズが指定されるなら、初期化している文字列は取り除かれるか、あるいは必要に応じて 0で埋められている。 もし符号位置が buf の整数にフィットしないなら、もしこれがコンパイル時間に発見されることができるなら、型、解析錯誤が表示される；さもなければ警告がランタイムに表示される、そしてあふれ出られたバッファー要素は、同様、適切な置換文字で一杯だU+FFFD （置換文字）もし要素の整数型は少なくとも 16 ビットである、あるいはU+007f （デリートしろ）もしより大きいなら、値がフィットしないだろう。 もし他の翻訳がそうである何かが望んだなら、それは明示的に指定されなくちゃならない。 特に、 UTF-8 あるいは UTF - 16への翻訳が試みられない；それは明示的に指定されなくちゃならない。 （それが起きるように、 32 ビット整数に基づいた buf 型への翻訳がネイティブのエンディアンで正当な UTF - 32を産み出す。）

とりわけ、Mu それが名詞として使われるとき、それが「undef」の Perl 5 のコンセプトのために代理をするほど Perl 6 に、（http://en.wikipedia.org/wiki/MU 、特に「Mu - （ネガ） －」入力参照）「Mu」あるいは無の東のコンセプトの名にちなんで名を付けられる。 しかしながら、Mu それが Java のような言語で同じぐらい使われる「オブジェクト」のコンセプトのために代理をするように、同じく他のすべてがそ（れ・こ）から得られる「ゼロ」は未定義の型オブジェクトとしてうか。 あるいはそれを「マイクロ」あるいは他のすべてのオブジェクトのための基底、ミューオンのように原子何かであるμ - オブジェクトであると考えろ。 あるいはもし頭字語があなたを幸せにして、そこ（に・で）選ぶべき多様性であるなら：

Most Universal
More Undefined
Modern Undef
Master Union
Meta Ur
Mega Up
...
 

あるいはただそれを同時にすべて以外何も意味しない雌牛が立てる音であると考えろ。

Perl 6 は未定義を表している一つの値を持っていない。 その代わりに、種々の型のオブジェクトが、にもかかわらず（彼・それ）ら自身未定義に残っている間に、型情報を振る舞うことができる。 オブジェクトが定義されるかどうかが通り過ぎて決定されるかどうか.defined 真に戻るあるいはそうじゃない。 これらのタイプされたオブジェクトは典型的にイニシャライズされていない値を表す。 劣化オブジェクトが、例外情報を振る舞ったにもかかわらず、同じく公式に未定義だ；これらは使って作られるかもしれないfail 関数、あるいは例外の直接の構築までにいくらかのオブジェクトがソートする。 （失敗がどのように扱われるかについて、 S04 を見ろ。）

Mu          Most Undefined
Failure     Failure (lazy exceptions, thrown if not handled properly)
 

あなたが何でもあなたが自動的にとして知られている同一名で未定義のプロトタイプの値を宣言している型、クラス、モジュール、あるいは実装、について親切であると宣言するときはいつでも型オブジェクト。 名前“自身がその型オブジェクトを生む：

Mu          Perl 6 object (default block parameter type, Any, Junction, or Each)
Any         Perl 6 object (default routine parameter type, excludes junction)
Cool        Perl 6 Convenient OO Loopbacks
Whatever    Wildcard (like Any, but subject to do-what-I-mean via MMD)
Int         Any Int object
Widget      Any Widget object
 

オブジェクトが連結された空の括弧で（彼・それ）らの名前に文字列化する型。 型オブジェクトがクラスじゃない、しかし名前クラスに慣れているかもしれないことに注意を払え：

Widget.new()        # create a new Widget
 

いつでもFailure 値がタイプされたコンテナに入れられる、それはコンテナによって指定された型を雇うが、振る舞い続けるFailure ロール。 使用fail 特定の失敗を返すために。 使用Mu なぜなら最も一般的な非劣化の未定義の値。 Any 得られた型からMu同じく未定義だ、ただ除外するJunction そしてEach 自動的に通すことは標準の多数のディスパッチルールを使ってディスパッチされるように型。 ユーザー定義のクラスが生じるすべてAny デフォルトによってのクラス。 Whatever 型が得られるからAny けれども他の何もそれから得られない。

これらの型と一緒のオブジェクトが値のように振る舞う、すなわち。 $x === $y もしそれら型であるなら、真だそしてコンテンツが同一だ（それは存在する、もし$x.WHICH eqv $y.WHICH）.

Str         Perl string (finite sequence of Unicode characters)
Bit         Perl single bit (allows traits, aliasing, undefinedness, etc.)
Int         Perl integer (allows Inf/NaN, arbitrary precision, etc.)
Num         Perl number (approximate Real, generally via floating point)
Rat         Perl rational (exact Real, limited denominator)
FatRat      Perl rational (unlimited precision in both parts)
Complex     Perl complex number
Bool        Perl boolean
Exception   Perl exception
Block       Executable objects that have lexical scopes
Seq         A list of values (can be generated lazily)
Range       A pair of Ordered endpoints
Set         Unordered collection of values that allows no duplicates
Bag         Unordered collection of values that allows duplicates
Enum        An immutable Pair
EnumMap     A mapping of Enums with no duplicate keys
Signature   Function parameters (left-hand side of a binding)
Parcel      Arguments in a comma list
LoL         Arguments in a semicolon list
Capture     Function call arguments (right-hand side of a binding)
Blob        An undifferentiated mass of ints, an immutable Buf
Instant     A point on the continuous atomic timeline
Duration    The difference between two Instants
HardRoutine A routine that is committed to not changing
 

Set 値が落ち着いているかもしれないでset リスト演算あるいはメソッド。 Bag 値が落ち着いているかもしれないでbag リスト演算あるいはメソッド。

InstantsそしてDurationsは分数で原子秒後で慎重だ。 観念的にそれらが何ででも実装されるかもしれない実数値だReal なるべく、十分な精度の型Rat あるいはFatRat. 　（利用可能な subsecond 精度について固定点仮定をする実装は落胆している；ユーザインタフェースはいずれにしても実数値のように作用しなくちゃならない。） つくインタフェースDuration スリープ () のような、引数が同じく付くかもしれないReal 引数、ただInstant 引数が明示的に種々の文化的に気付いている時間スペック API の何もとしてであるように創造されなくちゃならない。 少数のInstant 共通時代の緊急の値を表す値は同じく利用可能だ。

数のコンテキストでDuration 楽しく戻るRat あるいはFatRat 秒ごとの番号を表す。 Instant 値は、他方、主として不透明であって、数値的に言って、そして特に不可知論で時代だ。 （Any 時代はただ詳細に過ぎないInstantそしてその時代と関係がある時が本当にそうであるすべてInstant ±Duration戻る新しいInstant.） 順に文化的に気付いている時間モジュールを書くことを促進するために、Instant 型が供給するInstant UTC がそれについて考える（とき・から・につれて・ように）、1958年の TAI 時代、 POSIX 時代、 Mac 時代と多分西暦2000年時代のような、種々のよく使われる時代に対応している値。 原子秒ごとに申し分がない有用な時代が特徴づけた何も除外する理由がない。 標準時間が付加と減法を使ったそれらの時代瞬間から計算され得るすべてDuration 値。 それに注意するDuration 値が；特に、まだただ原子時何なしででも文化的な変形であるDuration 形成して、引き算をすることによって、Instant::Epoch::POSIX 現在の瞬間から最新の POSIX より多くの秒を含んでいるだろうtime() POSIX のうるう秒のひどく悪い無知のために。 このではない、（相対論的な考慮事項を無視している）ではないがだました領域の過失。 InstantsそしてDurationsは常に長さの原子秒ごとだ。 文化的な時間と原子時間の間に interconvert に誘われるとき、公式に、 POSIX システムのような、堅実な時間基準を提供することができないシステムがただ正しい原子時について（彼・それ）らの最も良い推測をしなければならないだろう。 代わる代わる、それらが何か他のさらに少なく公式の時間機構を着実な時計振る舞いを達成するために使うかもしれない。 たとえ POSIX 時間型が困惑するとしても、たいていの Unix システムが時間刻みを数えることができる。

概念的な型であるけれどものInstant 似ているFatRatいずれかの分子あるいは分母で独断的に大きいサイズで、内部形式はもちろん「近くの」時間内部的に最適化されるかもしれない、それで、もし我々が整数として年を知っているなら、年以内の瞬間はただそうであり得るRat 年頭から差し引き計算値を表す。 同じ年に含まれる計算がそれから破滅させられることができるRat よりむしろFatRatあるいは差し引き計算が、（これまでのところ）誰もわずかなうるう秒を提案する勇気がなかったから、2年の間に整数瞬間相違を見いだすことができる毎年のテーブル。 あるいは何でも。 Instant 我々がユーザーに見える結果なしで実装入出力を交換することができるように、不透明だ。

項now 現在時刻を返すけれどもInstant.と同じようにrand そしてself 項、それは関数じゃない、それでそれの後に括弧を置くな。 それは同じく決して引数を探さない、それで次のトークンは演算子あるいはターミネータであるべきだ。

now + 300   # the instant five minutes from now
 

瞬間と所要時間の合計が常に瞬間であるように、基本的な数学演算がインスタントと duration のために定義される、他方2つのインスタントの相違は常に所要時間だ。 インスタントの上の数学がただ duration （あるいは同じぐらい上記の duration と思われるであろう数）でされるかもしれない；あなたは2つの瞬間を加えてはならない。

$instant + $instant      # WRONG
$instant - $instant      # ok, returns a duration
$instant + $duration     # ok, returns an instant
 

duration の上の数の演算が戻るDuration それが意味をなすところ（付加、減法、法）。 他の算術演算のために返された型は特定されていない；それらが標準の数の型を返すかもしれない、あるいはそれらが次元の分析を支援しようと試みる他の次元の型を返すかもしれない。 （我々がそれが反対して平均的プログラマに影響を与えない、そしてそれが緩やかなタイプ入力のコンセプトでうまくプレーすることを明示することができるまで、後のアプローチは今のところ多分明示宣言を必要とするべきだ。）

Blob 型は不変のバッファーのようであって、そして従って共に配列と（いくらか）筋が多い演算に返答する。 それに注意して、好むBuf、そサイズ常にバイトであるとは限らないベースユニットが何であるとしてもそれで測られる。 もしあなたがそうしたならmy Blob[bit] $blobそれから$blob.elems その中にビットの数を返す。 バッファーと同じように、種々のネイティブの型が自動的にネイティブの符号のない int 型から得られる：

blob1       Blob[bit], a bit string
blob2       Blob[uint2], a DNA sequence?
blob3       Blob[uint[3]], an octal string
blob4       Blob[uint4], a hex string
blob8       Blob[uint8], a byte string
blob16      Blob[uint16]
blob32      Blob[uint32]
blob64      Blob[uint64]
 

これらの型は（少なくとも）次のロールをする：

Class       Roles
=====       =====
Str         Stringy
Bit         Numeric Boolean Integral
Int         Numeric Integral
Num         Numeric Real
Rat         Numeric Real Rational
FatRat      Numeric Real Rational
Complex     Numeric
Bool        Boolean
Exception   Failure
Block       Callable
Seq         Iterable
Range       Iterable
Set         Associative[Bool] Iterable
Bag         Associative[UInt] Iterable
Enum        Associative
EnumMap     Associative Positional Iterable
Signature   
Parcel      Positional
Capture     Positional Associative
Blob        Stringy Positional
Instant     Real
Duration    Real
HardRoutine Routine
 

［推測しろ：Stringy 両方ともである場合は、最も良く2つのロールに分かれているかもしれないStr そしてBlob いっそう一般的な、そして公正な（の・もの・人）を構成しろStr それほど一般的じゃない（の・もの・人）を構成する。 それらのいっそう一般的な（人たち・もの）は共通をそうなことに適用するだろう、から密度が高い何でも（「文字列」）それを順序立てて並べるStr そしてBlob 両方ともは連接のように（文字のいずれかあるいはビットあるいは整数など）と文字列演算子である（~）そして複製（xxx）いっそう一般的なロールの一部だろう. ロールが申し込むであろういっそう特定の（人たち・もの）Str しかしそうじゃないBlob そしてビットあるいは整数などに文字に特殊であって、そしてそうしない特定の演算子が応用する何でも含む。 他の代替物はいっそう明らかに、もって、ビット文字列から文字文字列を遠ざけることだ~文字文字列のみのための / などとビット文字列のために類比を加えること。］

Iterable ロールがあなたが直接型を反復することができるとはではなく示す、けれどもあなたが型にイテレータを返すように要請することができること。 Iterable 型が多数のイテレータ（リスト）が同時にそれらを偶然見つけているようにするかもしれない、しかしイテレータ / リスト自身が消費のたった1つのスレッドを持っている。 あなたがする毎回get イテレータに、値がそのリストから姿を消す。

それに注意しろSet そしてBag イテレータがただ、値ではなく、キーだけを返す。 あなたは明示的にc <.pairs>をキー / 値対を得るために使わなくちゃならない。

これらの型と一緒のオブジェクトが互いに素を持っている.WHICH たとえオブジェクトがコンテンツであるとしても、変化しない値が変化する。 （それらが決まった場所で巻き得るから、 Routine は変更可能であると見なされる。）

Iterator    Perl list
SeqIter     Iterator over a Seq
RangeIter   Iterator over a Range
Scalar      Perl scalar
Array       Perl array
Hash        Perl hash
KeySet      KeyHash of Bool (does Set in list/array context)
KeyBag      KeyHash of UInt (does Bag in list/array context)
Pair        A single key-to-value association
PairSeq     A Seq of Pairs
Buf         Perl buffer (array of integers with some stringy features)
IO          Perl filehandle
Routine     Base class for all wrappable executable objects
Sub         Perl subroutine
Method      Perl method
Submethod   Perl subroutine acting like a method
Macro       Perl compile-time subroutine
Regex       Perl pattern
Match       Perl match, usually produced by applying a pattern
Stash       A symbol table hash (package, module, class, lexpad, etc)
SoftRoutine A routine that is committed to staying mutable
 

KeyHash ロールが標準とは違うAssociative それがデフォルト値を扱う方法でのハッシュ。 もし値であるならのKeyHash 賛成のデフォルト値への要素設定されているKeyHash要素削除される. もし、デフォルトデフォルトが賛成であるという状態で、宣言されていないならKeyHash 数字型のために0だ、False ブールの型と空の文字列の間文字列とバッファー型のために。 AKeyHash オブジェクトについて型がその型の間未定義の原型をデフォルトとする。 いっそう一般には、デフォルトデフォルトは値を定義したものは何もであるNil 変換するだろうからその値型のために。 AKeyHash のScalar 0あるいは空の文字列に行く要素をデリートする。 AKeyHash 同じく標準の未定義の値のための自（己・動）削除のキー（それは、スローされない例外を含んでいないそれらの未定義の値だ）。

AKeySet そうであるKeyHash デフォルトと一緒のブール値のFalse. 　もしあなたが使うならHash 要素をインタフェースして、そして増加させのKeySet その値は真になる（もしそれがすでに存在しないなら要素を作っている）。 もしあなたが要素を減少させるなら、それは偽になって、そして自動的に削除される。 存在しない値を減少させることは中に結果として生じるFalse 値。 存在する値がもたらす増加することTrue. 　使用されないときHash （すなわち、使用されるときArray あるいはリストあるいはSet オブジェクト）KeySet 振る舞う as a Set そのキーについて。 （唯一の可能な値からのKeySet そうであるTrue 値、それはまったくビットで実際の実装で表される必要がない。）

AKeyBag そうであるKeyHash のUInt 0のデフォルトで。 もしあなたが使うならHash 要素をインタフェースして、そして増加させのKeyBag その値は1人（もしそれがすでに存在しないなら要素を作っている）によって増やされる。 もしあなた値がそうである要素が1だけ減少させたデクリメント；もし値が0に行くなら、要素が自動的に削除されるなら。 存在しない値がもたらすデクリメントへの努力Failure 値。 使用されないとき、Hash （すなわち、使用されるときArray あるいはリストあるいはBag オブジェクト）KeyBag 振る舞う as a Bag そのキーについて、と複製されたそれぞれのキーで回数がその対応する値までに明示した。 （使用.kv あるいは.pairs リストコンテキストでこの振る舞いを隠すために。）

と同じようにHash 型、Pair そしてPairSeq それらの鍵でではなく、それら値で変更可能だ。 （キーが変更可能なオブジェクトに参照であり得る、しかし変化することができないそ.WHICH 識別情報。 それと対照的に、ハッシュ要素がそうするかもしれないのとちょうど同じように、値は異なったオブジェクトに再境界であるかもしれない。）

次のロールはサポートされる：

Iterator    List
Scalar      
Array       Positional Iterable
Hash        Associative
KeySet      KeyHash[Bool]
KeyBag      KeyHash[UInt]
KeyHash     Associative
Pair        Associative
PairSeq     Associative Postional Iterable
Buf         Stringy
IO          
Routine     Callable
Sub         Callable
Method      Callable
Submethod   Callable
Macro       Callable
Regex       Callable
Match       Positional Associative
Stash       Associative
SoftRoutine Routine
 

する型List 繰返しがイテレータのに明示的な呼び出しまでによりむしろ典型的にコンテキストによって引き起こされるから、ロールは一般に、カジュアルなビューから隠れている.get メソッド。 ファイルハンドルは顕著な例外だ。

S06 でソフト対難しい定常課程の解説のために「包装」を見ろ。

明示的な型はオプションだ。 Perl 変数が2つの関連づけられた型を持っている：「型の」それらとそれら「コンテナ型」。 （いっそう一般に、どんなコンテナでも、サブルーチンとモジュールを含めて、コンテナ型を持っている。） of 型が記憶されるけれどもそof プロパティはコンテナのコンテナ型である間にそれ自身ただコンテナのオブジェクト型に過ぎない。 言葉returns 賛成でエイリアスとして許されるof.

of 型がどんな種類の値が変数で記憶されるかもしれないか明示する。 of 型が接頭辞として与えられるあるいはでof キーワード：

my Dog $spot;
my $spot of Dog;
 

どちらの場合もこれは凝固するof そうするためのコンテナのプロパティDog.

型のon 配列あるいはハッシュがそれぞれの要素によって記憶された型を指定する：

my Dog @pound;  # each element of the array stores a Dog

my Rat %ship;   # the value of each entry stores a Rat
 

ハッシュの重要な型はシェイプトレイトとして明示されるかもしれない － S09 を見ろ。

コンテナが、沈むことについて、型の安全を実施するのに対して、サブルーチンがリターンで型の安全を強いる。 returns 宣言エイリアスが賛成であるof サブルーチンの型。

sub get_pet() of Animal {...}       # of type, obviously
sub get_pet() returns Animal {...}  # of type
our Animal sub get_pet() {...}      # of type
 

あなたの帰りの値を強制するために、自動型変換型を使え：

sub get_pet() returns Pet(Animal) {...}  # coerce any Animal to Pet
 

コンテナのために、しかしながら、自動型変換型の使用 as the of 沈むや否や戻ることよりむしろ値を強制する。

コンテナ型は変数がどのようにそれ自身実装されるか明示する。 それは変数のトレイトとして与えられる：

my $spot is Scalar;             # this is the default
my $spot is PersistentScalar;
my $spot is DataBase;
 

コンテナ型を定義することは、 Perl 5 で変数をタイすることに、 Perl 6 同等物だ。 けれども Perl 6 変数が宣言時間に直接タイされる、そして性能で理由が実行時でタイされないかもしれないtie 変数がそれがするコンテナ型で明示的に宣言されない限り文Tieable ロール。

しかしながら、変数がそうである実装が常に見なしたTieable デフォルトまでに。 結果として、すべての名前付きパッケージは同じくだTieable デフォルトまでに。 異なってパッケージをタイしたように、クラスとモジュールが見られるかもしれない。 他の方向、クラスとバインドされることを望むモジュールからパッケージ名がすることができなければならないグローバルまでそれを見るPackage ロール。

A　スカラーでない型はその要素のそれぞれが何の値の型を記憶するか明示するために資格を持っていて、順調であるかもしれない：

my Egg $cup;                       # the value is an Egg
my Egg @carton;                    # each elem is an Egg
my Array of Egg @box;              # each elem is an array of Eggs
my Array of Array of Egg @crate;   # each elem is an array of arrays of Eggs
my Hash of Array of Recipe %book;  # each value is a hash of arrays of Recipes
 

連続したそれぞれof 左に右に型を型の仮引数にする。 パラメータを伴う型が、それほど：正方形の括弧を使って名指される

my Hash of Array of Recipe %book;
 

実際は手段：

my Hash:of(Array:of(Recipe)) %book;
 

実際の変数が、複雑であるとき、見つけにくくあり得るから、型が指定される、同様に接尾辞フォームがある：

my Hash of Array of Recipe %book;           # HoHoAoRecipe
my %book of Hash of Array of Recipe;        # same thing
 

as フォームがサブルーチンで使われるかもしれない：

my sub get_book ($key) as Hash of Array of Recipe {...}
 

代わる代わる、帰りの型はシグネチャーの中で指定されるかもしれない：

my sub get_book ($key --> Hash of Array of Recipe) {...}
 

わずかな相違、型推測するものがそうするであろう限りにおいて無視があるas けれども注意を払え--> あるいは同じく知られている接頭辞型宣言 as the of 型。 ただサブルーチンの内側だけが注意にそうするよう金を払うasそして本質的に強制型変換、返値、から、ただあなたがそれぞれの帰りの展開式を強制したかのように、示された人たちはタイプする。

あなたは同じく指定するかもしれないof 型 as the of トレイト（でreturns 同義語として許された） :

my Hash of Array of Recipe sub get_book ($key) {...}
my sub get_book ($key) of Hash of Array of Recipe {...}
my sub get_book ($key) returns Hash of Array of Recipe {...}
 

どこでも、もしそれがそうであったなら、あなたはあなたが便利さのために明記できる型のセットを使用することができる一つの型を使うことができる "or" ジャンクション：

my Int|Str $error = $val;              # can assign if $val~~Int or $val~~Str
 

もっとおしゃれな型拘束知識が部分型を通して表明されるかもしれない：

subset Shinola of Any where {.does(DessertWax) and .does(FloorTopping)};
if $shimmer ~~ Shinola {...}  # $shimmer must do both interfaces
 

仮引数での項が暗黙的にである1セットの拘束知識だと見なされることができたときから時が一緒に「anded される」（変数はそれ自身型拘束知識を供給する、そしてwhere マッチしている条項あるいはツリーがただもっと多くの拘束知識を加える）、我々振る舞うべき型の並列を許すためにこれを緩める "and" ジャンクション：

# Anything assigned to the variable $mitsy must conform
# to the type Fish and either the Squirrel or Dog type...
my Squirrel|Dog Fish $mitsy = new Fish but { Bool.pick ?? .does Squirrel
                                                       !! .does Dog };
 

［注意しろ：我々が少しもっと良く MMD を理解するまで、パラメータが正式の変数に対してただ一つの主な型だけを感じていることに、6.0.0で現在限定されている限りにおいて、上の（人たち・もの）はわずかな嘘だ。］

パラメータがただ他のいかなる変数のようにでも、型を与えられるかもしれない：

sub max (int @array is rw) {...}
sub max (@array of int is rw) {...}
 

宣言の中で、（自力あるいは存在する型名の後への）クラス変数が書き下ろし型名を宣言して、そして実際のそれがそれと結び付けられる仮引数の型からそのパラメータを伴う値をとる。 それは関連づけられた宣言と同じ範囲の新しい型名を宣言する。

sub max (Num ::X @array) {
    push @array, X.new();
}
 

新しい型名はすぐに開始される、それでシグネチャーが、もしそれらであるなら調和して統一しなくちゃならない同じことでの2つのこのような型は同一名を持っている：

sub compare (Any ::T $x, T $y) {
    return $x eqv $y;
}
 

スコープ宣言されたサブルーチンで、リターン型が名前の前か後に指定されることができる。 我々呼び出しはすべて型「リターン型」を返すが、2種類の戻り型を区別する、as type そして the of 型、からof 型が通常型という名前の「当局者」であって、そして、間、ルーチンへの公式のインタフェースを宣言するas 何がルーチンの見地からルーチンによって返されるかもしれないかについて、型はただ束縛に過ぎない。

our sub lay as Egg {...}            # as type
our Egg sub lay {...}               # of type
our sub lay of Egg {...}            # of type
our sub lay (--> Egg) {...}         # of type

my sub hat as Rabbit {...}          # as type
my Rabbit sub hat {...}             # of type
my sub hat of Rabbit {...}          # of type
my sub hat (--> Rabbit) {...}       # of type
 

もし明示的にスコープ宣言されたサブルーチンではないが、それはデフォルトとするならmy 有効範囲規則。 Any リターン型が名前：を追わなくちゃならない

sub lay as Egg {...}                # as type
sub lay of Egg {...}                # of type
sub lay (--> Egg) {...}             # of type
 

匿名のサブルーチンで、戻型がそうすることができる何でもただ後で行くsub キーワード：

$lay = sub as Egg {...};            # as type
$lay = sub of Egg {...};            # of type
$lay = sub (--> Egg) {...};         # of type
 

けれどもあなたは使うことができるanon 開始するべき宣言詞をスコープ宣言するof 型を前接続しろ：

$lay = anon Egg sub {...};            # of type
$hat = anon Rabbit sub {...};         # of type
 

帰りの型は同じく後で指定されるかもしれない--> シグネチャーの中のトークン。 これはまったく同じことを意味しないけれどもas.of 型は「公式の」帰りの型であって、そして従って sub の外（に・で）型推論をするために使われるかもしれない。 as 型がただそれほど sub の内部に向かう準備が整っているリターン型をそれにするreturn 文がそのコンテキストを知ることができる、しかし sub の外（に・で）我々は、ない場合返却として、帰りの値について何も知らない、型が（すでに）宣言されていた。 前置形式は指定するof どちらかと言えば型よりas 型、それで帰りの型の

my Fish sub wanda ($x) { ... }
 

型魚のオブジェクトを返すことが知られている、あなたが言ったかのように：

my sub wanda ($x --> Fish) { ... }
 

あなたが言ったかのようにではなく

my sub wanda ($x) as Fish { ... }
 

それは賛成で可能であるof 一緒に不一致であるべき型as 型：

my Squid sub wanda ($x) as Fish { ... }
 

あるいは等しく、

my sub wanda ($x --> Squid) as Fish { ... }
 

あなた自身に横たわっているこのではない － それは世界に横たわっている。 異なった内部の型を持つことは、もしあなたが例えば外の世界にあなたのルーチンをあなたが漏らしたより厳しいスタンダードに保つことを望むなら、有用だ。

Cool 型が得られるからAnyそして部分一致そうなすべてのメソッドが「冷たい」（同じぐらい中に、「私はその型の引数で冷静だ。」.）.

もっと特定すると、これらは、典型的なユーザが問題のメソッドを理解する特定の組込み型に翻訳を暗示するためにメソッドの名前を期待するであろう限りにおいて、文化的に普遍的なメソッドだ。 例えば、$x.abs 適切な数の型もしに翻訳を暗示する$x 「冷たい」、しかしすでにその名前のメソッドをサポートしない。 逆に、$x.substr 文字列あるいはバッファー型に翻訳を暗示する。

Cool モジュールが同じく最後の手段のすべての多潜水艦を含んでいる；もし標準の多数のディスパッチが実行可能な対象を見いださないなら、これらは自動的に検索される。 それに注意するCool 実装は変更可能だ、そして共に一つの、そして多数のディスパッチが実行時猿パッチングの目的でそこ（に・で）変更を考慮に入れなくちゃならない。 しかしながら、多数のディスパッチャの使用からCool ただフェイルオーバとしてパッケージしろ、このようなディスパッチのコンパイル時分析は正確か、あるいは近いマッチでどんな引数のためにでも主として影響されない。 同じくどんなシングルでもそれが（それより）いっそう特定のメソッドを急送するCool 変わりやすさに罹っているではないを分類しろCool. 　クラスが生じないユーザー定義のCool デフォルトまでに、このようなクラスが同じく変化に影響されないようにそうするためにCool.

$Package'var 構文はなくなっている。 使用$Package::var その代わりに。 （注意する、しかしながら、識別子が、もしマッチしている文字によって後に続かれるなら今単一引用符あるいはハイフンを含んでいるかもしれないこと<.alpha>）

Perl 6 はシギルのシステムを含む、からマークは変数の基本的な構造的な型を含む：

$   scalar (object)
@   ordered array
%   unordered hash (associative array)
&   code/rule/token/regex
::  package/module/class/role/subset/enum/type/grammar
 

宣言、の中で& シギルが宣言の範囲の中でシギルなしで同じくサブルーチン名の視程を宣言する：

my &func := sub { say "Hi" };
func;   # calls &func
 

シグネチャーあるいは他の宣言、の中で:: 識別子によって後に続かれた擬似シギルが同じく実装 / 型の視程を宣言の範囲の中のシギルがない名前だと宣言する型変数に記録を残す。 最初のこのようなスコープの中の宣言は自由にされた型だと考えられる、そしてその関連づけられた引数の実際の型をとる。 次の宣言で同じ範囲で擬似シギルの使用は任意であって、そのままの型名から同じく宣言される。

もしそれが内部の宣言が型を再びしばるであろうときからの同じ型を意味することを望むなら、中でネストされた宣言がシギルを使ってはならない。 （pointy ブロックのシグネチャーが、外側ブロックではなく、内側ブロックの一部として扱われることに注意を払え。）

シギルが、境界オブジェクトの正確な型ではなく、全体的な接合点を示す。 異なったシギルが異なった最小の能力を暗示する。

$x どんなオブジェクトにでもバインドされるかもしれない、何でも含めて他のいかなるシギルにでもバインドされることができるオブジェクト。 オブジェクトが本質的に合成か、あるいは単一かどうかにかかわらず、このようなスカラー変数は常にリストコンテキストについて親切に何ででも単数形の商品として取り扱われる。 明示的に何らかの種類の間接参照コンテキストに置かれないなら、それはそのコンテンツに自動的にではなくデリファレンスを遺贈する。 特に、リストコンテキストの中に補間挿入されるとき、$x 一つの商品として決してオブジェクト以外の何ものも自身にそのオブジェクトを拡大しない、たとえオブジェクトがコンテナであるとしても多数の項目を含んでいるオブジェクト。

@x オブジェクトにバインドされるかもしれなのArray クラス、しかしそれは同じくそれがするどんなオブジェクトにでもバインドされるかもしれないPositional ロール、そんなもの as a SeqRangeBufParcelあるいはCapture.Positional ロールがサポートするべき能力を暗示するpostcircumfix:<[ ]>.

同じく、%x それがするどんなオブジェクトにでもバインドされるかもしれないAssociative ロール、そんなものけれどもPairPairSetSetBagKeyHashあるいはCapture.Associative ロールがサポートするべき能力を暗示するpostcircumfix:<{ }>.

&x それがするどんなオブジェクトにでもバインドされるかもしれないCallable 何ものような、ロールBlock あるいはRoutine.Callable ロールがサポートするべき能力を暗示するpostcircumfix:<( )>.

::x それがするどんなオブジェクトにでもバインドされるかもしれないAbstraction ロール、1パッケージ、モジュール、クラス、ロール、文法、あるいは何のようにでも型として使用されることができる他の型オブジェクト、あるいはどんな不変の値オブジェクトでも。 これAbstraction ロールが種々のシンボルテーブルそして／あるいは要約という条件のもとで何によってもサポートされるかもしれない、あるいはそうしないかもしれない類型学の扱いをする能力を暗示する。 主としてそれがただあなたが若干の要約に正称を与えることを望むことを意味するけれどもあなたがそれから後にコンパイルで何なしででもシギルを使うことができること。

何かで場合、ロールが暗示した最小のコンテナは遅くとも時バインディングにおいてシギルによってチェックであって、そして、もしセマンティックエラーがより早く検出されることができるなら、以前に（コンパイル時間にのように）故障するかもしれない。 もしあなたがまだ適切なロールをしないオブジェクトをバインドすることを望むなら、あなたはあるいはノーブランドをこつこつ続けなくちゃならない$ シギル、あるいはいっそう特定のシギルにバインディングの前に適切なロールを混ぜろ。

オブジェクトが両方ともをサポートすることを可能にされるPositional そしてAssociative. 　それがサポートしないオブジェクトPositional 直接そうすることに疑いがあるかもしれない@x. 　しかしながら、何でもそんなものを作成するけれども%x それは配列変数までの非常にリストへのオブジェクトのコンテンツを補間挿入することができるので、コンテキストが自動的にそれからバインドされるかもしれないリスト値を作成することができる。 このようなリストを添え字化することはオリジナルのオブジェクトの中に後部を添え字化することを暗示しない。

Perl 5 の場合と異なり、あなたはもう空白文字をシギルとその次の名前あるいは構造の間に置いてはならない。

普通のシギルが通常スコープ宣言された変数、語彙あるいはスコープ宣言された実装を示す。 奇妙にスコープ宣言された変数が変数がどんな種類の奇妙な有効範囲規則の適用を受けるかを示す第二のシギル（twigil）を含む：

$foo        ordinary scoping
$.foo       object attribute public accessor
$^foo       self-declared formal positional parameter
$:foo       self-declared formal named parameter
$*foo       dynamically overridable global variable
$?foo       compiler hint variable
$=foo       Pod variable
$<foo>      match variable, short for $/{'foo'}
$!foo       object attribute private storage
$~foo       the foo sublanguage seen by the parser at this lexical spot
 

twigils を持っているたいていの変数が暗黙のうちに宣言されるか、あるいは何か他の範囲に宣言されると考えられて、そしてそうしないそうする必要がある "my" あるいは "our" . 変数が一緒に宣言される属性hasけれども。

標準の名前と変数が範囲宣言詞を使うと宣言される：

my          # introduces lexically scoped names
our         # introduces package-scoped names
has         # introduces attribute names
anon        # introduces names that aren't to be stored anywhere
state       # introduces lexically scoped but persistent names
augment     # adds definitions to an existing name
supersede   # replaces definitions of an existing name
 

名前が同じく関数のシグネチャーに宣言されるかもしれない。 これらは同等であるそうすることmy 関数のブロック以内の宣言、そのこのようなパラメータデフォルト以外読み取り専用に。

anon 宣言詞が何の中にもエラーメッセージで使われ得る、しかし置かれない名前を提供する宣言にシンボルテーブルを許す：

my $secret = anon sub marine () {...}
$secret(42)  # too many arguments to sub marine
 

シギルは今不変だ。 $ 常にスカラ変数を意味する、@ 配列変数、そして% ハッシュ変数、添え字化しているいつさえ。 項目コンテキスト、変数でそんなものけれども@array そして%hash ただ（彼・それ）ら自身を返せArray そしてHash オブジェクト。 （商品コンテキストは以前にスカラーコンテキストとして知られていた、しかし、配列がリストコンテキストから切り離されると同じように、我々はコンテキストよりむしろ変数について話をすることに対して、今「スカラー」概念を留保する。）

文字列コンテキストで、オブジェクトが（分離された空白文字）文字列値を私物化するために自動的に文字列化するコンテナ。 数のコンテキストで、コンテナでの要素の数は返される。 ブールのコンテキスト、真の値で返されるもしそして何でもある場合に限りコンテナでの要素。

何の Perlish 表示のためにでも使用オブジェクトを手に入れること.perl メソッド。 Like the Data::Dumper Perl 5 、のモジュール.perl Perl が同じオブジェクトに戻っている結果を評価することができるように、メソッドが文字列の周りにクォートを、リスト値の周りに正方形の括弧、ハッシュ値、オブジェクトの周りのコンストラクタ、などの周りにカーリーを置くだろう。 .perl メソッドが前提条件に関してオブジェクトの表示をそれリターンするだろう、もしコード化がある時点で再び解析されるなら、それは商品コンテキストでスカラーとしてオブジェクトをよみがえらせるために使われるだろう。 もしあなたがリストコンテキストでよみがえらせられたオブジェクトを間にはさむことを望むなら、使うことは必要であるかもしれない<prefix:<| ＞ ＞ 補間を強制するために。

それに注意しろ.perl 非常に特定の定義を持つ、そしてそれはそれに予想されてモジュールがそれと一緒往復の値へ能力に頼るであろういくらかだeval. 　実際で、オーバーライドしている.perl 異なった構成で（世界的規模で使うMONKEY_TYPINGあるいは特別な処理がされない限り維持するべき特定クラスで解析性）賢明じゃない. 上に依存しないコード化.perl「鮮明度が使うべきであるs.pretty その代わりにもっと多くの管理を許すために。

.prettyそれと対照してで.perlオブジェクトの柔軟なフォームが人間の翻訳のために意図した復帰。 ユーザクラスがオーバーライドするよう奨励される詳細.pretty 適切な何かとそれをすることは猿パッチに完全に受容できる.pretty 手直しをしている間の、何でも破る危険がないメソッドがモジュールを使った。 .prettyメソッド、が受け入れて、そして認められない名指された引数；実装を無視するであろう何のようにでも.pretty 旗のセットを標準化するよう奨励される。

［若干の推測の提案：

:oneline        Do not indent or linebreak output
:width($d)      Wrap output at $d chars
:charset($obj)  Represent unrecognized characters as escapes
:ascii          Short for some instantiation of :charset
 

推測的に、.pretty クラスが再びディスパッチすることができたシステム - 確定の上にそうするために&*PRETTYPRINTER あるいはきれいなフォーマットを変えるいっそうしつけが良い方法を可能にして、若干の類似のシステム。

中間の文字列のために単純であるより豊かな構成を使うことは同じく望ましいかもしれないStr例えば知的なラインブレークを扱うことができるオブジェクト構成を使う。 しかしながら、それはおそらく過剰だ。］

何の書式つき表示のためにでも使用スカラ値を手に入れること.fmt('%03d') メソッドが暗黙をするsprintf 値に。

コンマによって分離されて配列値をフォーマットするために、2番目の引数を供給しろ：.fmt('%03d', ', '). 　ハッシュをフォーマットするために、値あるいはペアのリスト、最初の文字列でキーと値両方のためにフォーマットを含む：.fmt('%s: %s', "\n").

左にあったものは何によってでも今首尾一貫してコンテナが生産したデリファレンスを添え字化する。 空白文字ではないが変数名とその添え字の間に許した。 しかしながら、視覚的に構造を引き伸ばす2つの方法がある。 添え字が一種の接尾辞だから、演算子、それぞれの添え字の対応するドットフォームがある（@foo.[1] そして%bar.{'a'}）デリファレンスをもう少し明示的にする. 不変の文字列添え字が、それほど、角に置かれるかもしれない%bar.{'a'} 同じく書かれるかもしれないけれども%bar<a> あるいは%bar.<a>. 　さらに、あなたは unspace を使って余分の空白文字を差し込んでもよい。

Slicing は、シギルによってではなく、添え字の性質によって指定される。

添え字が評価されるコンテキストは同様もうシギルによってコントロールされない。 添え字が常にリストコンテキストで評価される。 （もっと特定すると、それらが存在する、あなたがセミコロンを使って多次元のスライスをすることができるように、次元の情報を保存する lol コンテキストとして知られているリストコンテキストの変形（リストのリスト）で評価する. しかしながら、それぞれのスライス次元が標準のリストコンテキストでその部分リストを評価する、それで、添え字の一部がそうしない（とき・から・につれて・ように）、呼び出された関数が lol コンテキストを見る。 薄く切ることについて、さらに多くのために S09 を見ろ。）

もしあなたが（スカラー）商品に内部のコンテキストを押しやる必要があるなら、我々は今数と~文字列のために ＋ のような便利なシングル - 文字コンテキスト規則子を持っている：

$x        =  g();       # item context for g()
@x[f()]   =  g();       # list context for f() and g()
@x[f()]   = +g();       # list context for f(), numeric item context for g()
@x[+f()]  =  g();       # numeric item context for f(), list context for g()

@x[f()]   =  @y[g()];   # list context for f() and g()
@x[f()]   = +@y[g()];   # list context for f() and g()
@x[+f()]  =  @y[g()];   # numeric item context for f(), list context for g()
@x[f()]   =  @y[+g()];  # list context for f(), numeric item context for g()

%x{~f()}  =  %y{g()};   # string item context for f(), list context for g()
%x{f()}   =  %y{~g()};  # list context for f(), string item context for g()
 

シギルが関数としてあるいは、これらが同じく働くように、リスト接頭辞演算子が同じくコンテキストを強制する（とき・から・につれて・ように）使った：

@x[$(g())]         # item context for g()
%x{$(g())}         # item context for g()
 

けれどもこれらが同じことをしないことに注意を払え：

@x[$g()]           # call function in $g
%x{$g()}           # call function in $g
 

リスト割り当てをリストバインディングから区別する必要性がある。 それのような多くが、値をコピーして Perl 5 でする割り当て仕事をリストしろ。 ある新しい:= それがあなたに名前をバインドさせるバインディング演算子Array そしてHash サブルーチン引数と同じ方法で、コピーしないでオブジェクトは仮パラメータに境界だ。 バインディングについてさらに多くのために S06 を見ろ。

1つのA級リストあるいはいっそうコンマによって分離されたオブジェクトが「括弧セル」の中に括弧によって集められるかもしれない、あるいはParcel. 　この種類のリストは平らになっているリストコンテキストと混同されるべきじゃない。 その代わりに、これはまだ平らになる責任を持たなかった生の構文的なリストだ；翻訳がそれが何のコンテキストで評価されるであろうか知らないで内部にリストから作られていない。 例えばあなたが言うとき：

(1,2,3,:mice<blind>)
 

結果はそうであるParcel オブジェクトが3を含んでいるInt objects そして a Pair オブジェクト、すなわち、4つの位置のオブジェクト。 しかしながら、あなたが何かを言うとき、好む：

rhyme(1,2,3,:mice<blind>)
 

構文的な（人たち・もの）Parcel （コンパイル時間に、この場合）翻訳される中にCapture バインディングの準備の引数という名前の3の positionals と1人と一緒のオブジェクト。 いっそう一般には、区画がそれが完全なシグネチャーにバインドされるどんな時でもキャプチャに transmuted される。

あなたは即刻の翻訳にそうすることを強いるかもしれないCapture 区画生成するものにバックスラッシュを前接続することによってのオブジェクト：

$args = \(1,2,3,:mice<blind>)
 

同じじゃないCapture オブジェクト、Parcel バインディングあるいは割り当てが常に区画を他の何かに変えるから、オブジェクトはユーザがほとんど決して1（人・つ）を実数独立型オブジェクトとして見ない限りにおいて、つかのまだ。 区画が一般にただ外の区画あるいはキャプチャオブジェクトの一部として保存されるかもしれない。

区画あるいはキャプチャ生成するものでの個別の引数が外の区画（あるいはキャプチャ）の中で引数（しばしば subparcel 、もしファンクションリターン多値）として配置されてそれぞれの関数の結果で関数が、すぐに、呼び出されると述べた普通の展開式と何とでも解析される。 何かが引数が平らにされるとすればその終局のバインディングの上に、そして一般に依存するであろうかどうかは区画 / キャプチャ合成時間に知られているはずがない。

我々は、もし位置か、あるいは名指された仮引数にバインドされるならここに一つの引数と思われるであろう何かを意味している「引数」を使う：

rhyme(1,2,3,:mice<blind>)     # rhyme has 4 arguments
rhyme((1,2),3,:mice<blind>)   # rhyme has 3 arguments
rhyme((1,2,3),:mice<blind>)   # rhyme has 2 arguments
rhyme((1,2),(3,:mice<blind>)) # rhyme has 2 arguments
rhyme((1,2,3,:mice<blind>))   # rhyme has 1 argument
 

これらの例、最初の引数で関数に区画はそれが簡単にである最初のケース以外のすべてでリテラルの整数1か。 引数がいずれかであるの :

• 部分リストを集める区画あるいは

• 一つの引数として関数を缶詰めにする Any の他のオブジェクト。

他の方法でそれを見て、実際に区画でラップされる必要がないすべての引数はバインディングの話になると（彼・それ）ら自身の権利で変化した区画だと見なされる。 キャプチャではないが見なした、一種の区画が、それほど平らなコンテキストで平らにならないことに注意を払え。

いつかParcel 仮引数にバインドされる、仮引数が「平らになっている」か、あるいは「引数的な」かどうかについて、振る舞いは依存する。 位置のパラメータとスライスパラメータは引数的である、そして呼び出しだ.getarg 内部のイテレータに、そしてただ平らにならないで次の構文的な引数（区画あるいは他のオブジェクト）を返せ。 （スライスが「素晴らしい」ことにおいて普通の定位置パラメタとは違う、すなわち、それは周囲のキャプチャの variadic 領域から多数の値を引き出すように意図される。 素晴らしいコンテキストが平らになって両方ともに来る（* パラメータ）そして薄く切る（** パラメータ）フォーム。）

仮引数がバインドされているという事実はシグネチャーにバインドされて外のキャプチャがあることを意味する。 キャプチャのイテレータは供給する.get そして.getarg メソッドがイテレータに中に何のコンテキストをバインドするべきか教える。 なぜなら位置の / がパラメータを切るから、.getarg メソッド Return 、イテレータからの全部の次の引数である、しかし transmutes に少しも外のParcel そうすることSeq オブジェクト；それは変化していない他のオブジェクトを返す。 パラメータが呼び出す平らなコントラストで.get 平らになるキャプチャのイテレータに、次の商品を引き抜く前に、何でも subparcels する。 どちらの場合も、そのままの区画オブジェクトが標準の境界引数として見られない。 （しかしながら、バックスラッシュを使っている原因となっている区画をバインドする方法がある。 これは内部の定常課程がどのように実数オブジェクトとして区画を取り扱うことができるかだ。）

パラメータバインディング、もしと対照してParcel シグネチャー全体に（典型的に関数あるいはメソッド呼び出しの一部として）バインドされる、それは最初に区画とほとんど同じようだが、その引数がより速いバインディングの間位置の、そして名指された下位グループの中に分割されるようにするキャプチャオブジェクトに変換されるだろう。 （通常この変換はコンパイル時間に起きる。） もし守備の最初がコンマの代わりにコロンによって後に続かれるなら、それが気にかけるコンテキストにそれ自身を見いだす場合に備えて、インボカントとして記録されている。 最初の引数の後に以外どこでもコンマの代わりにコロンを使うことは非合法だ。

宣言詞が暗黙のシグネチャー括弧を unparenthesizedなフォームの周りに置くということである明示的なバインディングから個別の変数がある形式のシグネチャーバインディングだと見なされる：

my (*@x) := foo(); # signature binding
my *@x := foo();   # same thing
 

もし1以上の仮引数があるなら、括弧は、もちろん、必要とされる。

Capture オブジェクトは抽象的に不変だが、いい加減にそれら引数を評価する。 すべての前に内部にCapture 完全に評価される（それはすべての引数が定数であるコンパイル時間において起きる）、終局の値未知であるであろう. 我々が知っているすべては我々がそれらとして不変のそれのかけらを知られているようにするという約束を持っているということだ。

Capture オブジェクトが送信のような多数の未解決のイテレータあるいは区画あるいは区画のリストを含んでいるかもしれない。 何かについて、これらが解決される方法が依存する、それらが最終的に境界であるそうすること. 他のものがそうじゃない間に、若干のバインディングが多数の次元に敏感だ。 リストのリストへのバインディングは、「薄く切る」として、しばしば知られている、なぜなら潜在的に多次元の配列の「スライス」にインデックスを付けることはよく使われるから。

あなたは部分を取り戻すかもしれないからCapture 接頭辞シギル演算子と一緒のオブジェクト：

$args = \3;     # same as "$args = \(3)"
@$args;         # same as "Array($args)"
%$args;         # same as "Hash($args)"
 

配列の中に投げ入れられるとき、あなたはすべての位置の引数にアクセスすることができる；すべて引数という名前のハッシュに打ち込んでいる。

すべての接頭辞シギル演算子は商品コンテキストで評価された1つの位置の引数を右辺値として受け入れる。 それらが、もし括弧で呼び出されるなら文字列で補間挿入されることができる。 特別な構文形式$() 中に翻訳する$( $.ast // Str($/) ) 同様に、現在のマッチオブジェクトの手術をするために@() そして%() 位置の、そして名指されたサブマッチを引き抜くことができる。

Parcel そしてCapture オブジェクトが Perl 6 に参照の生態的地位を埋める。 あなたは「脂肪」参照としてのそれら、すなわち、それがそうすることができる参照についてただ一つのオブジェクトの現在の識別情報だけではなく、キャプチャを考えることができる、しかし同じくいくつかの関連したオブジェクトの相対的な識別情報。 Conversely 、あなた容器の変化したフォームとして Perl 5 参照について考えろCapture あなたが一つの商品だけを参照することを望むとき。

スペシャルがあるParcel 値が名前をつけられるNil. 　それが意味する「ここに値がない」。 それは空きの未定義の同等物だ() 後者が定義されて、そして「ここに0の引数がある」ということを意味すること以外、傾け。 Nil もしあなたがそれを反復するか、あるいは添え字化することとしてのそれからの位置の値を得ようとするなら、値がそれ自身を返すが、平らなコンテキストと空きの中に空白リストとして補間挿入されるSeq 木コンテキストの中に。 どちらの場合も、警告が表示される。

呼び出しがそうであるメソッドが直接何に関してでもオブジェクトを行なったときから、Nil ある特定のメソッド呼び出しに返答することができる。 Nil.defined 戻るFalse （のに対して().defined 戻るTrue）. Nil.so 同じく戻るFalse. Nil.ACCEPTS それ以外の何ものでもなくマッチするNil 値。 Nil.perl そしてNil.gist 戻れ'Nil'. Nil.Stringy そしてNil.Str 帰り」警告で. Nil.Numeric 警告で0を返す。 上に Any の未定義のメソッド呼び出しNil 戻るNilそれでそれNil メソッド呼び出し鎖の下方に繁殖する。

割り当てるNil スカラーコンテナが何かの外にスローするべきコンテナにコンテンツと復旧自身をもたらす何かにイニシャライズされていない公式（それがどちらの後にそうするだろうかコンテナ、どこ（で・に）かの宣言型に適切な型オブジェクトを含んでいるAny デフォルト型だ）. バインドしているNil で:= ただコンテナに Nil を入れる。 しかしながら、バインディングNil 仮引数に（::= 意味規則）；パスして、いっそう割り当てのように働くNil 仮引数にデフォルトでその仮引数を設定されさせるから未定義の値よりむしろ、引数が供給されなかったかのようにそのデフォルト値。

割り当てるNil 何にでも合成のコンテナ（そんなものけれどもArray あるいはHash）、イニシャライズされていないステートに戻ってそれをリセットして、コンテナを空にする. コンテナオブジェクトはそれから、それ自身未定義になる。 （【割り当て】の() それが定義される状態にしておく。）

sink 文接頭辞が熱心に何でも評価するだろう、ブロックあるいは文、が結果をスローして、そしてその代わりに戻るNil 値。 これは、まだ空リストを返している間に、若干の振る舞いを空リストに固定させるために有用であり得る：

# Check that incoming argument list isn't null
@inclist = map { $_ + 1 }, @list || sink warn 'Nil input!';

@inclist = do for @list || sink { warn 'Nil input!'; $warnings++; } {
    $_ + 1;
}

# Check that outgoing result list isn't null
@inclist = do map { $_ + 1 }, @list or sink warn 'Nil result!';

@inclist = do for @list {
    $_ + 1;
} or sink { warn 'Nil result'; $warnings++; }
 

そうではあるがsinkそこ（に・で） Perl 6 のループで「ほかに」文節のために必要性じゃない , そして the sink 構造が何でも公正じゃないリストを扱うfor ループ。

ACaptureCursor オブジェクトは関連づけられたスタートポジションでもう1つのキャプチャの中に光景だ。 このような線を引いたガラス板は本質的にパターン - マッチしているステートだ。 カーソルが演算のために使われるキャプチャgrep そしてmap そしてfor 短いシグネチャー複数回を卑しいキャプチャによって供給された値のより長いリストに適用する必要があるループ。 我々が「キャプチャ」と言うとき、我々は時々いずれかを意味するCapture あるいはCaptureCursor. CaptureCursors 同じく不変だ。 パターンであるとき、マッチしていて、線を引いたガラス板に対してのシグネチャー、あなたが教える新しい線を引いたガラス板バックのためにあなた卑しいキャプチャでの転職先を手に入れる。

シグネチャーオブジェクト（Signature）、コロンによって前接続された括弧で：作られるかもしれない

my ::MySig ::= :(Int, Num, Complex, Status)
 

シグネチャーの中の展開式が普通の展開式よりむしろ仮引数宣言と解析される。 パラメータのためにもっと多くの構文についての詳細については S06 を見ろ。

Declarators は一般にコロンをオプションにする：

my ($a,$b,$c);      # parsed as signature
 

オブジェクトが型変数にバインドしたシグネチャーが（例のように上に）他のシグネチャーの中で追加の型拘束知識を応用するために使われるかもしれない。 引数、シグネチャーがあなたにキャプチャの引数の型をとることを許すキャプチャに適用されるとき、MySigけれども、括弧にあなた自身さらにシグネチャーとしての（型宣言されていない）変数名を宣言しろ：

sub foo (Num Dog|Squirrel $numdog, MySig $a ($i,$j,$k,$mousestatus)) {...}
foo($mynumdog, \(1, 2.7182818, 1.0i, statmouse());
 

Perl 5 、表記法の場合と異なり&foo ただ賛成の状態にあるfoo 関数 as a Routine それを呼び出さないでオブジェクト。 あなたは、（もちろん、引数を含んでいるかもしれない）括弧でそれをデリファレンスすることによって、どんなコード化オブジェクトでも呼び出すかもしれない：

&foo($arg1, $arg2);
 

それが接尾辞と解析されるから、空白文字ではないが前に括弧を許した。 何ででも接尾辞、同じく文通することがある（とき・から・につれて・ように）.() 演算子とあなたは「unspace」フォームをオプションの空白文字とコメントをバックスラッシュと接尾辞フォームのいずれかの間に挿入するために使うかもしれない：

&foo\   ($arg1, $arg2);
&foo\   .($arg1, $arg2);
&foo\#`[
    embedded comment
].($arg1, $arg2);
 

注意するしかしながら関数とメソッド呼び出しのフォームという名前の「標準」の引数の周りの括弧が接尾辞じゃない、演算子が、それほど許さないこと.() できろ、なぜならドットは名指されたフォームがしていない実際の間接参照演算を示しているから。 あなたは、しかしながら、「unspace」を余分のスペースを括弧の前にフォームにインストールするために使うかもしれない：

foo()       # okay
foo\ ()     # okay
foo.()      # means foo().()

.foo()      # okay
.foo\ ()    # okay
.foo.()     # means .foo().()

$.foo()     # okay
$.foo\ ()   # okay
$.foo.()    # means $.foo().()
 

もしあなたが使用をするなら、ドットのある（人たち・もの）はこれらの上に特別なフォームを構成する、それはあなたが引数がない名指されたフォーム、そして次にデリファレンス、それの結果、を呼び出すことを望んだと想定するだろう。

多数のディスパッチで、&foo 実際は名前であrnodispatch ルーチン（インスタンスを作られたからproto）セットをコントロールすることが対象関数の（それをあなたが、それが普通の関数であるかのように、使うことができるからdispatch 本当にであるonly ディスパッチャの経営への pretentions を持っている関数）. しかしながら、このような場合&foo それ自身ユニークに特定の関数と命名するに十分なではないによって。 それをするために、型は後置演算子としてリテラルで、シグネチャーを使うことによって、精製されるかもしれない：

&foo:(Int,Num)
 

劣化で明瞭に一つの多結果を選択しないシグネチャーの使用。

それはまだただ戻るRoutine オブジェクト。 呼び出しが、使うことによって、同じく部分的に応用であるかもしれない.assuming メソッド：

&foo.assuming(1,2,3,:mice<blind>)
 

Slicing 構文は S09 で覆われている。 多次元のスライスがセミコロンで個別のスライス部分リストの間で行われるだろう。 セミコロンはトップのリストが型の（こと・もの）である木 - ness の1つの余分のレベルを暗示するLoL そして部分リストがそうだListss（あるいは一つの商品の区画として関数を缶詰めにする非 iterable 品目）。 そうあなたが言うとき

@matrix[1..*; 0]
 

本当は手段

@matrix[LoL( (1..*), 0 )]
 

おのおののそのようなスライス sub - 区画がいい加減に評価される。

幾分値以外のスライス添え字復帰をかせぐために、添え字に適切な副詞を添えろ。

@array = <A B>;
@array[0,1,2];      # returns 'A', 'B', Nil
@array[0,1,2] :p;   # returns 0 => 'A', 1 => 'B'
@array[0,1,2] :kv;  # returns 0, 'A', 1, 'B'
@array[0,1,2] :k;   # returns 0, 1
@array[0,1,2] :v;   # returns 'A', 'B'

%hash = (:a<A>, :b<B>);
%hash<a b c>;       # returns 'A', 'B', Nil
%hash<a b c> :p;    # returns a => 'A', b => 'B'
%hash<a b c> :kv;   # returns 'a', 'A', 'b', 'B'
%hash<a b c> :k;    # returns 'a', 'b'
%hash<a b c> :v;    # returns 'A', 'B'
 

これらの副詞のフォームはすべて存在しない項目を取り除く。

同じく、

my ($a,$b,$c) = %hash<a b c> :delete;
 

それらを返している間に、項目「en passant」をデリートする。 （もちろん、これらのフォームの何でも同じく一つの添字を含んでいるスライスの変化したケースで働く。） 添え字が最高の前の演算子であるという事実によってこれらのフォームが機能することに注意を払え。 もしカンマよりもっときつい何か他の演算子が最高であるように思われるであろうなら、あなたはリストコンテキストを括弧で括るか、あるいは強制しなければならないかもしれない：

1 + (%hash{$x} :delete);
$x = (%hash{$x} :delete);
($x) = %hash{$x} :delete;
 

（それらが通常コンマ優先順位において営業するリストコンテキストで使われるから、状況は上記のスライス修飾子のためにしばしば生じない。）

あなたは一つの商品あるいは項目のジャンクションに、同様、同じく存在テストを行なってもよい：

if %hash<foo> :exists {...}
if %hash{any <a b c>} :exists {...}
if %hash{all <a b c>} :exists {...}
if %hash{one <a b c>} :exists {...}
if %hash{none <a b c>} :exists {...}
 

使う:exists それが両方の方法で論じられることができたから、副詞が － なるべくコンパイル時間に － 一緒にリストスライスで錯誤をもたらすかどうか:exists そのままのリストの上に持っているだろうany あるいはall 意味規則。

数のコンテキストで（すなわち、投げられるとき中にInt あるいはNum） , a Hash オブジェクトがペアに含まれる項目、ハッシュ、の番号になる。 ブールのコンテキストで、もしある、何かがハッシュで対になるなら、ハッシュオブジェクトが真だ。 どちらの場合も、何でも本質的であるという状態で、イテレータがリセットされるだろう。 （もしハッシュが本質的なイテレータを振る舞う（それらとして Perl 5 にする）なら、あるだろう.reset 明示的にイテレータをリセットするハッシュオブジェクトの上のメソッド。）

ペアのリストを分類することはデフォルトによってのそれらのキーで、それからそれら値の上にソートするべきだ。 リストのリストを分類することは要素、それから2番目の要素などをファーストで分類するべきだ。 さらに多くのために上にsort S29 を見ろ。

Perl 5 の特別な変数の多くが立ち去っている。 ファイルハンドルのような若干のオブジェクトに適用されるそれらはその代わりに適切なオブジェクトの属性だろう。 グローバルが世界的なアルファベット順の名前、そんなものを持つであろう本当にである人たち$*PID あるいは@*ARGS.

残っている特別な変数がレキシカルスコープなであろう Any 。 これは含む$_ そして@_新しい（人たち・もの）と同様$/それは最後の正規表現マッチのリターン値だ。 $0$1$2など、別名である中に$/ オブジェクト。

$#foo 表記法は死んでいる。 使用@foo.end あるいは@foo[*-1] その代わりに。 （あるいは@foo.shape[$dimension] なぜなら多次元の配列。）

識別子がどんな列によってでも後に続かれたアルファベット順の文字について英数字の文字で構成されている。 アルファベット順の、そして数のインクルードの適切な Unicode 文字の定義。 アンダースコアが常にアルファベット順であると見なされる。 次の文字がアルファベット順であるなら、識別子が同じく孤立したアポストロフィーあるいはハイフンを含んでいるかもしれない。

名前は（シギルを計算に入れないで）変数名の正当な部分である何もだ。 これは含む

$foo                # simple identifiers
$Foo::Bar::baz      # compound identifiers separated by ::
$Foo::($bar)::baz   # compound identifiers that perform interpolations
$42                 # numeric names
$!                  # certain punctuational variables
 

シギル、意味の（人たち・もの）として使用されないとき、作用しろ:: 名前以内が名前の前の部分に名前の次の部分が位置しているはずである1パッケージだと見なされることを強いるはずだ。 もし前の部分がゼロであるなら、それは実装が特定されていないことを意味して、そして続くことの性質によれば、捜されなくちゃならない。 一般にこれはそれにイニシャルを意図する:: けれども、主なシギルがにおいて知られている名前の上に無操作命令である下記が時間をコンパイルする::() 同じく補間を開始する（下を見る）ために使われることができる。 同じく、もう1つのシギルがないときには、:: － もう － 申告されないパッケージ名の意図的な使用を示してそれ自身のシギルとして勤めることができる。

Perl 5 の場合と異なり、もしシギルが（Unicode 括弧と空白文字を含めて）括弧あるいは空白文字について親切にコロンが識別子、あるいは何までにも後に続かなかったコンマ、セミコロン、によって後に続かれるなら、 punctuational 変数よりむしろ名前なしでシギルだとみなされるだろう。 これはあなたがシギルを自動型変換演算子として使用することを可能にする：

print $( foo() )    # foo called in item context
print %( foo() )   # foo called in hash context
 

宣言部分構造でそのままのシギルが匿名の変数の間プレースホルダーとして使用されるかもしれない：

my ($a, $, $c) = 1..3;
print unless (state $)++;
 

あなたが使うかもしれない宣言部分構造の外で* プレースホルダーのために：

($a, *, $c) = 1..3;
 

何かを言うべき試み：

($a, $, $c) = 1..3;
 

通信をもたらすだろう、「匿名の変数が宣言詞を必要とする」。

普通の実装 - 修飾名がそれらが Perl 5 にするように見える：

$Foo::Bar::baz      # the $baz variable in package Foo::Bar
 

時々変数名でシギルを保持することはいっそう明確だ、それでこれを書く代わりの方法がそうだ：

Foo::Bar::<$baz>
 

変数名が定数であるから、これはコンパイル時間に解決される。

次の擬似パッケージ名は名前の先頭において予約されている：

MY          # Symbols in the current lexical scope (aka $?SCOPE)
OUR         # Symbols in the current package (aka $?PACKAGE)
CORE        # Outermost lexical scope, definition of standard Perl
GLOBAL      # Interpreter-wide package symbols, really UNIT::GLOBAL
PROCESS     # Process-related globals (superglobals)
COMPILING   # Lexical symbols in the scope being compiled
DYNAMIC     # Contextual symbols in my or any caller's lexical scope
 

次の相対的な名前は同じく遠慮がちだ、しかしどこでも名前で使われるかもしれない：

CALLER      # Contextual symbols in the immediate caller's lexical scope
OUTER       # Symbols in the next outer lexical scope
UNIT        # Symbols in the outermost lexical scope of compilation unit
SETTING     # Lexical symbols in the unit's DSL (usually CORE)
PARENT      # Symbols in this package's parent package (or lexical scope)
 

他の全大文字名は半遠慮がちだ。 我々は将来それらのさらに多くを加えるかもしれない、それであなたは、あなたのトップレベルのパッケージで入り混ざった場合を使うことによって、あなた自身を未来の対立から守ることができる。 （我々は存在するトップレベルの CPAN が、もちろん、包装する何も破らないことを約束する。 多分以外ACMEそして次にただコヨーテのために。）

範囲が知られているファイルのUNITしかしそこ（に・で）（しばしば他の文化で前兆として知られている）言語の設置に対応するそれの外の1つ以上のレキシカルスコープである. Hence, the SETTING 範囲が同等であるそうすることUNIT::OUTER. 　標準的な Perl プログラムのためにSETTING 同じであるけれどもCOREしかし種々の始動オプション（そんなものけれども-n あるいは-p）あなたを言語、どのケースの領域特定に入れることができるCORE 標準語、間の範囲のままでいるSETTING 機能する DSL を現行ファイルをセットすることと定義しているスコープを表す。 同じく見る-L/ --language S19 - commandline で記述されて乗り換えろ。 もし設置が主な実行の利得調整に、それがただ宣言する必要があるならいいのにと思うならMAIN 同じぐらい S06 で文書化されたルーチン。 この場合ユーザのコード化の普通の実行は隠される；その代わりに、ユーザのコード化の実行は完全に委任先、設置、のだMAIN レキシカルに埋め込みのユーザのに戻る呼び出しがコードするルーチン{YOU_ARE_HERE}.

{YOU_ARE_HERE} ユーザののためのプロキシとしての沈むことの中の関数UNIT それほど、ブロックしろ-n そして-p 設置で実装されるかもしれなで :

for $*ARGFILES.lines {YOU_ARE_HERE}                 # -n
map *.say, do for $*ARGFILES.lines {YOU_ARE_HERE}   # -p
 

あるいは

map {YOU_ARE_HERE}, $*ARGFILES.lines;               # -n
map *.say, map {YOU_ARE_HERE}, $*ARGFILES.lines;    # -p
 

そして、それらが直接ループブロックであるかのように、ユーザはループ制御フェーザを使うかもしれない。 Any OUTER コード化が外ブロックを参照するユーザので{YOU_ARE_HERE}. 　もし独立型の文として使用されるなら、{YOU_ARE_HERE} それがそのままのブロックであるかのように、走る。

それ以来、それに注意するUNIT eval についてそれ自身、 eval 文字列であるSETTING 実施にファイルのトップに、実施される言語ではなく、 eval のポイントに言語が eval だ。 （あなたは、しかしながら、使ってもよいOUTER::SETTING eval を実行しているコード化をセットすることを得るために。） いっそう伝統的な項で、標準のプログラムは eval の「前兆」として作用することだ。

最も外側のレキシカルスコープが、否定されて、このようにネストするようにとしてOUTER：

CORE <= SETTING < UNIT < (your_block_here)
 

スコープが、否定されてこのようにネストする最も外側の実装としてPARENT：

GLOBAL <  (your_package_here)
 

あなたメインプログラムが中にスタートするGLOBAL package そして the UNIT レキシカルスコープ。 何でも "our" で意味規則だと宣言されるときはいつでも、それは名前を現在の実装と現在のレキシカルスコープ両方に挿入する。 （そして "my" 意味規則がただレキシカルスコープを現在に挿入する。） それほど標準的な設置的に注意する、CORE1パッケージではなく、レキシカルスコープだ；定義されるさまざまな項目が中だ（あるいは輸入された中に）CORE 中に *not* だGLOBALいつおおかた空のあなたのプログラムはコンパイルし始めて、そして主としてただものを含むだけである、あなたがそのモジュールを使ったから、あなたはあるいはそこ（に・で）あなた自身、あるいはそこ（に・で）置かれた何か他のモジュールを置いた. 一般にものが中で定義される（あるいは輸入された中に）CORE ただ宣言されるべきであるか、あるいは "my" で意味規則を読み込む。 Perl コード化が見ることができるすべてCORE とにかく最も外側のレキシカルスコープとして、それで同じくこのようなことを注ぐべき必要性がないGLOBAL.

GLOBAL 実装自身がアクセス可能であるとしてUNIT::GLOBAL. PROCESS 実装がアクセス可能であるとしてUNIT::PROCESS.PROCESS ではない、親、を包装しろGLOBAL. 　しかしながら、ダイナミックな一時的記憶装置上がって dynamic を検索して、変数が（自動的にそれぞれの呼び出しのレキシカルスコープにマップされて、範囲をパッケージするな）主なダイナミックスコープに向かってすべてのネストされた動的有効範囲で見るだろう； すべての動的有効範囲が消耗している途端に、それは同じくちょっと立ち寄るGLOBAL 実装、そして次に中にPROCESS 実装、そうだ$*OUT 典型的にプロセスの標準出力ハンドルを見いだす。 従って、PROCESS そしてGLOBAL 余分の外の動的有効範囲の役をして、極めて好むCORE そしてSETTING 余分の外のレキシカルスコープとしての関数。

余分のものSETTING スコープが（彼・それ）らの身元とそれらをネストすることを中である状態に保つCOREあなたがそうしなければならないかもしれないように行けOUTER 数回からUNIT あなたがそうすることができる前にCORE. 　しかしながら、通常、どのケースで、ただ中核となる沈むことだけがあるUNIT::OUTER 同じを意味することになるけれどもSETTING 同じがどちらとしてかCORE.

余分のものGLOBAL スコープが異なって扱われる。 すべてのコンパイル単位がそれ自身のものが提携させられるようにするUNIT::GLOBAL 実装。 現在コンパイルしているコンパイル単位が種々の他のコンパイル単位のために必要性を表現する、それらの他の単位に知られている大域名が新しい単位のに統合されなくちゃならない（とき・から・につれて・ように）UNIT::GLOBAL. 　（これはグローバルな実装の中ですべてのパッケージに名前を含める。） もし2つの異なった単位が同じグローバル名を使うなら、それらが一般に同じ商品に言及するために、しかしシグネチャーがそうであり得る型が噛み合った場合に限り、だまされるに違いない（そして、中に、後に続かれた増大ルールパッケージ名のケース）. もし2つの単位が互換性がない型シグネチャーをパッケージ名に提供するなら、単位のコンパイルは失敗する。 言い換えれば、あなたは相容れない世界的な型を共用体型を提供するために使わないかもしれない。 しかしながら、もし1（人・つ）あるいは他の単位が互換性がある方法で型を過小に指定するなら、それがそれを学ぶ（とき・から・につれて・ように）、過小に指定された型はただ余分の型情報を雇う。 （多分 Liskov 置換の若干の組み合わせが、ダックタイピングと実行時が調べるという状態で、過小に指定された型でコンパイルされた単位で悲劇を防ぐだろう。 代わる代わる、コンパイラは問題が確かな何かがランタイムに起こるかどうか見るために書き下ろし型拘束知識で単位をリコンパイルするか、あるいは再検討することを可能にされる、そしてその場合コンパイラは不平を言うことが自由だ。）

ダイナミックな変数がその人と共に宣言した Any our ユーザのメインプログラムで（特に、コンパイルされた部分でGLOBAL 現在の実装として）アクセス可能である（中にいることによってGLOBAL）動的変数としてもしそうでなければさえ直接ダイナミックな呼び出しチェインで. ダイナミックな変数が * ではなくが見る * をすることに注意を払えCORE 何のためにでも。 （それらがちょっと立ち寄るかもしれないSETTING もしあなたが凝固している互いに素の下を走っているならからCOREもしその沈むことが賛成であるのような、あなたのメインプログラムの外（に・で）ダイナミックスコープを定義するなら-n あるいは-p 乗り換えろ。） 変数が一緒に宣言したコンテキストour 中にいるGLOBAL あるいはPROCESS パッケージが使う必要がない* それらのパッケージを捜索する前に、 twigil が、 twigil からはがされる。 従って、あなたの環境変数はシギルなしで効果的に宣言される：

augment package GLOBAL { our %ENV; }
 

あなたは1パッケージあるいは変数名使用方法の中に文字列を補間挿入してもよい::($expr) あなたが通常（すでに）1パッケージあるいは変数名を置いていたところ。 文字列は許される、から追加の例を含んでいろ::それは実装埋め込みと解釈されるだろう。 あなたはただ、構造前方一致から、全部の名前を補間挿入してもよい::そしてすぐにいずれかの終わりあるいはもう1つで続けられる:: 括弧の外（に・で）。 たいていの象徴的な参照がこの表記法を終えている：

$foo = "Bar";
$foobar = "Foo::Bar";
$::($foo)           # lexically-scoped $Bar
$::("MY::$foo")     # lexically-scoped $Bar
$::("OUR::$foo")    # package-scoped $Bar
$::("GLOBAL::$foo") # global $Bar
$::("PROCESS::$foo")# process $Bar
$::("PARENT::$foo") # current package's parent's $Bar
$::($foobar)        # $Foo::Bar
$::($foobar)::baz   # $Foo::Bar::baz
$::($foo)::Bar::baz # $Bar::Bar::baz
$::($foobar)baz     # ILLEGAL at compile time (no operator baz)
 

Perl 5 にそれほど同じでなくて、最初に注意しろ:: グローバルを暗示しない。 ここで補間構文の一部としてそれは実装を暗示しさえしない。 補間の後にの::() それが、優先性がレキシカルスコープで最初に先行する擬似パッケージ名、それから名前に与えられるという状態で、オリジナルのソースコードでそこにあったかのように、コンポーネント、間接的な名前は正確に検索される（終わって、外へスコープを検索するでCORE）. 現在の実装は最後に捜索される。

使用MY 現在のレキシカルスコープに、ルックアップを制限する擬似パッケージそしてOUR スコープを現在の実装スコープに制限するために。

「厳格である」が有効である時（それは短いジョーク以外デフォルトだ）、資格を持っていない変数（そんなものけれども$x そして@y）ただ、決して実装スコープからではなく、レキシカルスコープから調べられる.

レキシカルスコープの中に実装変数をバインドするために、ただ言えour ($x, @y). 　レキシカルスコープの中にグローバルな変数をバインドするために、それらを前もって宣言しろuse：

use PROCESS <$IN $OUT>;
 

あるいはただとしてそれらに言及しろ$*IN そして$*OUT.

直接ルックアップをするために、1パッケージのシンボルテーブルで、走り読みしないで、パッケージ名をハッシュとして取り扱え：

Foo::Bar::{'&baz'}  # same as &Foo::Bar::baz
PROCESS::<$IN>      # Same as $*IN
Foo::<::Bar><::Baz> # same as Foo::Bar::Baz
 

:: 添え字が、ここで、必要とされる前にからFoo::Bar{...} autovivifiable 型オブジェクトまでの「いずこからか」初期化クロージャを付加することに対して、構文が予約される。（S12 参照）.

同じじゃない::() 象徴的な参照は、これは引数を解析しない::同様にそれはその初期点からネームスペーススキャンを始めない. 加えるに、不変の添え字のために、それはコンパイル時間に記号を解決することを保証される。

空の疑似パッケージは普通の名前サーチと同じサーチリストを意味するために予約される。 すなわち、次のことはすべて意味で同一だ：

$foo
$::{'foo'}
::{'$foo'}
$::<foo>
::<$foo>
 

すなわち、それらのそれぞれが外へレキシカルスコープを走査する、そして次に、（「厳格である」が有効であるとき、実装スコープがその時認められないけれども）、現在の（人たち・もの）は範囲をパッケージする。

これらの結果としてルールは、あなたはのいずれかとして何にでも任意の変数名を書くことができる：

$::{'!@#$#@'}
::{'$!@#$#@'}
 

同じく使用権限：::<> 名前にスペースがない限り、できろ。

現在の語彙のシンボルテーブルは疑似パッケージを通して今アクセス可能だMY. 　現在の実装シンボルテーブルは疑似パッケージとして目に見えるOUR.OUTER 名前 refers から the MY シンボルテーブルがすぐに現在を囲むMYそしてOUTER::OUTER あれのまわりの（の・もの・人）だ。

our $foo = 41;
say $::foo;         # prints 41, :: is no-op
{
    my $foo = 42;
    say MY::<$foo>;         # prints "42"
    say $MY::foo;           # same thing
    say $::foo;             # same thing, :: is no-op here

    say OUR::<$foo>;        # prints "41"
    say $OUR::foo;          # same thing

    say OUTER::<$foo>;      # prints "41" (our $foo is also lexical)
    say $OUTER::foo;        # same thing
}
 

あなたは使ってはならない、何でもレキシカルに、名前によってあるいは参照によって、コンパイルしてされるレキシカルスコープにシンボルを加えるシンボルテーブルをスコープ宣言した。 （もしけれどもそれが有用であることが分かるなら、我々はこれを緩める権利を保留する。）

CALLER 実装が（ダイナミックにスコープ宣言された）呼び出し側のレキシカルスコープを参照する。 レキシカルスコープが許可である呼び出し側のはあなたにどんなユーザー定義の変数でも隠す。 実際、それはデフォルトだ、そして語彙の変数がトレイトを持っていなくちゃならない「is dynamic」目に見えることとしてCALLER.（$_$! そして$/ 常にダイナミックだ、変数であるように、誰のが宣言したかがを含む段落を名指す* twigil 。） もし呼び出し側で目に見える変数ではないであるなら、それは劣化を返す。 その名前が呼び出しのポイントで目に見える、しかしそのレキシカルスコープの外から来る変数がそれらが元来ダイナミックであると宣言されたスコープによってコントロールされる。 Hence 、視程、のCALLER::<$*foo> どこ（で・に）決定される$*foo （それがそれがたまたま宣言されるところじゃないなら）、呼び出し側のスコープのそばに、実際に宣言されない。 同じくCALLER::CALLER::<$x> 宣言にだけ依存すの$x 呼び出し側があなたの呼び出し側で目に見える。

ダイナミックな変数が一般に一緒に初期化されるべきであるユーザー定義の::= 変数が修正されることが必要じゃないなら。 （ダイナミックな変数に読み取り専用であるという記録を残すことは、読み取り専用変数がロックされている必要がないから、競い合うスレッドの間で同じ値を分担することについて、項で非常に助けになる。）

DYNAMIC 疑似パッケージはただ同種のものに過ぎないCALLER それが現在の中で始まること以外外へすべての動的有効範囲（フレーム）を通してそれがその動的フレームの関連づけられたレキシカルパッドでのその名前の dynamic 変数を見いだすまでダイナミックスコープとそこから走査。 （このサーチは変数のために暗示されるで* twigil ；従って$*FOO 匹敵するものはそうするはずだDYNAMIC::<$*FOO>.） もし、外へそれらすべての動的有効範囲でスキャンした後で、レキシカルパッド、それがはがすすぐに関連づけられた何にもその名前の変数がないなら* 名前がなくなっている twigil とルックインGLOBAL 通り過ぎて後に続かれた実装PROCESS 実装。 もし値ではないが見い出したなら、それは劣化を返す。

同じじゃないCALLERDYNAMIC ダイナミックな変数がすなわち、現在の範囲に宣言されて、それが始まるから1よりむしろ一時的記憶装置上がって0のスコープを検索するのを見るだろう。 あなたは、しかしながら、使ってもよいCALLER::<$*foo> からダイナミックな定義を回避しろ$*foo 外のダイナミックな値でそれを初期化するためのような、あなたの現在のスコープで：

my $*foo ::= CALLER::<$*foo>;
 

temp 宣言詞が（初期化演算子なしで）ダイナミックな変数に関して類似の演算を行なうために使われるかもしれない：

temp $*foo;
 

主な差はデフォルトまでにそれが新しい（人たち・もの）を初期化するということだ$*foo その現在の値で、呼び出し側の値よりむしろ。 同じく、それは許される、ただ外の値のコピーを作る唯一の理由があなたが後にそれをオーバーライドすることを望んで、そして次に変更を忘れるであろうから指定期間の末であろうときからのリードライト動的変数の上に現在のダイナミックスコープ。

あなたは同じく使ってもよいOUTER::<$*foo> あなたがあなたの外のレキシカルスコープでサーチを始めることを望む、しかし、その外のレキシカルスコープが同じくそうであること偶然起こる場合に限り、これが成功するであろうことを意味するために、あなたの現在の動的有効範囲の1つであれ。 すなわち、同じサーチはそのままの（人たち・もの）と同じようにされる$*foo何以外でも「起きて」、我々がそうしなければならないようになるまで、無視されるOUTER 我々の走査のスコープ。

そこ（に・で）もうどんな特別な実装ハッシュでもではなくがそんなものであるけれども%Foo::. 　ただそのキーが変数名、何でも含めてシギルであるハッシュオブジェクトとしてそれ自身実装オブジェクトを添え字化しろ。 オブジェクトが使用によって型名から得られることができる実装:: 接尾辞：

MyType::<$foo>
 

（正方形の括弧あるいはカーリーで直接型を添え字化することは種々の一般的な型 - 理論的な演算に限られる。 他のほとんどの問題でタイプ名とパッケージ名は交換可能だ。）

Typeglobs はなくなっている。 バインディングを使う（:= あるいは::=）別名化をすること. 個別の変数オブジェクトはそれぞれのシンボルテーブルを表しているハッシュを通してまだアクセス可能だ、しかしあなたは今変数名でシギルを含まなければならない：MyPackage::{'$foo'} あるいは同等物MyPackage::<$foo>.

グローバルが住んでいる Interpreter GLOBAL 実装。 ユーザーズプログラムは始まるGLOBAL 実装、それで主回線での宣言がコード化する "our" はデフォルトまでにその実装に入る。 プロセス規模の変数が住み込むPROCESS 実装。 たいていの前もって定められたグローバルのよう$*UID そして%*PID 実際はプロセスグローバルだ。

ただ今までにシングルがあるPROCESS 実装。 ひとりでに走っている普通の Perl プログラムのために、ただ1（人・つ）があるGLOBAL 同様に包装しろ。 しかしながら、（Web サーバの下の共有されたホスティング機能のような）ある特定の状況で、実際のプロセスは多数のバーチャルプロセスを含んでいるかもしれない、あるいはそれぞれそれ自身の「メイン」を動かしているインタープリタがコードする。 この場合、GLOBAL ネームスペースが、間、適切に個別の事実上のプロセスのものである変数を持っているPROCESS ネームスペースが適切に実際のプロセス全体のものである変数を持っている。 プログラムの観点から、すべてのグローバルな変数が、それらが動的変数であるかのように、アクセスされる限り、小さい相違がある（使うことによって* twigil）. 個別のサブプロセスによって見られるように、プロセス全体はプロセス変数の変わりやすさに対して制約事項を与えるかもしれない。 同じく、個別のサブプロセスが新しいプロセス変数を作らないかもしれない。 プロセスがとして伝えるべき交付金サブプロセス、能力、に望むもしPROCESS ネームスペース、それはその特典を認められたすべてのサブプロセスに writeable 動的変数を供給しなくちゃならない。

すでに存在しないダイナミックな変数を割り当てるか、あるいはバインドすることは非合法だ。 それは中に作成されないだろうGLOBAL （あるいはPROCESS）自動的に、また、それは何ででもレキシカルスコープに列せられない. その代わりに、あなたはそれにうまくいくようにさせるためにパッケージ名を使って直接割り当てなくちゃならない：

GLOBAL::<$mynewvar> = $val;
 

魔法のコマンドラインインプットハンドルはそうだ$*ARGFILES. 　引数自身は中に入る@*ARGS. 　S06 で同じく「メインサブルーチンを宣言している」を見ろ。

値が変数で甘んじて受け入れる － がスコープ宣言したマジカルなファイル= 第二のシギル。 $=DATA 名前であrnoあなたDATA 例えばファイルハンドル。 すべての Pod 構造は完全に利用可能だ%=POD （あるいは何かそのようなもの）。 と同じように*= 同じく実装名前：として使用されるかもしれない$=::DATA.

レキシカルにスコープ宣言された値が変数で一緒に住んでいる Magical ? 第二のシギル。 これらはすべてコンパイラに知られていて、そして実際それ自身コンパイラの中で動的にスコープ宣言されるかもしれない値であって、そしてただ、コンパイラの動的有効範囲がプログラムのレキシカルスコープに溶解するから、レキシカルスコープなであるように思われる。 すべて$? 変数は中に見なされた定数であって、そして、コンパイルされた後で、変更されないかもしれない。 ユーザは同じく定義するべき許可だあるいは（再定義しろ）このような定数：

constant $?TABSTOP = 4;     # assume heredoc tabs mean 4 spaces
 

（宣言詞が常にその初期化展開式を評価する不変の（人たち・もの）が時間をコンパイルするとは、注意しろ。）

$?FILE そして$?LINE 例えばあなたの現行ファイルと行番号だ。 代わりに$?OUTER::FOO あなたはおそらく書くことを望むOUTER::<$?FOO>. 　それがとしてコンパイル、そんなものの間に失点にしているコード化の中でBEGIN ブロック、あるいはマクロボディ、あるいは一定のイニシャライザ、変数が（例えば）言及されなくちゃならないコンパイラCOMPILING::<$?LINE> もしそのままの（人たち・もの）であるなら$?LINE ユーザの終局のコード化よりむしろ現在ランニングのコード化のコンパイルの間の値のコンパイル単位だとみなされるだろう。 例えば、マクロ本体の中で$?LINE ただ、マクロ本体の中でラインだCOMPILING::<$?LINE> マクロが呼び出されたラインだ。 存在しているさらに多くのために下を見るCOMPILING 疑似パッケージ。

ここに若干の可能性がある：

$?FILE      Which file am I in?
$?LINE      Which line am I at?
&?ROUTINE   Which routine am I in?
&?BLOCK     Which block am I in?
%?LANG      What is the current set of interwoven languages?
 

すべての関係があるインフォメーションを含んでいる次の帰りのオブジェクト：

$?KERNEL    Which kernel am I compiled for?
$?DISTRO    Which OS distribution am I compiling under
$?VM        Which virtual machine am I compiling under
$?XVM       Which virtual machine am I cross-compiling for
$?PERL      Which Perl am I compiled for?
$?SCOPE     Which lexical scope am I in?
$?PACKAGE   Which package am I in?
$?MODULE    Which module am I in?
$?CLASS     Which class am I in? (as variable)
$?ROLE      Which role am I in? (as variable)
$?GRAMMAR   Which grammar am I in?
 

名前のような種々の属性、バージョン、あるいは権限をチェックするためにペアに対してこれらの不変のオブジェクトにスマートマッチすることは比較的容易だ：

given $?VM {
    when :name<Parrot> :ver(v2) { ... }
    when :name<CLOS>            { ... }
    when :name<SpiderMonkey>    { ... }
    when :name<JVM> :ver(v6.*)  { ... }
}
 

不変のオブジェクトがすべて解決されるかもしれない上に不変の対のマッチが時間をコンパイルする、それで不要コードがオプティマイザによって削除されることができる。

これらのものの若干が類似物を中に入れるとは、注意する* ランタイムにおいてのスペース：

$*KERNEL    Which kernel I'm running under
$*DISTRO    Which OS distribution I'm running under
$*VM        Which VM I'm running under
$*PERL      Which Perl I'm running under
 

あなたはこれらがそれらコンパイル時いとこと同じ値にかかっているであろうと想定するべきじゃない。

間$? 変数はランタイムに不変だ、コンパイラはそれ自身のものについて困惑しないでコンパイル時間にこれらの値を変える方法を持っていなければならない$? （コンパイル時コード化がそれ自身コンパイルされた時に冷凍であった）変数。 コンパイラは使っているこれらのコンパイラ - ダイナミックな値について話をすることができるCOMPILING 擬似パッケージ。

そうするための参照COMPILING 変数が現在コンパイルされているレキシカルスコープの中に自動的に持ち上げられる。 沈むか、あるいはテンポラリ化するCOMPILING 変数が沈むか、あるいはテンポラリ化する初期の（人たち・もの）$? コンパイルされている周囲のレキシカルスコープの変数。 もしコンテキストにおける何がコンパイルされていないなら、例外がスローされる。

$?FOO // say "undefined";   # probably says undefined
BEGIN { COMPILING::<$?FOO> = 42 }
say $?FOO;                  # prints 42
{
    say $?FOO;              # prints 42
    BEGIN { temp COMPILING::<$?FOO> = 43 } # temporizes to *compiling* block
    say $?FOO;              # prints 43
    BEGIN { COMPILING::<$?FOO> = 44 }
    say $?FOO;              # prints 44
    BEGIN { say COMPILING::<$?FOO> }        # prints 44, but $?FOO probably undefined
}
say $?FOO;                  # prints 42 (left scope of temp above)
$?FOO = 45;                 # always an error
COMPILING::<$?FOO> = 45;    # an error unless we are compiling something
 

それに注意しろCALLER::<$?FOO> 同じ変数を発見するかもしれないけれどもCOMPILING::<$?FOO＞ しかしコンパイルしているスコープが即刻の呼び出し側である場合に限り。 同じくOUTER::<$?FOO> あなたを正しい場所に連れて行くかもしれない、あるいはそうしないかもしれない。 抽象的に、COMPILING::<$?FOO＞ それがコンパイルしているスコープを見いだして、そしてそれで「権利」を見いだすことを保証されるまで、ダイナミックに外側に行く$?FOO. 　（実践で、コンパイラはとにかく希望を抱いてその現在のコンパイルしているスコープを記録・追跡する、それでスキャンが必要とされない。）

明敏な読者がこれが種々の「コンパイラヒント」提案を包括することを指摘するだろう。 頭がおかしい読者がこれがあなたがコンパイルしているスコープで他の語彙のために初期値を設定することができたことを意味するかどうかと思うだろう。 答えはイエスだ。 実際、この機構はおそらくエクスポーターによって輸入業者のネームスペースの中に名前をバインドするために使われる。

現在コンパイルしている Perl パーサは、中に編み束ねられた言語の1つを修正することによって、取り替えられるCOMPILING::<%?LANG>. 　スコープ宣言されたパーサがテンポラリ化するべきであるということを変える Lexically 、変更。 ここからの変更、から終わりがコンパイル単位についてただそれを割り当てるか、あるいはバインドすることができる。 一般に、変更が新しい文法そして次にポインティング（の・もの・人）を得ることを必然的に必要とするたいていのパーサCOMPILING::<%?LANG> その新しい文法においての項目。 代わる代わる、現在のパーサを動かしているテーブルは微分なしで修正されることができる、しかし少なくとも1レベルの匿名の微分が前の Perl 文法からじゃましなくちゃならない、あるいはあなたはほかの誰かの文法を台なしにすることであるかもしれない。 基本的に、中に文法の現在のセット%?LANG 現在のコンパイルしているスコープにだけ属さなければならない。 それは、少なくともすべてのパーティーの明白な同意なしで、分かちあわれなくはないかもしれない。 遠く離れてマジカルな構文はなし。 支配された（人たち・もの）とそのすべての同意。

個別の部分言語（「slangs」）が使って言及されるかもしれない~ twigil 。 次のことは有用だ：

$~MAIN       the current main language (e.g. Perl statements)
$~Q          the current root of quoting language
$~Quasi      the current root of quasiquoting language
$~Regex      the current root of regex language
$~Trans      the current root of transliteration language
$~P5Regex    the current root of the Perl regex language
 

従って、あなたが標準の Perl マクロを定義しているとき、あなたは replacing だ$~MAIN 得られた言語で、しかしあなたが新しい正規表現バックスラッシュ列を定義するとき、あなたは replacing だ$~Regex 得られた言語で。 （これをする主な言語に構文がないかもしれない、あるいはそうするかもしれない。） レキシカルスコープにこのような変化が自動的にスコープ宣言されることに注意を払え；実数スラングと同じように、定義は周囲の文化から継承されたより大きい言語で一時的で、そして埋め込みだ。

直接マクロを定義する代わりに、あなたは新しい部分言語のレキシカルにスコープ宣言された宣言までに同じく1つ以上で文法ルールを混ぜてもよい：

augment slang Regex {  # derive from $~Regex and then modify $~Regex
    token backslash:std<\Y> { YY };
}
 

それがただブロック1つのミキシン指定期間の末をしなければならないことだけをするから、これはいっそう効率的である傾向がある。 スラング宣言が実装に何も関係を持っていないとは、注意しろRegexしかしそれ以外の何ものでもなくで$~Regex. 　Sublanguages は（彼・それ）ら自身のネームスペースにいる（現在の値の中にの%?LANG実際）. 従ってaugment 他のどこか（に・で）、実装ではなく、編み束ねられた言語のローカルな束の1つを変更している。

もし、例えば、あなたがただ現在のレキシカルスコープでその部分言語を停止させることを望むなら、あなたは完全に同じく sublang に取って代わるかもしれない：

supersede slang P5Regex {}
m:P5/./;             # kaboom
 

あなたが取って代わるもしMAIN それであなたは完全に Perl パーサを取り換えている。 これは、例えば「使用 COBOL」宣言によってされるかもしれない。 :-)

任意の文字あるいは他のデータ構造を含む名前を持つことはしばしば都合が良い。 典型的にこれらの使用は「短い」名前、しかし静けさがその要素のそれぞれが個々に同一であると確認できることを必要とする実体のセットが共通を共有する状況を伴う。 例えば、あなたはその短い名前が存在するモジュールを使うかもしれないThatModule、モジュールの完全なロングネーム以外そのバージョン、命名機関と多分その原始言語さえ含む。 同様に、一緒に名前を持った種々の構文カテゴリにおける演算子の仕事のセットが好むprefixinfixpostfixなど. これらの演算子のロングネームは、しかしながら、普通の識別子からしばしば除外される文字を含む。

すべてのそのような使用のために、（下を見ろ）添え字のような副詞の形によって後に続かれた識別子が延長された識別子だと見なされる：

infix:<+>    # the official name of the operator in $a + $b
infix:<*>    # the official name of the operator in $a * $b
infix:«<=»   # the official name of the operator in $a <= $b
prefix:<+>   # the official name of the operator in +$a
postfix:<--> # the official name of the operator in $a--
 

この名前は意味的に、統語論上ではなく、思い出されるはずだ。 すなわち、使われた括弧文字は名前の一部として扱われない；ただ引用されたデータだけが重要だ。 これらはすべての同一名だ：

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

外形にもかかわらず添え字指定フォームとして、これらの名前はランタイムにではなくコンパイル時間に変換される。 擬似添え字は単純なスカラーである必要がない。 これらは同じ2要素のリストで延長される：

infix:<?? !!>
infix:['??','!!']
 

識別子が、多数の名指された識別子拡張で、延長されるかもしれない、その場合名前は重要だ、しかしそれらオーダーがそうしない。 これらは同じモジュールに名前をつける：

use ThatModule:auth<Somebody>:ver<2.7.18.28.18>
use ThatModule:ver<2.7.18.28.18>:auth<Somebody>
 

副詞の構文が後にいっそう完全に記述されるだろう。

一つのアンダースコアがリテラルの数でただどんな2つの数値の間にでも許される、そしてそこで数値の定義は底の上に依存する。 （次の項で説明されるように、一つのアンダースコアが底接頭辞と次の数値の間に同じく許される。） Underscores が、底の次にポイントあるいは exponentiator を含んで、他のどこ（で・に）も数字リテラルに入ることを許されない、あるいは始まりあるいは終わりに。

イニシャル0 ひとりでにもう8進数を示さない。 あなたはそれのために明示的な底目標を使わなくちゃならない。 前もって定められた底接頭辞は次のものを含む：

0b          base 2, digits 0..1
0o          base 8, digits 0..7
0d          base 10, digits 0..9
0x          base 16, digits 0..9,a..f (case insensitive)
 

これらのそれぞれが底接頭辞の後にしかし最初の数値の前にオプションのアンダースコアを許す。 これらはすべて同じことを意味する：

0xbadcafe
0xbad_cafe
0x_bad_cafe
 

数の形式が副詞の形で底を前接続することを必然的に必要とする総合的な底：

:10<42>             same as 0d42 or 42
:16<DEAD_BEEF>      same as 0xDEADBEEF
:8<177777>          same as 0o177777 (65535)
:2<1.1>             same as 0b1.1 (0d1.5)
 

数値が表されると考えられる余分のものa・・・。z そしてA・・・。Zあなたが卑しい36に上がることができるように。 （使用A そしてB 卑しい12で、そうじゃないT そしてE.） 代わる代わるあなたは小数で数値のリストを使うことができる：

:60[12,34,56]       # 12 * 3600 + 34 * 60 + 56
:100[3,'.',14,16]   # pi
 

数値を表しているすべての数は（もし定数 - 折り畳めることがそれをとらえることができるなら、コンパイル時間にあるいはさもなければランタイムに）底、あるいは錯誤が結果に対してそうするであろうより少しに違いない。

Any 底が小数部を含むかもしれない。 あなたがそれに数がどこ（で・に）終わるか教えなければならないから、ドットが決してあいまいじゃない：

:16<dead_beef.face> # fraction
:16<dead_beef>.face # method call
 

ただ「e」あるいは「E」に始まって（何ででも形式）が追加の exponentiator に許すだけである10の基礎を置け。 他のすべての基数が不変の折り畳み式の普通の積のプロパティとべき乗に頼るか、あるいは2がすなわち、10進数としてデフォルトによって、それらが、文字列の外（に・で）、そうするであろう（とき・から・につれて・ように）、解釈されるであろう文字列の地域だと考える等価物を供給しなくちゃならない：

:16<dead_beef> * 16**8
:16<dead_beef*16**8>
 

それはそれほどそれ以外の何ものでもなく真である基数それを定義するe 数値としてそのようにあいまいだ、しかし何でも exponentiator が10歳であるべきかどうかがはっきりとじゃない底あるいは底とこれがそれを明示的にする：

0b1.1e10                    ILLEGAL, could be read as any of:

:2<1.1> * 2 ** 10           1536
:2<1.1> * 10 ** 10          15,000,000,000
:2<1.1> * :2<10> ** :2<10>  6
 

我々がそれらを書くようにけれども

:2<1.1*2**10>               1536
:2<1.1*10**10>              15,000,000,000
:2«1.1*:2<10>**:2<10>»      6
 

一般的な文字列から数への変換器は（* フォームを含めて、ランタイムに向かう準備が整っている一定の折り畳み式のではないから）これらすべてのフォームを認識するだろう。 同じく入るのを許されて、文字列は暗黙の基準化のために先行するプラスあるいはマイナスと多分後続する単位型だ。 先行する、そして後続する空白文字が無視される。 同じくそれほど先行して注意しろ0 ひとりでに Perl 6 に決して8進数を暗示しない。

これらすべてのケースで、生産された型は Int 、 Rat 、あるいは正確に数を表すことができる Num の中で最も狭いだろう。 ない場合型が正確にそれを表すことができる、どちらがいっそう正確であるとしても、それは Rat あるいは Num として返されるべきだ。 （Rat64 が標準か、あるいは大きい大きさの数でいっそう正確である傾向があるだろう、他方、 Rat の分子と分母のサイズ不適当な組合わせが頭上に最終的に Num の指数部より多くの正確度の費用がかかるだろうから、 Num64 は非常に小さい大きさの数でいっそう正確であるかもしれない。 制限するケース、 Rat64 が表すことができないように、何：10 ＜ 1 * 2より小さい ** にも達する － 64 ＞）

前の（人たち・もの）の結果はあなたが FatRat を使っているコロン表記法を作ることができないということだ。 あなたはコンストラクタと不変の折り畳めることに頼らなくちゃならない：

(FatRat.new(1,1) * 2 ** -128)
FatRat.new(1, 2 ** 128)     # same thing
 

副詞のフォームの Any は関数として使われるかもしれない：

:2($x)      # "bin2num"
:8($x)      # "oct2num"
:10($x)     # "dec2num"
:16($x)     # "hex2num"
 

これらをデフォルト底をセットすること、それを強制しないことであると考えろ。 Perl 5 の老人のようにoct() 関数、これらの何でも異なった底目標に始まって数を認識して、そして他の底に変わるだろう。 しかしながら、それに注意する:16() 関数が先行して解釈するであろう変換器0b あるいは0d 底スイッチャではなく、 16進数字として。

文字列じゃない何もでの関数形式の使用がユーザが数を数の原文の表示と混同したと説明している例外をスローするだろう。 これはエラーのためにそんなものを捕えるはずである as a :8(777) それはそうであるべきだった:8<777>あるいはバックしている関数を番号から原文の表示を作り出すために使う努力。

有理数リテラルが、スラッシュで2つの整数リテラル（何ででも底）を分離して、そして全体を角度に同封することによって、示される：

<1/2>       # one half literal Rat
 

空白文字ではないがスラッシュのどちらかかの側を乗せた、あるいはそれは標準のクォート - 単語意味規則の下で分割されるだろう：

< 1 / 2 >   # ('1', '/', '2')
< 1/2 >     # okay, same as <1/2>
 

不変の折り畳めることのために、あなたはしばしば角度を書き（言い）落としておいてその難を逃れるかもしれない：

1/2         # 1 divided by 2
 

しかしながら、このような場合あなたは優先順位と結合性に注意を払わなければならない。 次のことが3乗しない2/3：

2/3**3      # 2/(3**3), not (2/3)**3
 

「e」表記法を使わない10進法の分数が同じくリテラルであるとして扱われるRat 値：

6.02e23.WHAT     # Num
1.23456.WHAT     # Rat
0.11 == 11/100   # True
 

複合したリテラルが、角の中に2実数数について（再び、演算子の周りにスペースなしで）付加あるいは減法を書くことによって、同様に示される：

<5.2+1e42i>
< -3-1i >
 

有理数リテラルと同じように、不変の折り畳めることは同じ複素数を作り出すだろう、しかしこの形式は、周囲の優先順位を無視して、一つの項として解析をする。

（これらが実際に特別な構文的なフォームじゃないとは、注意しろ：有理数と複雑なリテラルのフォーム両方が当然意味のルールから下記の qw クォートがなくなる。）

Blob リテラルは底マーカーで整数リテラルに類似しているように見える、しかし角度の代わりにカーリーを使え：

:2{0010_1110_1000_10}   a blob1, base 2, 1 bit per column
:4{}                    a blob2, 2 bits per column
:8{5235 0437 6}         a blob3, 3 bits per column
:16{A705E}              a blob4, 4 bits per column
 

空白文字とアンダースコアが許されて、しかし無視される。

索引作成済みが16進数によってそれと一緒開始することによって文字列の中に補間挿入されることができる文字"\x"いずれかまでにそのままの16進数の後に続いた（"\x263a"）あるいは角カッコでの16進数（"\x[263a]"）. 同様に、"\o12" そして"\o[12]" 8進数を補間挿入しろ － けれども一般にあなたは Unicode の世界中の16進法を使っているべきだ。 多数の文字が、カンマで数を分離することによって、かっこでくくられたフォームの何の中ででも指定されるかもしれない："\x[41,42,43]". 　あなたは、文字がそれらとして底で数値のように見えると思う多くが指定した（とき・から・につれて・ように）、 unbracketedなフォームのすべてが食べるから、もし unbracketedな形態があまりに多くの文字を「食べる」であろうなら、あいまいさを排除するべきかっこでくくられた書式を使わなくちゃならない。 これらの表記法のいずれも標準の Perl コード化で働かない。 書き入れと正規表現、などでだけのそれらの仕事。

括弧の内側が展開式じゃなく、そして、それが二重の補間であろうときから、あなたがそこ（に・で）補間挿入されないかもしれないとは、注意しろ。 カーリーを展開式の値を補間挿入するために使え。

古いもの\123 現状のままで、形式が今非合法である\0123 できろ。 それ以外の何ものでもなく\0 残留する、そして次にただもし範囲での次の文字ではないであるなら'0'..'7'. 　8進法の文字が使わなくちゃならない\o 表記法。 通り過ぎて同じく backreferences がもう表されないことに注意を払え\1 そして同種のもの － S05 を見ろ。

qw/foo bar/ クォート演算子が今かっこでくくられた書式を持っている：<foo bar>. 　それがスライス等価物を実行する添え字として使用されるとき、{'foo','bar'}. 　ほかのところにそれは文字列の括弧で括られたリストと等しい：('foo','bar'). 　括弧が一般にただ優先順位群化のために確保されるから、それらが平らなリストコンテキストでただ自動的に補間挿入される。 そのために

@a = 1, < x y >, 2;
 

同等の値：だ

@a = 1, ('x', 'y'), 2;
 

同じがどちらとしてか：

@a = 1, 'x', 'y', 2;
 

項目コンテキスト、暗黙の集まることに括弧が、それほど、まだそこにある

$a = < a b >;
 

同等の値：だ

$a = ('a', 'b');
 

区画がスカラーに割り当てられるから、 mostly-eagerly はどちらの中へフラットな、そして回されたリストとして評価されるかSeq オブジェクト。 他方、もしあなたが区画をバックスラッシュするなら：

$a = \<a b>;
 

それはそうである同種のもの：

$a = \('a', 'b');
 

そして平らにならないキャプチャオブジェクトとなる）.

バインディングは割り当てと異なっている。 もし、シグネチャーに、バインドされるなら<a b> 区画が促進されるだろうそうすることCapture オブジェクト、けれどももし仮引数にバインドされるなら、それは個別の仮引数の性質に基づいて平らになること / スライスしている判断をするだろう。 すなわち、もしあなたがパスするなら<a b> 引数として、それはシングルとして位置あるいはスライスの商品、わずか2つの素晴らしい品目をバインドするだろう。

けれども括弧 - 書き直し規則の下で、一つの値がまだ一つの値のように振る舞うであろうことに注意を払え。 これらはどうでもよいことだ：

$a = < a >;
$a = ('a');
$a = 'a';
 

すなわち、区画が実際に、括弧によってではなく、コンマによって作成される。 一つの値に商品コンテキストでの複合オブジェクトになることを強いるために、括弧の中にコンマを加えるか、あるいは、正当性と同様、明快さのために適切なコンストラクタあるいは生成するものを使え：

$a = (< a >,);
$a = ('a',);
$a = Seq.new('a');
$a = ['a'];
 

何のためにでも数であるように思われるリストでの商品、リテラルの（人たち・もの）が文字列と数の特性両方でオブジェクトとして記憶される、そしてそこで文字列特性は常にオリジナルの文字列を返す。 それは商品がオリジナルの文字列値の中に入り混ざっている適切な数の型に変換されるかのようにだ。 従って：

< 1 1/2 6.02e23 1+2i >
 

オブジェクトのように生産する：

'1' but 1              # Int < Str
'1/2' but 1/2          # Rat < Str
'6.02e23' but 6.02e23  # Num < Str
'1+2i' but 1+2i        # Complex < Str
 

これの目的は、ユーザが数のリストを表す最も読み取り可能な方法としてアングル表記法の方を好むとき、マルチメソッドのディスパッチのコンパイル時分析を促進することだろう、そしてそれはしばしばそうだ。 ミキシン意味規則、得られた数字型のためにプリファランスで獲得されるから文字列型、けれども文字列型は常に利用可能だ、なぜならマッチしているない場合数値的型がマッチするから。 （もし数を文字列として取り扱うことが同一の値を作り出すであろうなら、文字列値は維持される必要がない。） この振る舞いは特例じゃない；それは、ユーザがどこにあるかという状況が、それらが本当に他の種類の値を意味するとき、テキストに入ることを強いた何からでも来るテキストを解析することによって、実際は型情報を理解することについてのいっそう一般的なプロセスの例だ。

値が数のリテラルの形式としてそんなものを果たすシングルを持っている形式Rat そしてComplex それはさもなければ作成されなければならないだろう。 それは同じく視覚的に何でも隔離する合理的な方法で我々に一つの構文ユニットとしての周知のリテラルの構成を与える：

<-1+2i>.polar
(-1+2i).polar       # same, but only by constant folding
 

変化したケース<> ありそうな努力として今書かれる Perl 5 の；スタイルで IO をすることを認められないlines().（<STDIN> 同じく認められない。） リストが一緒にもっと良く書かれる Empty () あるいはNil 何ででも場合から<> しばしば意味と誤読されるだろう(''). 　（同じく添え字形式%foo<> 書かれるべきだ%foo{} から読み間違いを避けろ@foo{''}.） もしあなたが本当に形式上の理由でアングル形式を欲するなら、あなたは、内部にスペースを置くことによって、錯誤を隠すことができる：< >.

関連とほとんど同じように一つのクォートとダブルクォートの間に、ダブル角がそうする間に、一つの角度が補間挿入されない。 二重の角度は、フランスのクォートで、同様書かれるかもしれない«$foo @bar[]»あるいは「Texas」クォート、で<<$foo @bar[]>>ASCIIの回避策として。 暗黙の分裂は補間の後にされる、しかし、それほど、殻のようなやり方でクォートを尊重するそれ«'$foo' "@bar[]"» 産物に2「単語」同等物のリストを保証される('$foo', "@bar[]"). Pair 表記法は内部に同じく認識されている«...» そしてこのような「言葉」は返されるけれどもPair オブジェクト。

コロンのペア（しかし矢印じゃないペア）が二重の角度の中で識別される。 付加、角が始まるコメントを可能にするダブルで#. 　Perl の普通のコメントがコードするように、これらのコメントは正確に働く。 シェルの場合と異なり、リテラルの何も# 引用されなくちゃならない、それらの前（に・で）空白文字がない（の・もの・人）を平らにしろが、これがもっと来ることに注意を払え、あるいはより低度にただでコロンで対になれ:char<#x263a>コメントがただ二重の角で働くだけだから、シングルヒットを打つな。

あふれ出るであろう上記のリテラルの数、どんなリテラルの数に関してでもポリシーを一般化するRat64 分子で文字列として同じく記憶される。 もしより広い型、そんなものへの自動型変換であるならけれどもFatRat求められる、全部のオリジナルの文字列からのリテラルの再コンバート、ただよりむしろそれがフィットするであろう値Rat64. 　（それはもちろん、次回のために、それからその変換された値をキャッシュするかもしれない。） もしあなたがそれが自動的にならない精度が高い、過剰を持っている定数を宣言するならそうFatRatそれは pessimal の中にすべての計算を強制するだろうFatRat 型。

constant pi is export = 3.14159_26535_89793_23846_26433_83279_50288;
say pi.perl;   # 3141592653589793238/1000000000000000000 (Rat64)
say pi.Num     # 3.14159265358979
say pi.Str;    # 3.14159_26535_89793_23846_26433_83279_50288
say pi.FatRat; # 3.14159265358979323846264338327950288
 

この場合角を同質異形を受けとるために近くにいるようにすることは必要じゃない。 ただ精度を超えのRat64 振る舞いを引き起こすのに十分だ（しかしリテラルだけのためだ）。

今一般化された副詞の形の Pair 表記法がある。 次の表は「fatarrow」表記法に連絡を示す：

Fat arrow           Adverbial pair  Paren form
=========           ==============  ==========
a => True           :a
a => False          :!a
a => 0              :a(0)
a => $x             :a($x)
a => 'foo'          :a<foo>         :a(<foo>)
a => <foo bar>      :a<foo bar>     :a(<foo bar>)
a => «$foo @bar»    :a«$foo @bar»   :a(«$foo @bar»)
a => {...}          :a{...}         :a({...})
a => [...]          :a[...]         :a([...])
a => $a             :$a
a => @a             :@a
a => %a             :%a
a => &a             :&a
a => $$a            :$$a
a => @$$a           :@$$a (etc.)
a => %foo<a>        %foo<a>:p
 

fatarrow 構造はただ、それが見なしたから、項が期待されるところ（に・で）だけ使われるかもしれない、それ自身の権利での展開式が、 fatarrow からそれ自身、（左に識別子を自動的に引用するときでさえ）、標準のインフィックス演算子と解析される。 左側が一般的な展開式であるから、 fatarrow フォームはキーとして Pair を何ででも値に列するために使われるかもしれない。 他方、同じぐらい上に生成に慣れているとき、Pair オブジェクト、副詞のフォームはキーとして識別子の使用に制限される。 あなたは生成するべき fatarrow 形を使わなくちゃならないPair キーが識別子じゃないところ。

その制限にもかかわらず、他のものがコロンとその括弧を隔てることは可能だ；しかしながら、可能な非識別子の副詞のキーのすべてが特別な統語論的なフォームに限られる。 Perl 6 は現在10進数とヌルキーを識別する。 次の表で第1と第2の縦列は同じことを意味しない：

Simple pair         DIFFERS from    which means
===========         ============    ===========
2 => <101010>       :2<101010>      radix literal 0b101010
8 => <123>          :8<123>         radix literal 0o123
16 => <deadbeef>    :16<deadbeef>   radix literal 0xdeadbeef
16 => $somevalue    :16($somevalue) radix conversion function
'' => $x            :($x)           signature literal
'' => ($x,$y)       :($x,$y)        signature literal
'' => <x>           :<x>            name extension
'' => «x»           :«x»            name extension
'' => [$x,$y]       :[$x,$y]        name extension
'' => { .say }      :{ .say }       adverbial block (not allowed on names)
 

副詞のフォームのすべて（正常のものを含めて識別子のキーで）が特別なトークンだと見なされて、そして項ポジションのほかに種々のポジションで認識される。 特に、インフィックスが期待されたそれらであろうところ（に・で）使われるとき、（S03 参照）優先順位で「ゆるく単項である」よりもっときつい前の最高の演算子を修正しろ：

1 == 100 :fuzz(3)     # calls: infix:<==>(1, 100, fuzz => 3)
 

副詞の書式が慣れている宣言の中で、仮引数宣言を改名しろ：

sub foo ( :externalname($myname) ) {...}
 

副詞が種々の引用フォームの意味を修飾する：

q:x 'cat /etc/passwd'
 

（すなわち、接尾辞ポジションで）識別子に添えられるとき、副詞の構文はその識別子のユニークな変形を生み出すために使われる；この構文はネーミングの演算子のためにそんなものを使用されるinfix:<+> そして文法的なディスパッチされた － がそんなものを支配する逓倍statement_control:if. 　それほど使われるとき、副詞は、それほど、名前の整数部分だと見なされるinfix:<+> そしてinfix:<-> 2つの異なった演算子だ。 同じくprefix:<+> 異なったからinfix:<+>. 　（表記法は同じく別の識別子を容易にアクセス可能なセットにグループ化することについての利益を持っている；これは、例えば、 Perl 6 文法が現在のセットを知っている標準的な（人たち・もの）がどのように演算子を挿入するかだ。）

ただ1つ以上の値（なるべく文字列）のリストを生産する識別子だけが a name 拡張を許される；特に、クロージャが、それほど、値として修飾しない:{...} 書式ではないが名前エクステンダとして許した。 特に、これはメソッド名の後にブロック書式を自由にする、それでそれは我々にブロックをメソッド引数と解析することを許す：

@stuff.sort:{ +$_ }.map:{ $_ * 2 }
 

これらはそれが対を使っているように見えるかもしれない、しかしそうすることは本当に同等だ

@stuff.sort: { +$_ }.map: { $_ * 2 }
 

そしてコロンは対を開始しない、しかしメソッドについてどちらかと言えば引数リストを開始している。 （何ででも他の場所、:{...} ヌルキーをクロージャにマップして1対と思われるだろう。）

fatarrow あるいは副詞のペア表記法が関数あるいはメソッドに項として引数と命名されてパスするために使われるかもしれない。 括弧で括られた引数と一緒の呼び出し、ただ副詞の構文だけがパスするために使われるかもしれなかった後追加の引数。 これは典型的に超過のブロックパスするために使われる：

find($directory) :{ when not /^\./ }
 

副詞のブロックがそうであるから、これはそれが「演算子を見いだせ」を修正するように演算子ポジションで、ただ前のルールから当然落ちるだけだ。 （括弧が演算子だと見なされない。）

（いつものように）それに注意する{...} （識別子ベースであるか、あるいは特別な）形式がクロージャあるいはコンテンツで依存しているハッシュを示すことができる。 それは、それ以来、添え字を示さない:key{} 本当は匹敵するものはそうするはずだkey = ｛｝ ＞ と矯正ブレースはまったく接尾辞として性質を有していない. （もし、しかしながら、それが選択するなら、それがパスされる関数は値を添え字として使用することができる。）

同じくそれに注意する<a b> 形式は添え字じゃなくて、そしてそのためにそうしないための匹敵するものだ.{'a','b'} けれどもそれよりもむしろ、そうするために('a','b'). 　そのままだ<a> 中に変わる('a') よりむしろ('a',). 　（しかしながら、他のかっこでくくられたフォームと同じように、値はコンテキストに依存している添え字として使われることになるかもしれない。）

2かそれ以上の副詞が常にどこでもじゃましている句読法なしで一緒に張られることができる、一つの副詞が受容できる。 引数で名指された引数として使用されるとき、リスト、あなたは、中間で、カンマを置くかもしれないなぜならそれらペアが同じように働かせるであろう関数と fatarrow にただ普通の名指された引数である. しかしながら、最初のペアが項が期待されるところ（に・で）起こるときだけ、このコンマは許される。 2項演算子が期待されるところで、副詞は括弧の中で隠れられないで、そうな最も近くの前の演算子を修正するとして、常にとられる、そしてもしあなたが一緒に複数を張るなら、そんなものが対になる、あなたはそれが次のペアを項のように見えさせるであろうときからの中間のコンマを置いてはならない。 （まったく交換台に入ることを許された fatarrow 書式ではない） 副詞の使用のために S06 を名指された引数として見る。

否定された形式（:!a）そして sigiledなフォーム（:$a:@a:%a）決して引数をとらなくて、そして次の文字が何であるか気にする. それらは見なされたコンプリートだ。 これらのフォームは識別子にキーの役をするように要求する。

数の引数をとる識別子のために、それは、例えば、略して書くことを許される:sweet(16) そうするために:16sweet. 　（これは識別可能だから：16 ＜ deadbeef ＞ 決して数の後にアルファベット順の文字を持っていないフォーム。） ただリテラルの10進数だけがこのように交換されるかもしれない。

他のフォームが副詞の（そのままの（人たち・もの）を含めて:a 形式）常に即刻のかっこでくくられた引数を探して、そしてそれを音を立てて飲むだろう. もしそれが意図的じゃないなら、あなたは副詞と括弧開始の間に空白文字を使わなくちゃならない。 個別の副詞の構文は Perl 6 にどこでも同じだ。 引数が欲せられるかどうかに基づいて行なわれた例外がない。 （もし望ましいなら、括弧に置かれなくちゃならない、演算子をかっこでくくってただ括弧だけをそれらとして受け入れて、そして他の括弧を無視するクォートと正規表現副詞のためにマイナーな例外がある。 上の表で「括弧形式」を見ろ。）

上に指摘されているとして以外に、パーサは常に括弧を探す。 真の添え字、括弧が同様に接尾辞と解析されることを示さなかったにもかかわらず、演算子。 後置として括弧は（彼・それ）らのイニシャルから分離されるかもしれない:foo unspace あるいはドットで（あるいは共に）、けれども他の何も。

構文にかかわらず、（項あるいはインフィックスポジションで）名指された引数として使用された副詞が一般に任意の名指されたパラメータとして問題の関数に現われる － たとえ関数が演算子あるいはマクロであるとしても。 問題の関数は知りも、そしてオリジナルの構文がどれぐらい気味が悪かったか気にしもしない。

加えるにそうするためにq そしてqqそこ（に・で）今卑しい形式だQ そうするために明示的に修正されないなら、それは補間をしない。 それでq 賛成で本当に短いQ:q そしてqq 賛成で短いQ:qq. 　実際、クォートのようなフォームが生じるすべてQ 副詞で：

q//         Q :q //
qq//        Q :qq //
rx//        Q :regex //
s///        Q :subst ///
tr///       Q :trans ///
 

副詞のよう:regex 異なったパーサに切り替えることによって、言語を解析されるように変えろ。 これは完全にそれ自身、引用された資料と同様、次の副詞で何の翻訳でも変えることができる。

q:s//       Q :q :scalar //
rx:s//      Q :regex :sigspace //
 

一般化されたクォートが今副詞をとるかもしれない：

Short       Long            Meaning
=====       ====            =======
:x          :exec           Execute as command and return results
:w          :words          Split result on words (no quote protection)
:ww         :quotewords     Split result on words (with quote protection)
:v          :val            Evaluate word or words for value literals
:q          :single         Interpolate \\, \q and \' (or whatever)
:qq         :double         Interpolate with :s, :a, :h, :f, :c, :b
:s          :scalar         Interpolate $ vars
:a          :array          Interpolate @ vars
:h          :hash           Interpolate % vars
:f          :function       Interpolate & calls
:c          :closure        Interpolate {...} expressions
:b          :backslash      Interpolate \n, \t, etc. (implies :q at least)
:to         :heredoc        Parse result as heredoc terminator
            :regex          Parse as regex
            :subst          Parse as substitution
            :trans          Parse as transliteration
            :code           Quasiquoting
:p          :path           Return a Path object (see S16 for more options)
 

あなたは、イニシャルに加わることによって、最初のコロンを除いてもよいQqあるいはqq フォームが好きである生産する一つの短縮フォーム副詞で：

qw /a b c/;                         # P5-esque qw// meaning q:w
Qc '...{$x}...';                    # Q:c//, interpolate only closures
qqx/$cmd @args[]/                   # equivalent to P5's qx//
 

（それに注意しろqx// 補間挿入されない。）

もしあなたがさらに略して書くことを望むなら、ただマクロを定義しろ：

macro qx { 'qq:x ' }          # equivalent to P5's qx//
macro qTO { 'qq:x:w:to ' }    # qq:x:w:to//
macro quote:<❰ ❱> ($text) { quasi { {{{$text}}}.quoteharder } }
 

すべての大文字の副詞はユーザー定義のクォートに限られる。 Latin - 1の上のすべての Unicode 区切り文字はユーザー定義のクォートのために確保される。

上の（人たち・もの）の結果は我々が今言うことができるということだ：

%hash = qw:c/a b c d {@array} {%hash}/;
 

あるいは

%hash = qq:w/a b c d {@array} {%hash}/;
 

項目を補間挿入すること中にqw. 　好都合に、配列とハッシュがデフォルトまでにただ空白文字セパレータだけと一緒に補間挿入される、それで空白文字の上の次の分裂はまだうまくいく。 （しかし組込み«...» quoter が自動的に補間同等物をそうするためにするqq:ww:v/.../. 　組込み<...> 匹敵するものはそうするはずだq:w:v/.../.）

:v/ :val 修飾子が完全にそれぞれの単語を走らせるval() 現在のスラングによってリテラルを定義されているとして認知しようと試みるであろう関数。 ただ数と列挙型のような純粋なリテラルだけがそれほど認識されている；他のすべての言葉が文字列として残される。 何ででもケース、文字列のような直感で知られた値の使用が先行する何もあるいは後続する空白文字を含めてオリジナルの文字列を再現するだろう：

say +val(' +2/4 ')   # '0.5'
say ~val(' +2/4 ')   # ' +2/4 '
 

もちろん、言葉によって得られたから:w そして:ww 離れて上にそれが言葉がそうであるものであるときからの空白文字が分割した何も持たないだろう。

空白文字が「q」とその副詞の間に許される：q :w /.../.

これらの「q」フォームのために区切り文字の選出は意味規則に影響を与えない。 すなわち、''""<>«»``()[]そして{} いつ使われた特別でない有効係数を持て// 区切り文字として。 冒頭の区切り文字の前に空白文字があるかもしれない。 （それは括弧のために義務的だからq() サブルーチン呼出しであるそしてq:w(0) 引数と一緒の副詞だ）. 他の括弧が同じくそれらが何かで副詞に引数と解釈されるであろう空白文字が好むことを要求するかもしれないq:z<foo>//. 　それが、何がそれの前（に・で）あるかにかかわらず、もう1つの副詞を意味するために常にとられるだろうから、コロンが決して区切り文字として使用されないかもしれない。 また、そうしないかもしれない# それが常に空白文字と考えられるから（特に、コメントとして）、文字が区切り文字として使用される。 あなたは区切り文字のために空白文字あるいは英数字を使ってはならない。

新しい引用構造がマクロとして宣言されるかもしれない：

macro quote:<qX> (*%adverbs) {...}
 

注意しろ：もし副詞が解析結果に含められるなら、マクロ副詞がマクロ呼出し時間に自動的に評価される。 もし副詞が、それから、明示的な名指された仮引数がへ仮引数としてパスされるかもしれないマクロの引用されたテキストを解析することに影響を与える必要があるならis parsed サブルール、あるいはどのサブルールに訴えるべきか選択するために使われた。

あなたは一つの引用文字列の使用方法の中にダブル - quotish テキストを間にはさむかもしれない\qq[...] 構造。 他の「q」フォームが、同じくユーザー定義のもの、それらで始まる項目「q」と同じぐらい長くを含めて、機能する。 さもなければあなたはただ内部にあなたの構造を埋め込まなければならないだろう\qq[...].

そのままのスカラー変数は常にダブル - quotish 文字列で補間挿入される。 そのままの配列、ハッシュとサブルーチン変数が決して補間挿入されないかもしれない。 しかしながら、スカラー何も、配列、ハッシュ、あるいは補間がもしそれが1つ以上の列によって後に続かれるなら dereferencers ：すなわち、何でもかっこでくくった変数が始動させるかもしれないサブルーチン：

1．配列添え字

2．ハッシュ添え字

3．関数呼び出しを示している括弧のセット

4．それらドット形式の1から3までの Any

5．引数括弧を含むメソッド呼び出し

6．1つ以上の unparenthesizedなメソッドの列　完全に1の何によってでも後に続かれた呼び出し　5

言い換えれば、これは正当だ：

"Val = $a.ord.fmt('%x')\n"
 

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

"Val = { $a.ord.fmt('%x') }\n"
 

しかしながら、補間挿入された接尾辞がバックスラッシュで始まらないかもしれない、それでどんなバックスラッシュあるいは unspace ではないでも認知した、しかしその代わりに補間の外の文字列の一部で、そしてそのクォートコンテキストの標準のバックスラッシュしているルールの適用を受けると考えられるだろう：

my $a = 42;
"Val = $a\[junk\]";  # Val = 42[junk]
"Val = $a\[junk]";   # Val = 42[junk]
"Val = $a\ [junk]";  # Val = 42 [junk]
"Val = $a\.[junk]";  # Val = 42.[junk]



 

配列全体を補間挿入するために、それは空の括弧で添え字に今必要だ：

print "The answers are @foo[]\n"
 

これがスプリアスを直すとは、注意する「@」ダブルを見積もられた電子メールアドレスの問題.

Perl 5 配列補間と同じように、要素はスペースによって分離される。 （それ以外、もし要素がすでに何らかの種類の空白文字に終わるなら、スペースではないが付け加えた。 特に、ペアのリストが二人の後にキーと値と改行の間にタブで補間挿入されるだろう。）

ハッシュ全体を補間挿入するために、それは空のブレースあるいはアングルで添え字に必要だ：

print "The associations are:\n%bar{}"
print "The associations are:\n%bar<>"
 

これがスプリアスを避けるとは、注意する「%」二重に引用された printf フォーマットの問題.

デフォルトまでに、キーと値が分離される、タブによって文字と対が改行によって終了させられる。 （これはほとんど決してあなたが欲するものじゃない、しかしもしあなたが何かが磨かれるのを望むなら、あなたはいっそう特定であり得る。）

sub 呼び出しの結果を補間挿入するために、シギルと括弧両方を含むことは必要だ：

print "The results are &baz().\n"
 

メソッドの結果を補間挿入するために、引数なしで呼び出せ、括弧を含むか、あるいは、何かが括弧に終わるという状態で、呼び出しを延長することは必要だ：

print "The attribute is $obj.attr().\n"
print "The attribute is $obj.attr<Jan>.\n"
 

メソッドは商品コンテキストで呼び出される。 （もしそれがリストを返すなら、その傾きは、それが配列であるかのように、補間挿入される。）

それは最後の1つの後方一致括弧の長さの引数のないメソッドのカスケードを持っていることを許される：

print "The attribute is %obj.keys.sort.reverse().\n"
 

（カスケードは基本的に、エンドブランケット規則のために一つのメソッド呼び出しとして勘定に入れられる。）

それぞれが何らかの種類の括弧に終わるか、あるいはそのままのメソッドである限り、多数の dereferencers は積み上げられているかもしれない：

print "The attribute is @baz[3](1, 2, 3).gethash.{$xyz}<blurfl>.attr().\n"
 

それが一括された dereferencer を開始しないから、展開式の一部と思われたではないの上にそれほど最終ピリオド的に注意しろ。 括弧は上に必要とされない.gethashそれら以外上に必要とされる.attr()、それから補間全体を終了させる。

決して空白文字あるいは unspace までにトップレベルのコンポーネントの何分離されないかもしれない。 （けれども、これらは中にのような、構造をかっこでくくっている何の中にでも許される(1, 2, 3) 上に。）

そのままのクロージャが同じくダブル - quotish コンテキストで補間挿入される。 それは何によっても後に続かれないかもしれない、 dereferencers が、あなたから常にそれらをクロージャの中に置くことができる。 展開式内側は文字列商品コンテキストで評価される。 権限：勢力がコンテキストを展開式使用方法にリストするlist もし必要なら演算子。 文字列でのクロージャがそれ自身のレキシカルスコープを確立する。 （カーリーなしで、そんなものをこっそり持ち込む展開式けれども$(...)（彼・それ）ら自身のレキシカルスコープを確立しない、しかし外のスコープを使って、そして、（eval にない）内部のすべてのコード化がコンパイルにおいて見られるから、外のスコープで変数を宣言しさえするかもしれない時間。）

次のことが前の例と同じものを意味する。

print "The attribute is { @baz[3](1,2,3).gethash.{$xyz}<blurfl>.attr }.\n"
 

我々がカーリーで「実数」コード化を提供しているから、最終の括弧は不必要だ。 もしあなたがカーリーを補間挿入しない二重のクォートを持っている必要があるなら、あなたは明示的に機能を取り去ることができる：

qq:c(0) "Here are { $two uninterpolated } curlies";
 

あるいは等しく：

qq:!c "Here are { $two uninterpolated } curlies";
 

代わる代わる、あなたは正確に教える一つのクォートから上がっている能力にそれを作ることができる、あなたがすることは補間挿入されることを望む：

q:s 'Here are { $two uninterpolated } curlies';
 

主要なシギルが補間挿入されるかどうかに関して、第二のシギル（twigils）が影響を持っていない。 すなわち、もし$a 補間挿入される、それでしろ$^a$*a$=a$?a$.aなど. それはただ上に依存する$.

他のどのような展開式も補間挿入されない。 カーリーを使え。

クラスメソッドが直接補間挿入されないかもしれない。 カーリーを使え：

print "The dog bark is {Dog.bark}.\n"
 

古い曖昧性除去構文：

${foo[$bar]}
${foo}[$bar]
 

死んでいる。 その代わりにクロージャカーリーを使え：

{$foo[$bar]}
{$foo}[$bar]
 

（あなたはここで傾向を検出しているかもしれない．．．）

話題のメソッドを補間挿入するために、カーリーを使え："{.bark}".

シギルなしで関数呼び出しを補間挿入するために、カーリーを使え："{abs $var}".

バックスラッシュの連続がまだ補間挿入される、しかしもう何もない\v それが何であるとしても、垂直タブを意味するために。 （\v 今が正規表現で垂直の空白文字とマッチする。） リテラルの文字主張がそうだ：

\a          BELL
\b          BACKSPACE
\t          TAB
\n          LINE FEED
\f          FORM FEED
\r          CARRIAGE RETURN
\e          ESCAPE
 

同じくもう何もない\L\U\l\uあるいは\Q. 　その代わりに適切な関数でカーリーを使え："{ucfirst $word}".

あなたは名前使用方法によってどんな Unicode 符号位置でも補間挿入してもよい\c そして括弧をまっすぐにしろ：

"\c[NEGATED DOUBLE VERTICAL BAR DOUBLE RIGHT TURNSTILE]"
 

一つの文字を構成している多数の符号位置がシングルで間にはさまれるかもしれない\c カンマで名前を分離することによって：

"\c[LATIN CAPITAL LETTER A, COMBINING RING ABOVE]"
 

1つか2つの文字が Unicode で依存する（とき・から・につれて・ように）、それが見つめられるかどうかが現在のレキシカルスコープのレベルをサポートする。 一つの文字に確認しない多数の符号位置を補間挿入することは同じく可能だ：

"\c[LATIN CAPITAL LETTER A, LATIN CAPITAL LETTER B]"
 

［注意しろ：公式の Unicode 文字名のいずれもカンマを含まない。］

あなたは正方形の括弧の中に同じく1つ以上の10進数を置いてもよい：

"\c[13,10]" # CRLF
 

Any シングル10進数が括弧を除くかもしれない：

"\c8" # backspace
 

（あなたが同じく使うかもしれない正規表現の中で\C 存在する文字とマッチするために、指定された文字じゃない。）

もし文字下記であるなら\c あるいは\C 64ビットの XOR をとることについてのいつものトリックによってコントロール文字の中に左大括弧と10進数数値のいずれも、シングルが文字の後に続くという状態で、回されないということだ。 これは許す\c@ NULのためにそして\c? なぜならデリートしろ、しかし ESCAPE 文字がそのように表されないかもしれない；何かが好むことは表されなくちゃならないことに注意を払え：

\e
\c[ESCAPE]
\c27
\x1B
\o33
 

明らかに\e 短さが必要とされるとき、好まれる。

現在のクォートコンテキストで補間を始めるであろう Any 文字がバックスラッシュでプレフィックス変換によってこのような補間から守られるかもしれない。 バックスラッシュは常にこの場合取り除かれる。

補間を開始しなかったであろうバックスラッシュされた文字の取り扱いはクォートの型に依存して変化する：

1。

Any がそれが含む形式を引用するqq あるいは:qq その意味の微分で（標準のダブルを含めてクォート形式）がすべてのバックスラッシュが意味を持つと見なされるはずであると想定する。 次の文字が英数字かどうかについて、意味は依存する；もしそれがそうであるなら、非補間列はコンパイル時錯誤を作り出す。 もし文字が英数字じゃないなら、バックスラッシュは、文字列が使ってバックスラッシュされた前提条件に関して、静かに取り除かれるquotemeta() あるいは何かそのようなもの。

2。

他のすべての引用フォームが、それらが結果までずっとパスするためにおそらく意図的であるから、（標準的な一つのクォートを含めて）非補間の連続が変わらないままにしておかれるはずであると想定する。 バックスラッシュがただ終えているクォートのためにあるいは、もし unbackslashedであるなら、補間挿入されるであろう文字のために取り除かれる。 （どちらの場合も、特別な例外が括弧のために作られる；もし左であるなら、括弧が補間挿入されるだろう、右の括弧はオプションとして同じくバックスラッシュされるかもしれない、そしてもしそうであるなら、バックスラッシュは取り除かれるだろう。 もし括弧が、共に左と右に、区切り文字として使用されるならmust それらがさもなければ括弧総数で間違っていると考えられるであろうときから、同じようにバックスラッシュされろ。）

結果として、これらはすべて同じリテラルの文字列を作り出す：

" \{ this is not a closure } "
" \{ this is not a closure \} "
q:c / \{ this is not a closure } /
q:c / \{ this is not a closure \} /
q:c { \{ this is not a closure \} }
q { { this is not a closure } }
q { \{ this is not a closure \} }
 

（もちろん、マッチしているバックスラッシュがアルゴリズムを計算に入れて、少しもっと幸せな、何ででも進んだあなたの構文 highlighter を他の世間知らずの括弧にするためにありそうだ．．．）

Perl 6 に barewords がない。 宣言されていないそのままの識別子がサブルーチン名を意味するために常にとられるだろう。 （クラス名声（そして他のタイプ名）が前もって申告されるか、あるいは前接続されるで:: あなたが新しいのを申告している型シギル。） これの結果がもう何もないということだ「use strict 'subs'」. メソッド呼び出しのための構文が sub 呼び出しから区別されるから、特別に扱われなくちゃならないのはただ認められない sub 呼び出しに過ぎない。

あなたはまだあなたのサブルーチンを宣言しなくちゃならない、しかし認められない名前を持っている bareword がサブルーチン呼出し、このような宣言が終わりまでに起こるであろうその前提条件に関して現在のコンパイル単位として臨時にコンパイルされる：

foo;         # provisional call if neither &foo nor ::foo is defined so far
foo();       # provisional call if &foo is not defined so far
foo($x);     # provisional call if &foo is not defined so far
foo($x, $y); # provisional call if &foo is not defined so far

$x.foo;      # not a provisional call; it's a method call on $x
foo $x:;     # not a provisional call; it's a method call on $x
foo $x: $y;  # not a provisional call; it's a method call on $x
 

もしコンパイルが失敗する見られた postdeclaration ではないCHECK 時間。 （あなたはまだもちろん、明示的に、サブルーチンを前もって宣言することが自由だ。） もし宣言が暫定的な呼び出しの後によりむしろ前に起こっていたなら、 postdeclaration は何ででも語彙であるか、あるいは宣言を暫定的な呼び出しに見えさせることがあり得たはずである範囲をパッケージするかもしれない。

この fixup はただ暫定的な呼び出しの間される。 もし何かがあるなら、実数 predeclaration visible 、常にそれは優先順位をとる。 多数の不確かな postdeclarations の場合に、それらがすべて multis に違いないか、あるいはコンパイル時錯誤が宣言される、そして、たとえ1つの postdeclaration が明らかに「閉じ」であるとしても、あなたが前もって宣言しなくちゃならないかのどちらかだ。 A single proto predeclaration がすべてを postdeclaredにするかもしれないmulti それが実行時ディスパッチであり、そしてすべての multis が時までに効果的に目に見えるから、うまく機能するdispatch「s対象リストが生成される。

暫定的な呼び出しとしての bareword 関数を解析することは常にリスト演算子が扱われる同じ方法でされる。 もし postdeclaration がそれと一致しないために構文を曲げるなら、それは首尾一貫しないシグネチャー多様性の錯誤だ。

もし認められないサブルーチン名が通り過ぎて後に続かれるならpostcircumfix:<( )>それ括弧で括られたフォームの暫定的な関数呼び出しとしてコンパイルされる. もしそれがそうじゃない、それが暫定的な関数としてコンパイルされるなら引数リストを持つかもしれない、あるいはそうしないかもしれないリスト演算子フォームの呼び出し。 疑わしいとき、努力は引数リストを解析させられる。 何と同じようにも、それがある形式の括弧じゃないなら、リスト演算子、直接の後置演算子が非合法だ、空白文字の後に続く何かが引数として解釈されるであろうのに対して、可能かどうか列挙しろ。

サブルーチン宣言のシグネチャーに基づいて、それほど引数的な4つの方法だけがある、リストが解析されることができる：

Signature           # of expected args
()                  0
($x)                1
($x?)               0..1
(anything else)     0..Inf
 

すなわち、標準サブルーチン呼び出しがただ0 - arg 項（あるいは関数呼び出し）として解析されるかもしれない、1つの － 義務的な － arg が演算子（あるいは関数呼び出し）、1つの － オプション － arg 項あるいは接頭辞演算子（あるいは関数呼び出し）、を前接続する、あるいは「無限の arg」リスト演算子（あるいは関数呼び出し）。 所定のシグネチャーがただ2つの引数を受け入れることだけをするかもしれない、唯一の番号特質以外パーサは無効な、単数形の、そして複数形の；の範囲をすることを可能にされる 供給された引数のその数をチェックすることは、構文的な束縛としてではなく、別個の意味条件として1つがされなくちゃならないより大きいいずれかの数とマッチする。 Perl 関数が決してN引数をリストから取り出さない、そして、Nの小さい値以外、ほかの誰かのために残りを残す、そしてそこでスモールが1以上ではなくと定義される。 権限：がマクロを使ってもっとおしゃれになる、しかしマクロが常に predeclaration を必要とする。 無限のリストにないフォームがマクロとして本質的に振る舞っているから、それらのフォームは同じく predeclaration を必要とする。 ただ無限のリスト形式だけが postdeclared （そして従って臨時に使われる）かもしれない。

このようなコロンから、コロン接尾辞によって後に続かれる呼び出しが間接だけの上に許されることは暫定的なサブルーチンのために非合法だ、オブジェクト、あるいはメソッドがドットでフォームを呼び出す。 （文が期待されるとき、それは同じく名札の上で許される。） どんな宣言されていない識別子のためにでもそう「foo」 :

foo.bar             # ILLEGAL       -- postfix must use foo().bar
foo .bar            # foo($_.bar)   -- no postfix starts with whitespace
foo\ .bar           # ILLEGAL       -- must use foo()\ .bar
foo++               # ILLEGAL       -- postfix must use foo()++
foo 1,2,3           # foo(1,2,3)    -- args always expected after listop
foo + 1             # foo(+1)       -- term always expected after listop
foo;                # foo();        -- no postfix, but no args either
foo:                #   label       -- must be label at statement boundary.
                                    -- ILLEGAL otherwise
foo: bar:           #   two labels in a row, okay
.foo: 1             # $_.foo: 1     -- must be "dot" method with : args
.foo(1)             # $_.foo(1)     -- must be "dot" method with () args
.foo                # $_.foo()      -- must be "dot" method with no args
.$foo: 1            # $_.$foo: 1    -- indirect "dot" method with : args
foo bar: 1          # bar.foo(1)    -- bar must be predecl as class
                                    -- sub bar allowed here only if 0-ary
                                    -- otherwise you must say (bar):
foo bar 1           # foo(bar(1))   -- both subject to postdeclaration
                                    -- never taken as indirect object
foo $bar: 1         # $bar.foo(1)   -- indirect object even if declared sub
                                    -- $bar considered one token
foo (bar()): 1      # bar().foo(1)  -- even if foo declared sub
foo bar():          # ILLEGAL       -- bar() is two tokens.
foo .bar:           # foo(.bar:)    -- colon chooses .bar to listopify
foo bar baz: 1      # foo(baz.bar(1)) -- colon controls "bar", not foo.
foo (bar baz): 1    # bar(baz()).foo(1) -- colon controls "foo"
$foo $bar           # ILLEGAL       -- two terms in a row
$foo $bar:          # ILLEGAL       -- use $bar.$foo for indirection
(foo bar) baz: 1    # ILLEGAL       -- use $baz.$(foo bar) for indirection
 

間接的なオブジェクトコロンはただ今までに「単純な」がクラスと変数と括弧で括られた展開式を含む単純な項を支配する、しかし明示的にメソッドではなくがコールする、コロンが後置にメソッドをバインドするであろうから、プリファランスで呼び出せ。 トークンを1以上と解析する間接的なオブジェクトがコロンによって括弧に置かれて、後に続かれなくちゃならない。

要するに、ただ接尾辞コロンによって後に続かれた単純な項によって後に続かれた識別子だけがそうだever 間接的なオブジェクトと解析されて、それ以外形式がそうするだろうalways 識別子がさもなければ宣言されるかどうかにかかわらず、間接的なオブジェクトと解析されろ。

同じくノーがある「use strict 'refs'」象徴的なデリファレンスが今統語論上硬いデリファレンスから区別されるから. @($arrayref) 今実際の配列オブジェクト、間を供給しなくちゃならない@::($string) 明示的に象徴的な参照だ。 （はい、これは P5 から P6 への翻訳者に適応物を与えるかもしれない、しかし私はコンセプトを分離することはその価値があると思う。 多分象徴的な審判員フォームは切羽詰まれば実数オブジェクトに入ることを許すだろう。）

Perl 6 にハッシュ添え字自（己・動）引用がない。 使用%x<foo> 不変のハッシュ添え字、あるいは例の味方のために%x{'foo'}. 　（それは言うために同じく働く%x«foo» あなたがそれを理解する限りで補間の適用を受ける。）

ただ=> その即刻の左（コメントではなく、水平空白許可）にまだ何にでもそのままの識別子を自動的に引用する。 キーワードあるいはマクロ翻訳さえの適用を受ける識別子ではない。 もしあなたが言うなら

$x = do {
    call_something();
    if => 1;
}
 

それから$x 二人を含んでいることになる("if" => 1). 　常に。 （バージョン番号がそうしなかった Perl 5 に自（己・動）クォートと異なり、）

同じく使用権限：：キーを引用するべきキー（$value）形式選択肢対. 選択肢のペアの値を一列に並べるために、あなたは「unspace」接尾辞フォームを使ってもよい：

:longkey\  ($value)
:shortkey\ <string>
:fookey\   { $^a <=> $^b }
 

これらは解釈されるであろうけれども

:longkey($value)
:shortkey<string>
:fookey{ $^a <=> $^b }
 

ダブル - アンダースコアフォームは消え失せている：

Old                 New
---                 ---
__LINE__            $?LINE
__FILE__            $?FILE
__PACKAGE__         $?PACKAGE
__END__             =begin END
__DATA__            =begin DATA
 

［注意しろ： S26 が進展する（とき・から・につれて・ように）、このパラグラフは不確かで、そして徹底的な変更を必要とする。］ =begin END それが文通することはできないと想定するという点で、 Pod の流れは特別だ=end END ファイル終了の前に。 DATA ストリームがファイルハンドルとしてで、名前をつけられてアクセスされてより長いスペシャルはなし － 現行ファイルの Pod ストリームがそうであり得る何 － でもないけれども%=POD{'DATA'} そしてそんなもの。 Alternately 、あなた容器としてスカラーとして Pod の流れを処理しろ$=DATA あるいは配列としてとして@=DATA. 　モジュールがそのすべての COMMENT ブロックを読むことができた Presumably @=COMMENT例えば。 かなりの Pod が別個の配列として（それに）なるそれぞれで要素。 それを分離するべき権限：があなた自身の内側を覆う。 それぞれのチャンクがそうした.range ソースファイルの中でその行番号レンジを示すプロパティ。

語彙のルーチン自身はそうだ&?ROUTINE；あなた容器その名前を受けとrde&?ROUTINE.name. 　現在ブロックはそうだ&?BLOCK. 　もしブロックがラベル、それらが現われる何でも持っているなら&?BLOCK.labels. 　文のレキシカルスコープの中で名札と共に、名札はその文の動的に目に見える実例を表す擬似オブジェクトだ。 （もしその文の多数のダイナミックな例の中であるなら、名札は一番奥の（の・もの・人）を表す。） これは lexotic 意味規則として知られている。

あなたが言うとき：

next LINE;
 

それはこの擬似オブジェクトに本当はメソッドである、そして

LINE.next;
 

同じぐらいよく働くだろう。 権限：が、言うことによって、名札付きブロック早く何でも出る

MyLabel.leave(@results);
 

Heredocs はもう書かれない<<しかし、他のいかなるクォート構造にでも：副詞にある

print qq:to/END/;
    Give $amount to the man behind curtain number $curtain.
    END
 

同じ展開式の中で多数の heredocs であるように、他の副詞が同じく許される：

print q:c:to/END/, q:to/END/;
    Give $100 to the man behind curtain number {$curtain}.
    END
    Here is a $non-interpolated string
    END
 

Heredocs は前にもそして区切り文字を終了させた後にも共にオプションの空白文字を許す。 区切り文字の字下げと等しい先行する空白文字はすべての前のラインから取り除かれるだろう。 もしラインがターミネータより少ない空白文字を持つとみなされるなら、ただ空白文字だけが取り去られる、そして警告が表示されるかもしれない。 （難しいタブがそうであると考えられるだろう($?TABSTOP // 8) スペース、しかしタブとスペースが首尾一貫して使われる限り、それは重要じゃない。） 空の終了させている区切り文字が空白文字からだけ成り立っている次のラインで終わる、しかしこのようなターミネータは字下げを持っていないと考えられるだろう。 （それはそうだ、とそれが想定したから何の始めのマッチも空白文字。）

heredocs を解析する2つの可能な方法がある。 人は前方に改行を探して、そしてヒアドキュメントに対応しているラインを取って、そして次にオリジナルのラインの残りを解析するはずだ。 これは Perl 5 がどのようにそれをするかだ。 不幸にもこれは、 Perl 5 に改行を隠す方法がないから、いくぶんマスクされるマルチパスパージングの Perl 5 に行き渡っている問題のために苦境に陥る。 しかしながら、 Perl 6 に、我々は「unspace」を改行を見いだすために前途を考えているアルゴリズムが改行の場所を突き止めるために（可能な都合が悪い副作用で）フルの解析をしなくちゃならないことを意味する改行を隠すために使うことができる。

その代わりに、 Perl 6 は1パスアプローチをとって、そしてただいい加減にそれがラインに見いだす heredocs を待ち行列に入れて、そしてそれが「実数」改行を見るまでテキストを探して、そしてそれを適切なヒアドキュメントに取り付けるのを待つ。 このアプローチの悪い面はわずかな制限だ － あなたは、列が解析をし終える前に、走らなくちゃならないコード化でヒアドキュメントの実際のテキストを使ってはならない。 主としてそれはただあなたが書くことができないことを意味する：

BEGIN { say q:to/END/ }
    Say me!
    END
 

あなたその代わりにヒアドキュメント全体をつながれた不可欠BEGIN：

BEGIN {
    say q:to/END/;
    Say me!
    END
}
 

リテラルのバージョンがドットを打たれたフォームでバージョン番号によって後に続かれた「v」で書かれる。 これほど常に構造Version 文字列ではなく、オブジェクト。 ただ整数とある特定のワイルドカードだけが；あなたが文字列を強制しなくちゃならないもっとおしゃれな何のためにでも、許されるVersion：

v1.2.3                      # okay
v1.2.*                      # okay, wildcard version
v1.2.3+                     # okay, wildcard version
v1.2.3beta                  # illegal
Version('1.2.3beta')        # okay
 

注意するしかし、どの言っているケースかについて、 Perl で1バージョン番号を獲得するたいていの場所がそれを名指された引数として受け入れること:ver<1.2.3beta> 素晴らしい。 versionedなモジュールを使うことについて、さらに多くのために S11 を見ろ。

バージョンオブジェクトがバージョン対応についてたいていの人々の直観を追跡する前もって定められたソート順を持っている：それぞれの分類ポジションがポジションで数字の前に、アルファベット順に、アルファと alphabetics の間の数の間に数値的にソートする。 欠けている最終のポジションが「.0」だと考えられる。 「0」自身以外、数が先行するゼロを無視する。 ソートポジションに分かれることに対して、もし何かが alphabetics に（アンダースコアを含めて）すぐに数に隣接しているなら、ドットがそれらの間に仮定される。 同じくどんな英数字でない文字でもドットと等しいと考えられる。 それでこれらはすべて同等だ：

1.2.1alpha1.0
1.2.1alpha1
1.2.1.alpha1
1.2.1alpha.1
1.2.1.alpha.1
1.2-1+alpha/1
 

そしてこれらは同じく同等だ：

1.2.1_01
1.2.1_1
1.2.1._1
1.2.1_1
1.2.1._.1
001.0002.0000000001._.00000000001
1.2.1._.1.0.0.0.0.0
 

それでこれらは分類されたバージョンオーダーにある：

1.2.0.999
1.2.1_01
1.2.1_2
1.2.1_003
1.2.1a1
1.2.1.alpha1
1.2.1b1
1.2.1.beta1
1.2.1.gamma
1.2.1α1
1.2.1β1
1.2.1γ
1.2.1
 

アルファベット順の、そしてそれほどアルファベット順の何かが、 ASCII によればだけじゃなく、 Unicode によれば、定義された後、最後の人がどのようにペアになるかが暗黙.0がソートすると想定することに注意を払え。 このすべての意図は事前リリースがリリースの前にソートすることを確認することだ。 これが実数世界でまだ見られたバージョン対応スキームのサブセットであるとは、同じく注意しろ。 デフォルトまでに Perl が正確なバージョン番号によって外部モジュールを読み込むから、このような奇妙なバージョンを持っているモジュールがまだ Perl によって使われることができる。 （S11 を見ろ。） ただレンジ演算だけが「ガンマ」の後に「デルタ」を分類するシステムのように、未知の外国の校合の命令によって危うくされるだろう。

• Perl はまだ3つの主なコンテキストを持っている：（空間率としても知られる）受信側、（スカラーとしても知られる）商品とリスト。

• 未分化の項目のほかに、我々は同じくこれらの商品コンテキストを持っている：

  Context     Type    OOtype   Operator
  -------     ----    ------   --------
  boolean     bit     Bit      ?
  integer     int     Integral int
  numeric     num     Num      +
  string      buf     Str      ~
   

  特定の種類のコンテナ（スライスとハッシュコンテキストのように；詳細のために S03 を見ろ）を必要とする同じく種々のコンテナコンテキストがある。

• Perl 5 の場合と異なり、オブジェクトがもう常に真であると見なされない。 それはそれらのステートに依存する.Bool あるいは合成の属性であるかもしれないメソッドあるいはオブジェクトで明示的にビットを表す. それら値について真である、そして偽のクラスが決定することができる。 個別のオブジェクトがクラス定義をオーバーライドすることができる：

  return 0 but True;
   

  これほどオーバライド的.Bool メソッドの0 （anonymous によって得られた型の中にメソッドを混ぜることによって）、その公式の型を変えないで。

• 定義の.Bool なぜなら最も先祖の型（すなわちMu 型）匹敵するものはそうするはずだ.defined. 　なぜならオブジェクトがだと見なされる型が未定義、すべての型オブジェクトを（含むMu それ自身）、型が定義をオーバーライドしないなら、偽であrno.Bool 未定義の値を含むために。 インスタンスを作られたオブジェクトデフォルト、からクラスが鮮明度をオーバーライドしないなら真だ。 あなたがインスタンスを作ることができたそのもしに注意するMu それは定義されていて、そしてそれで真であると見なされるだろう。 （しかしながら、これが許されることは明確じゃない。）

• 一般にコンテナ型が、もしそれらであるなら偽で返すべきである何でもさもなければ空で、そして真だ。 これはスカラー以外すべての標準的なコンテナ型について真だ、そしてそれは常にそのコンテンツに真理の定義を延期する。 Perl 5 がそうすると同じように、非コンテナの型が truthiness を定義する。

  標準的な型、ユーザー定義ので型が別個の（人たち・もの）から、もしこのようなパーティションがブールのコンテキストを使って制御流れで意味をなすなら、（彼・それ）らの定義された値を真の、そして偽の値に分割することを遠慮なくするべきであるのとちょうど同じ（ように・時に）.defined もしあなたがそれを必要とするなら、メソッドが常にそこにある。

Perl 6 のリストコンテキストはデフォルトまでにいい加減だ。 これはリストが爆発しないで無限のジェネレーターを含んでいることができることを意味する。 平らになることは、それが呼び出し時間に（そして多分たとえそれでもではなく）関数あるいはメソッドのシグネチャーにバインドされるまで、いい加減なリストに起きない。 我々は、要求次第、しかし前にではなく我々がリストを平らにすることを約束することを意味して、このような引数リストが「いい加減に平らになっている」と言う。

ある「list」その引数の平らなもしにリストコンテキストを課す演算子list それ自身商品コンテキストで起こる。

使用明示的な平らになることを強制することflat contextualizer 。 これは1 - 次元のリストの中に回帰的にすべての区画を平らにする。 素晴らしい仮引数に、キャプチャが残りを平らにする境界であるときその位置の引数。

sub - 区画が使用ツリーノードに変わるように、リストを改革すること.tree メソッド、どちらが本質的にレベル - 重要であるかは、クロージャが再マッピングに供給した（の・もの・人）で、それぞれのレベルでの区画をマップする：

$p.tree(*.Seq)        # force level 1 parcels to Seq
$p.tree(1)            # same thing
$p.tree               # same thing, defaults to 1 level
$p.tree(*.Seq,*.list) # force level 1 parcels to Seq, level 2 to list
$p.tree(*.Seq xx *)   # Turn all subparcels into Seq recursively
$p.tree(*)            # same thing
 

いつがスライス仮引数にバインドされる（示されたで**）、キャプチャ1人と一緒のその位置引数の残りがへ同等の「treeness」について率直に話す改革@args.tree(1)すなわち、リスト、のリストあるいはLoL. 　部分リストは自動的に平らになっていない；すなわち、もし部分リストがそうであるならParcelそれ、次のプロセッシングが部分リストがどれぐらいフラットであるか、あるいは treelike であるべきであるか決めるまで、リストのままでいる.

リストが変えられるインボカントじゃない項目パラメータにバインドされるとき、いい加減Seq オブジェクト、すなわち、要求次第それ自身を拡張することができる配列、がリストのイテレータをその新しい値として使用する。 （いったん決定されると、しかしながら、値は読み取り専用だ。 匿名の変更可能な配列を作るために、リストの周りに明示的な正方形の括弧を使え。）

平らにならない項目コンテキスト、使用を無理に引き出すこと「item」演算子.

| 接頭辞演算子がその引数に「キャプチャ」コンテキストを押し付けて、そして同じく何にでもサブルーチンシグネチャー宣言によって課されて調べているスカラー引数で勝つために使われるかもしれない。 Any の結果として生じているリスト引数がそれから、いい加減に評価される。

使用いい加減でないリスト処理を強制することeager 演算子をリストしろ。 リスト割り当ては同じく暗黙のうちに熱心だ。 （実際に、我々が「熱心であるか？」と言うとき、我々は、通常 S07 で定義されるように、「たいてい熱心だ」を意味する）。

eager $filehandle.lines;    # read all remaining lines
 

それと対照して、

$filehandle.lines;
 

イテレータが何本の前方のラインを読んだかについて、保証をしない。 配列の中で記憶されるときでさえ、リストを入れているイテレータがプロセスにバッチに入ることを許される。 配列はそれが拡張可能であって、そして、それがもっと多くの要素を必要とする（とき・から・につれて・ように）、イテレータを呼び出すことを知っている。 （配列で要素を数えることは同じく熱心な終了に持ち込むだろう。）

平らになるか、あるいは薄く切ることに、この演算子は不可知論だ。 ただ変化だけで値発電機のためのポリシーでリードしている仕事。

変形のeager そうであるhyper 十分生み出されるので、あなたがどんなオーダーそれらか気にしないそれ以外の何ものでもなくではなくあなたがすべての値が今生み出されるのを望む、しかしあなたがひどくそれらを欲すると宣言する演算子をリストしろ。 すなわち、eager リスト、間の連続的な評価を必要とするhyper 要請（けれどもする必要とする）平行した評価. 何でもケースに入れろ、それはあなたが評価順序のことを気にかけないと宣言する。 （推測：ペアの超リストからハッシュに住むことは、若干のキーが前にさえ見られることができるように、結果が入ってくる（とき・から・につれて・ように）、されることができた超される. ここで Map - Reduce アルゴリズムについて考える．．．）

平らになるか、あるいは薄く切ることに、この演算子は不可知論だ。 値発電機のためのポリシーが仕事 - 前方であると、それだけそれはただ変化する。

非マルチ sub の上のシグネチャーがコンパイル時間にチェックされることができるのに対して、マルチ sub とメソッド呼び出しシグネチャーがただランタイムに（特殊命令がないときにはオプティマイザに）チェックされることができるだけだ。

これは配列あるいはハッシュであって、それらからそれらコンテキストのことを気にかけなくてもよい引数のために問題じゃない、しかしただ何でも（彼・それ）ら自身を事象リターンしろ、そしてそれはいい加減に平らになっているかもしれない、あるいはそうしないかもしれない。

しかしながら、メソッドがまだディスパッチされなかったから、関数呼び出しが引数リストで（彼・それ）らの終局のコンテキストを知ることができない、それで我々はどのシグネチャーに対して調べるべきか知らない。 このような帰りの値はいい加減にそのコンテキストを決定するであろうコンテキストに後の配送のために「区画」の中に着込ませられる。

=> 演算子の今の構造Pair ただよりむしろコンマとして作用しているオブジェクト。 両側が商品コンテキストにある。

.. 演算子の今の構造Range ただよりむしろ演算子の役割を果たしているオブジェクト。 両側が商品コンテキストにある。 Semantically, the Range 可能なエクステントにその値のリストのように振る舞うが、 Perl 5 の熱心なレンジ演算子と異なり、いい加減にそうする。

ハッシュリストコンテキストなどというものはない。 ハッシュへの割り当てが普通のリストコンテキストを生産する。 あなたはただ Perl 5 のように入れ替わるキーと値を割り当ててもよい。 あなたは同じくリストを割り当てるかもしれないのPair オブジェクト、それぞれがどちらのケースにペアになるかはキーと値を提供する。 対が来る限り、あなたは、実際、キーが期待されるとき2つのフォームを混ぜてもよい。 もしあなたが用品に望むならPair キーとして、あなたは構成しなくちゃならない外Pair キーがどちらで内部の（人たち・もの）かPair：

%hash = (($keykey => $keyval) => $value);
 

anonymous enum 関数がキーのリストを受けるか、あるいはキーのすでにじゃないカギが分ける何までの値も対にして、そして加える。 加えられた値は前のキーあるいはペアの値より1だけ多くだ。 これはうまく新しい（人たち・もの）で作動するqq:ww 形式：

%hash = enum <<:Mon(1) Tue Wed Thu Fri Sat Sun>>;
%hash = enum « :Mon(1) Tue Wed Thu Fri Sat Sun »;
 

同じであるけれども：

%hash = ();
%hash<Mon Tue Wed Thu Fri Sat Sun> = 1..7;
 

割り当てと対照して、ハッシュへのバインディング必要とするHash （あるいはPair）オブジェクト. バインディングが「しみ」ハッシュに対あるいはハッシュのリストを必要として、そして、それが対あるいはハッシュを使い果たすとき、引数リストを処理するのをやめる。 ずっと仮引数についてのバインディングのために S06 を見ろ。

• ファイル名グロブはアングル括弧でもう終わっていない。 使用glob 関数。

• ファイルハンドルからのインプットはアングル括弧でもう終わっていない。 代わりに

  while (<HANDLE>) {...}
   

  あなたは今書く

  for @$handle {...}
   

  あるいは

  for $handle.lines {...}
   

• S12 で詳述されるように、プロパティが働く。 それら実際はロールミキシンによって提供されるオブジェクト属性である. コンパイル時プロパティがまだ用途をコンテナとそんなものに適用したis キーワード、けれども今「トレイト」と呼び出される。 他方、実行時プロパティが使って個別のオブジェクトに付けられるbut その代わりにキーワード、ただまだ「プロパティ」と呼び出される.

• それらが実際若干のクラスあるいは他の属性であるから、プロパティが、たとえそれがその目的でその場その場で生成された匿名の singleton クラスであるとしても属性とまったく同じようにアクセスされる。 それ以来「rw」属性が、プロパティがそのために同じくそうであるかもしれない変数がテンポラリ化したように、あらゆる点で振る舞うtempあるいは hypotheticalized でlet.

Perl 6 の Lexing は文法的なカテゴリーのシステムによってコントロールされる。 解析結果におけるそれぞれのポイントで、レクサーは、示すカテゴリーがどの文法的な（人たち・もの）のサブセットにおいて可能であるか知って、そして何でも表しているそれらを含めて、すべての活発な代替物の向こう側に最も長いトークン規則に従う、そうする準備ができている文法的なカテゴリーがマッチする。 このプロセスの詳細な内容のために S05 を見ろ。

現在のカテゴリーのリストを受けとるために、 STD.pm6 から「トークンカテゴリ：」を grep しろ。

カテゴリ名が種々の演算子と、後者が付加の「sym」を含むけれども、それらを解析するルール両方の短い名前として使用される：

infix:<cmp>           # the infix cmp operator
infix:sym<cmp>        # the rule that parses cmp
 

あなたが見ることができるように、名前の extention はコロンペア表記法を使う。 :sym 典型的に引数を演算子；カテゴリーが必要とする「接周辞」のいくらかについて文字列名に冒頭の、そして終わりの文字列のための2つの引数を与えに連れて行く。 それほど多くがあるから、その記号が識別子であるルールとマッチする、我々は速記を許す：

infix:cmp             # same as infix:sym<cmp> (not infix:<cmp>)
 

推測的に、我々は同じく他の種類の木のような、ルールがルールにリライトするようにするかもしれない：

infix:match<cmp>      # rewrite a match node after reducing its arguments
infix:ast<cmp>        # rewrite an ast node after reducing its arguments
 

マッチしている文法の中で proto サブルール <インフィックス>は通り過ぎて、それらが分離されるかのように、 alterativesに並行としてインフィックスカテゴリですべての目に見えるルールとマッチするだろう「|「.

STDでここに解析ルールの名前の若干がある：

category:sym<prefix>                           prefix:<+>
circumfix:sym<[ ]>                             [ @x ]
dotty:sym<.=>                                  $obj.=method
infix_circumfix_meta_operator:sym['»','«']     @a »+« @b
infix_postfix_meta_operator:sym<=>             $x += 2;
infix_prefix_meta_operator:sym<!>              $x !~~ 2;
infix:sym<+>                                   $x + $y
package_declarator:sym<role>                   role Foo;
postcircumfix:sym<[ ]>                         $x[$y] or $x.[$y]
postfix_prefix_meta_operator:sym('»')          @array »++
postfix:sym<++>                                $x++
prefix_circumfix_meta_operator:sym<[ ]>       [*]
prefix_postfix_meta_operator:sym('«')          -« @magnitudes
prefix:sym<!>                                  !$x (and $x.'!')
quote:sym<qq>                                  qq/foo/
routine_declarator:sym<sub>                    sub foo {...}
scope_declarator:sym<has>                      has $.x;
sigil:sym<%>                                   %hash
special_variable:sym<$!>                       $!
statement_control:sym<if>                      if $condition { 1 } else { 2 }
statement_mod_cond:sym<if>                     .say if $condition
statement_mod_loop:sym<for>                    .say for 1..10
statement_prefix:sym<gather>                   gather for @foo { .take }
term:sym<!!!>                                  $x = { !!! }
trait_mod:sym<does>                            my $x does Freezable
twigil:sym<?>                                  $?LINE
type_declarator:sym<subset>                    subset Nybble of Int where ^16
 

これらの若干が相応して名指された演算子を作り出すとは、注意しろ、けれどもそれらのすべてじゃない。 それらであるとき、文通しろ（同じぐらい中にそんなものcmp 上記の例）、これが、施行によってではなく、約束によってである. （しかしながら、マッチしている<sym> これらの1つの中でルールがリテラルの演算子の代わりに次のプロセッシングでこの連絡を準備することをより容易にする。）

STD：：正規表現文法が同じくこれらを加える：

assertion:sym<!>                         /<!before \h>/
backslash:sym<w>                         /\w/ and /\W/
metachar:sym<.>                          /.*/
mod_internal:sym<P5>                     m:/ ... :P5 ... /
quantifier:sym<*>                        /.*/