タイトル

Synopsis 3： Perl 6 演算子

著者

Luke Palmer <luke@luqui.org>
Larry Wall <larry@wall.org>
Darren Duncan <darren@darrenduncan.net>

機種

Created: 8 Mar 2004

Last Modified: 6 Aug 2011
Version: 227

概観

Perl 5 からの変更のサマリーのために、 Perl 5 演算子に対する変更を見ろ。

演算子優先

Perl 6 は場所で Perl 5 、しかしそれらが異なって取り決められるとだいたい同じ優先レベルの数を持つ。 ここで我々は、それぞれのレベルの少数の例とともに、「「最もきつい」」から「「最も緩い」」にレベルをリストする：

A  Level             Examples
=  =====             ========
N  Terms             42 3.14 "eek" qq["foo"] $x :!verbose @$array
L  Method postfix    .meth .+ .? .* .() .[] .{} .<> .«» .:: .= .^ .:
N  Autoincrement     ++ --
R  Exponentiation    **
L  Symbolic unary    ! + - ~ ? | || +^ ~^ ?^ ^
L  Multiplicative    * / % %% +& +< +> ~& ~< ~> ?& div mod gcd lcm
L  Additive          + - +| +^ ~| ~^ ?| ?^
L  Replication       x xx
X  Concatenation     ~
X  Junctive and      &
X  Junctive or       | ^
L  Named unary       sleep abs sin temp let
N  Structural infix  but does <=> leg cmp .. ..^ ^.. ^..^
C  Chaining infix    != == < <= > >= eq ne lt le gt ge ~~ === eqv !eqv
X  Tight and         &&
X  Tight or          || ^^ // min max
R  Conditional       ?? !! ff fff
R  Item assignment   = => += -= **= xx= .=
L  Loose unary       so not
X  Comma operator    , :
X  List infix        Z minmax X X~ X* Xeqv ... E
R  List prefix       print push say die map substr ... [+] [*] any Z=
X  Loose and         and andthen
X  Loose or          or xor orelse
X  Sequencer         <==, ==>, <<==, ==>>
N  Terminator        ; {...}, unless, extra ), ], }

2を使って! 同じ優先、指定された結合を持っている何でも演算子についてペアにする属性的に表すべき下のシンボルが上に2進法の演算子のために次のように解釈される：

    Assoc     Meaning of $a ! $b ! $c
    =====     =========================
L   left      ($a ! $b) ! $c
R   right     $a ! ($b ! $c)
N   non       ILLEGAL
C   chain     ($a ! $b) and ($b ! $c)
X   list      infix:<!>($a; $b; $c)

これが解釈される unaries のために：

    Assoc     Meaning of !$a!
    =====     =========================
L   left      (!$a)!
R   right     !($a!)
N   non       ILLEGAL

（スタンダード Perl にスタンダード演算子が首尾一貫して同様そうであるそれぞれの優先レベルで接頭辞あるいは後尾辞から、結合性を利用することができる unaries がない。）

リスト結合性（X）がただ同一の演算子の間に機能するだけであることに注意を払え。 もし2つの異なったリスト - 結合の演算子がお互いと括弧があいまいさを排除するために使われなくちゃならない優先、それらが非結合性だと考えられる同じことを持つなら。

例えば、X 演算子を渡るそしてZ zip 演算子が共にわずか「リストインフィックス」の1つの優先順位を持っている：

@a X @b Z @c

非合法であって、そして同じぐらい同様書かれなくちゃならなの : 

(@a X @b) Z @c
@a X (@b Z @c)

もしリスト - 結合の演算子の唯一の実装が2進法であるなら、それは右連想として扱われるだろう。

標準的な優先レベルはそれら結合性、しかしユーザー定義の演算子の点で一貫しようと試みる、そして優先レベルが同じ優先レベルで権利と左連想演算子を混ぜるかもしれない。 もし2つの相いれない演算子があいまいにお互いと括弧があいまいさを排除するために使われなくちゃならない展開式、演算子が非結合性だと見なされるであろう同じことで使われるなら。

もしあなたが上にあなたの大好きな演算子を見ないなら、次節は優先オーダーですべての演算子をカバーする。 基本的な演算子記述がここにある；特別なトピックはその後カバーされている。

項優先

これは本当に優先レベルじゃない、しかし、演算子が項よりもっときつい優先を持つことができないから、それはここ（に・で・は）ある。 種々の項のより長い記述のために S02 を見ろ。 ここに若干の例がある。

メソッド後置優先

ドットが添え字のためにオプションであるけれども、すべてのメソッド後置はドットで始まる。 これらが最もきつい標準的な演算子だから、あなたはしばしば一連のメソッドについてただ複雑な名前を表現する一つの項としての呼び出しを考えることができる。

もっと多くのメソッドが呼び出す一つのディスパッチのディスカッションのために S12 を見ろ。

Autoincrement 優先

C、これらの演算子インクリメントあるいはデクリメントのように、それが前にあるいは後で置かれるかどうかについて、問題のオブジェクトはあるいは値の前か後に依存して、オブジェクトからとられる。 同じくCのように、シングルへの多数の参照がオブジェクトを突然変異させるという状態で、展開式がもたらすかもしれない同じことで若干の明示的な順次演算子が挿入されない限り未定義の振る舞い。 Sequence ポイントを見ろ。

Perl 6 にすべての後置演算子で、スペースが項とその後置の間に許されない（とき・から・につれて・ように）。 なぜかについて、そして「unspace」でどのように制限に取り組むべきかについて、 S02 を見ろ。

メソッドを突然変異させるとして、これらすべての演算子は同じ型の演算数と帰りの型に結果をディスパッチする、しかし、（不変の）値が変更可能なコンテナで記憶される場合に限り、それらは値型に正当だ。 しかしながら、そのままの未定義の値（中に適切Scalar コンテナ）中にそれ自身を突然変異させるべき許可であるInt 共通慣用句をサポートするために：

say $x unless %seen{$x}++;

増加するStr （適切なコンテナで） Perl 5 と同様に働く、しかし少し一般化される。 ではないが通り過ぎて（それより）優先されたスキャンが文字列で最終の英数字のシーケンスのために作られる「.」文字. Perl 5 の場合と異なり、この英数字のシーケンスは文字列の始まりに固定される必要がない、同様にそれは；文字列での最終のシーケンスがマッチしているという状態で、で始まる段落にアルファベット文字を必要としない<!after '.'> <rangechar>+ 何がそれの前に来るかにかかわらず、増加する。

<rangechar> 文字クラスが、定義された下として、インクリメントにレンジの中で Perl がどのように知っている文字のそのサブセットと定義される。

追加のマッチしている行動は2つの有用な利益を提供する：ファイル名を増加させることについてのその典型的な使用のために、あなたはパス名あるいは拡張のことで心配しなくてもよい：

$file = "/tmp/pix000.jpg";
$file++;            # /tmp/pix001.jpg, not /tmp/pix000.jph

多分いっそうポイントをついていて、もしあなたがインクリメントに起こるなら、10進数で終わる1つの文字列で、それは正しいことをする可能性が高い：

$num = "123.456";
$num++;             # 124.456, not 123.457

文字ポジションが数値 0..9 あるいはそれを表すとみなされる Unicode レンジが（そのために）完全な循環しているアルファベットであるとみなされる何のための（彼・それ）らの自然のレンジもの中で増加する（1つのケースの）（Unicode）スクリプト. ただ他のアルファベットのサイクル独立を形成する符号位置で（彼・それ）らのアルファベットを表すスクリプトだけが使われてそうであるかもしれない。 （英字の適切なサイクルを決定することに対して、この仕様はこのようなスクリプトのユーザーに従う。） 我々はその範囲で文字を利用する他のスクリプトと交差しないために独断的に ASCII アルファベットを定義する、しかし ASCIIの英字を点在させるアルファベットが許されない。

もし文字列位置の現在の文字がこのような範囲での最終の文字であるなら、それはレンジの最初の文字にラップして、そしてそれの残されたポジションに1「キャリー」を送る、そしてそのポジションはそれから、それ自身の範囲で増加する。 もし左端ポジションがその範囲で使い尽くされている場合に限り、そしてその場合には必ず、同じレンジの付加的文字が Perl 5 と同じファッションで走行距離を持つために差し込まれる、それで「（aaa00）」の中に「（zz99）」曲がり角を増加させることと、「（99zz）」を増加させることは「（100aa）」に変わる。

次の Unicode レンジは可能な rangechar レンジの若干だ。 我々がレンジを持っているかもしれないアルファベットのために：

A..Z        # ASCII uc
a..z        # ASCII lc
Α..Ω        # Greek uc
α..ω        # Greek lc (presumably skipping C<U+03C2>, final sigma)
א..ת        # Hebrew
  etc.      # (XXX out of my depth here)

我々がレンジを持っている数値のために：

0..9        # ASCII
٠..٩        # Arabic-Indic
०..९        # Devangari
০..৯        # Bengali
੦..੯        # Gurmukhi
૦..૯        # Gujarati
୦..୯        # Oriya
  etc.

レンジが同じくそうであるかもしれない 0..9 が増加させた他の非スクリプト、そんなものけれども

⁰..⁹        # superscripts (note, cycle includes latin-1 chars)
₀..₉        # subscripts
０..９      # fullwidth digits

Conjecturally 、共通の連続がそうであるかもしれない何も、たとえそれが 0..9 を表さないとしても、サイクルとして扱われる

Ⅰ..Ⅻ        # clock roman numerals uc
ⅰ..ⅻ        # clock roman numerals lc
①..⑳        # circled digits 1..20
⒜..⒵        # parenthesize lc
⚀..⚅        # die faces 1..6
❶..❿        # dingbat negative circled 1..10
  etc.

それらがそれらサイクルの終わりに達するとき、このような数を「振る舞う」ことが本当に意味をなさない間に、 incrementable のような値を扱うことはアウトラインと類似のナンバーが付けられた銃弾品目を書くことに向いているかもしれない。 （インクリメントに文字列のどの部分か知る前に、我々が rangechars の文字列の最終のシーケンスを見つけなければならないから、我々がただ認められない文字を増加させることができないとは、注意しろ。 同じく、我々がサイクルとオーバーラップすることを含まないために我々のレンジを明確にしたから、すべての文字増加が後継者の一人用のテーブルでルックアップによって扱われることができることに注意を払え。）

6が同じくサポートする Perl Str 類似の意味規則と一緒のデクリメント、ただ、サイクルに他の方向の負担を強いることによって。 しかしながら、左端文字が決して取り去られない、そして、あなたが「あああ」あるいは「000」のように文字列に着くとき、デクリメントは失敗する。

非 － に関するインクリメントとデクリメントStr 型が定義されることに関して.succ そして.pred オブジェクトの型の上のメソッドでScalar コンテナ。 もっと具体的に言うと、

++$var
--$var

同等であるそうすること

$var.=succ
$var.=pred

もし型がこれらのメソッドをサポートしないなら、対応するインクリメントあるいはデクリメント演算は失敗するだろう。 （オプティマイザは整数に関する普通のインクリメントとデクリメント演算がオーバーライドされないであろうと想定することを許される。）

増加するBool （適切なコンテナで）それを真にする。 それが何度前に増加したかにかかわらず、デクリメントがそれを偽にする。 これは有用なもしであるあなた%seen ハッシュが実際にであるKeySetデクリメントが実際にどのケースからそれを削除するかについてKeySet.

未定義のインクリメント / デクリメントNumericCoolあるいはAny 変数が変数を0にセットして、そして次にインクリメント / デクリメントを実行する。 従ってポストインクリメントが0を最初のときリターンする：

my $x; say $x++;    # 0, not Any

べき乗優先

象徴的な単項の優先

乗法の優先

演算子が回転演算子に変えられるかもしれない Any ビットシフト:rotate 副詞。 もし:rotate 指定される、符号拡張のコンセプトは無意味だ、そしてあなたは指定してはならない:signed 副詞。

加算の優先

複製

結合

Junctive と（すべて）優先

Junctive あるいは（何も）優先

名指された単項の優先

1つの引数の関数

sleep
abs
sin
...         # see S29 Functions

Perl 5 の場合と異なり、あなたが使わなくちゃならないことを注意する.meth デフォルトとするべきフォーム$_ 中にいる Perl 6。

単項のノーがあるrand あるけれども、 Perl に6を前接続する.rand メソッド呼び出しと引数のないrand 項。 単項のノーがあるint いずれかを前接続しろ；あなた不可欠は型キャストを使う、から型がそんなものを使うけれどもInt あるいはint. 　（型キャストが括弧を必要として、そして接頭演算子として使われないかもしれない。） 言い換えれば：

my $i = int $x;   # ILLEGAL

構文エラー（一列に並んだ2つの項）だ、なぜならint 今型名だ。

Nonchaining 2進優先

連鎖法2進優先

この優先レベルの上のすべての演算子は鎖でつながれるかもしれない；連鎖式比較を見ろ。 それらがすべて論理値を返す。

きつい、そして優先の

きつい、あるいは優先の

条件付きの演算子優先

副詞

演算子副詞は文法でスペシャルをケースに入れられたが、項目割り当てより少しもっときつい擬似優先のレベルで単項の演算子をなびかせるとして、解析される外観を与える。 （それら、それらが空白文字の欠如を必要とし、そしてこれらが空白文字を許すから、公式にではなく「後置」演算子である. これらの副詞は（彼・それ）ら自身をパーサーがインフィックス演算子を期待している場所に挿入する、しかし、副詞を解析して、そしてそれを前の項に適用した後で、パーサーはインフィックスを探し続ける。） それで、

$a < 1 and $b == 2 :carefully

そうする== 慎重に、他方

$a < 1 && $b == 2 :carefully

そうする&& 慎重にから&& 「カンマ」よりもっときつい優先の（こと・もの）だ。 使用

$a < 1 && ($b == 2 :carefully)

副詞を適用すること to the == その代わりに演算子。 我々はそれを言う== それが副詞がもしかすると当てはまることができた解析樹のてっぺんにあるという意味で、「最高の」演算子だ。 （それは括弧の外（に・で）適用されることができなかった。） もしあなたが最高の演算子が何であるか不確かであるなら、ただあなた自身にどの演算子が最後に応用されるであろうか尋ねろ。 例えば、中に

+%hash{$key} :foo

添え字は最初に起きるそして+ 演算子がそれほど、最後に、起きる:foo それに適用されるだろう。 使用

+(%hash{$key} :foo)

適用されるために:foo 添え字化している演算子にその代わりに。

あなたがものが好むと言うとき、副詞が一般にあなたが欲する方法に付着するだろう

1 op $x+2 :mod($x)

提案された内部のテスト構文はこれらの優先順位規則を利用する：

$x eqv $y+2  :ok<$x is equivalent to $y+2>;

ここで副詞は変更されていると見なされるeqv 演算子。

項目割り当て優先

緩い単項の優先

コンマ演算子優先

インフィックス優先をリストしろ

リストインフィックスがすべて同一の2項演算子が他の後の（の・もの・人）よりむしろ並列に一緒に働くことを意味するリスト結合性を持っている。 同一でない演算子が非結合性だと見なされて、そして明快さのために括弧で括られているに違いない。

演算子がリストを返すこれらの多くParcels、どのコンテキストに依存することは1つのフラットなリストの中にすべて出たそれらを平らにするかもしれない、あるいはそうしないかもしれない。 デフォルトは下に contextualizers を平らにして、しかし見るはずだ。

接頭辞優先をリストしろ

緩い、そして優先の

緩い、あるいは優先の

ターミネータ優先

項と同じように、ターミネータは本当は優先レベルではなく、最も緩い優先より緩いレベルだ。 それらがすべてどんな演算子先行パーシングでも終了させて、そして完全な展開式をメインパーサーに戻す効果を持っている。 それら演算子優先順序パーサーが何のステートにあるか気にする. もしパーサーが現在項を期待していて、そして展開式での最終の演算子が nullterm を取り扱うことができないなら、それは構文エラーだ。 （注目すべきことに、コンマ演算子と多くの接頭辞リスト演算子は nullterm を扱うことができる。）

Perl 5 演算子に対する変更

いくつかの演算子が明快さともっと良いハフマンコードを言語増やすために（今まで）所定の新しい名前：だった、他方他の人たちが優先を変えた。

Junctive 演算子

|&そして^ もうビットワイズ演算子じゃない（Perl 5 演算子に対する変更を見る）しかし今ずっとより高い原因をサポートしろ：それらは今ジャンクションコンストラクタだ。

ジャンクションは多数の値に同等の一つの値だ。 もう1つの結果を表しているジャンクションを返している演算を通してのそれらスレッド：

 (1|2|3) + 4;                            # 5|6|7
 (1|2) + (3&4);                          # (4|5) & (5|6)

最後の例によって例証されるように、2つのジャンクションが一つの演算子を通して応用されるとき、結果は値のそれぞれの可能な組み合わせへの演算子の適用を表すジャンクションだ。

ジャンクションが機能的な変形を持って来るanyalloneそしてnone.

これは建築物が好きである賛成のドアを開ける：

 unless $roll == any(1..6) { print "Invalid roll" }

 if $roll == 1|2|3 { print "Low roll" }

ジャンクションが添え字化することを通して働く：

doit() if @foo[any(1,2,3)]

ジャンクションは特に整然としていない。 それでもしあなたが言うなら

foo() | bar() | baz() == 42

それはコンパイラに junctional 引数の間にカプリングがないことを示す。 それらが中に評価されることができる、何でも命令する、あるいは並列に。 それらの何でも42を返すとすぐに、それらがショートして、そしてまったく他の人たちを動かすことができない。 あるいはもし並列に走っているなら、最初の成功したスレッドは突然に他のスレッドを終了させるかもしれない。 一般にあなたはおそらくジャンクションで副作用でコードを避けることを望む。

ジャンクションと一緒の否定的な演算子の使用は、もし素朴に自動的に通されるなら潜在的に問題だ。 しかしながら、定義することによって!= そしてne 否定メタ演算子に関して、我々は自動的に英語を話す人によって期待される「育成ではなく」得る。 すなわち、

if $a != 1 | 2 | 3 {...}

本当は手段

if $a ![==] 1 | 2 | 3 {...}

それを何かに似ている高次関数へのメタ演算子書き換えが好きだ：

negate((* == *), $a, (1|2|3));

それは同等の値：であることになる

if not $a == 1 | 2 | 3 {...}

それは英語を話す人が期待する意味規則だ。 しかしながら、それは後者があなた自身を構成すると書くためにもっと良いスタイルだろう。

配列の上の Junctive メソッド、リストとセットが対応するリスト演算子とまったく同じように働く。 しかしながら、ハッシュの上の junctive メソッドがただハッシュのキーだけのジャンクションを作る。 リスト演算形式を使え（あるいは明示.pairs）ペアのジャンクションを作ること.

比較意味規則

レンジと RangeIter 意味規則

.. 演算子が一緒に変形を持っているレンジ^ どちらかの端にレンジからその末端の排除を示すために。 それは常に生産するRange オブジェクト。 レンジオブジェクトが不変だ、そして主にマッチしている間隔の間使われる。 1..2 末端を含んだ1から2までの間隔は、1^．．．^2が末端を除外するが、何かとマッチするのに対して、中間の実数値か。

レンジが、それほど、より広い型に強制する異なった型の、数の引数のために：

1 .. 1.5

平均に導かれる：

1.0 .. 1.5

これらの強制型変換は多シグネチャーによって定義される。 （他の型が異なった強要ポリシーを持っているかもしれない。） 使うことは特に非合法であるRange 末端として：

0 ..^ 10  # 0 .. 9
0 .. ^10  # ERROR

レンジの間他の非数値的で右手の型、右の引数は左の引数の型に強制されて、そして数であるとして扱われる。 従って、Array もし左の引数が数であるなら、2番目の引数での型が数値的だと意図されると考えられる：

0 ..^ @x    # okay
0 ..^ +@x   # same thing

Whatever 型が -Inf / +Inf を表すために同じくサポートされる。 もしいずれかの末端がそうであるならWhateverCodeレンジもう1つの中にカリー化されたWhateverCode.

他の型のために、レンジは何のためにでも落ち着いているかもしれない、同じ型の2つの引数、もし型がそれ自身それをサポートする。 すなわち、一般に、infix:<..>:(::T Any $x, T $y) このようなそれ、もしがタイプする確定だT 一般的な比較を明確にする（すなわち、定義することによってinfix:<cmp> あるいは匹敵するもの）、レンジその型で作成される. もしT 同じく定義する.succそれから、レンジは反復されるかもしれない。 （さもなければレンジはただ間隔として使用されるかもしれなくて、そしてもし求められるなら失敗を返すだろうRangeIter.） それが必要じゃないとは、注意しろ、から型のレンジ多方法を定義しろT、一般的なルーチンから通常、あなたのためにレンジを自動的に生み出すことができる。

オブジェクトがサポートするレンジ.min そして.max （彼・それ）らの左と右の引数を表しているメソッド。 .bounds メソッドが間隔を表している2要素のリストとして両方の値を返す。 レンジが自動的に後退していない：2..1 常に空のレンジだ。 （連続演算子... しかしながら、自動的に後退することができる。 下を見ろ。）

オブジェクトがサポートするレンジ.excludes_min そして.excludes_max 除外を表しているメソッド（持っている^）あるいは包含物（いいえ^）範囲でのそれぞれの末端の.

Range      | .min | .max | .excludes_min | .excludes_max
-----------+------+------+-------------+------------
1..10      | 1    | 10   | Bool::False   | Bool::False
2.7..^9.3  | 2.7  | 9.3  | Bool::False   | Bool::True
'a'^..'z'  | 'a'  | 'z'  | Bool::True    | Bool::False
1^..^10    | 1    | 10   | Bool::True    | Bool::True

もし、リストコンテキストで、使われるならRange オブジェクトが分にびくっとして、そして最大限で終了して値のシーケンスを作り出すイテレータを返す。 いずれかの末端が使って除外されるかもしれない^. 　従って1..2 生産する(1,2) ただ1^..^2 匹敵するものはそうするはずだ2..1 そして値（Nil）を生産しない。 下方に重要である連続を指定するために、逆転を使え：

reverse 1..2
reverse 'a'..'z'

代わる代わる、数の連続のために、あなたはレンジ演算子の代わりに連続演算子を使うことができる：

100,99,98 ... 0
100, *-1 ... 0      # same thing

言い換えれば、何もRange リストが想定するように、使われる.succ 意味規則、決して.pred 意味規則。 もしあなたがインクリメントに望むなら、他のどのようなインクリメントも許されない、1、あなた以外の若干の数によっての数の連続が使わなくちゃならない... 演算子を順序立てて並べろ。 （Range 演算子の:by 副詞がここにけなされる。）

0, *+0.1 ... 100    # 0, 0.1, 0.2, 0.3 ... 100

ARange ただもし質問サポートでの型であるなら、反復されるかもしれない.succ メソッド。 もしそれがそうしないなら、何でも Return 失敗を反復しようと試みる。

反対のマッチしている Smart Range オブジェクトが中に（強要によって、もし必要なら）比較をするReal もしいずれかの末端がそうするならドメインReal. 　さもなければ比較は入っているStringy もしいずれかの引数がそうするならドメインStringy. 　さもなければ、もしそれが順序を定義するなら、分の型は使われる、あるいはもしそうでなければ、最大限は型だ。 もし分と最大限のいずれも秩序を持たないなら、 .ACCEPTS へのディスパッチが失敗する。 もし問題の順序が注文の選ばれたドメインによって暗示された appropropriate 型の中にスマートマッチされてずっとオブジェクトを強制するために何も持っていないなら、それは同じく失敗するかもしれない。

一般に、比較のドメインは、もし可能であるなら、問題のすべての値を表すことができる型であるべきだ。 従って、 Int ではないからこのような型、それは実数に昇進させられる、それでわずかな数が整数レンジとの比較の前に取り除かれない。 その代わりに整数は実数の上のポイント番号ラインを表すと考えられる：

1.5 ~~ 1^..^2  # true, equivalent to 1 < 1.5 < 2
2.1 ~~ 1..2    # false, equivalent to 1 <= 2.1 <= 2

もし* レンジについて（S02 で「Whatever」型を見ろ）正しい方に起こる、左オペランドから推定されるように、それはレンジが経営しているどんな typespace ででも「肯定的な無限」を意味するためにとられる。 A* 左手に右オペランドから推定されるように、さもなければ否定的な値と typespace で最初の値をサポートする型の間「負の無限数」を意味する。 （ではないが許した両側の上の星）

0..*        # 0 .. +Inf
'a'..*      # 'a' le $_
*..0        # -Inf .. 0
*..*        # Illegal
v1.2.3 .. * # Any version higher than 1.2.3.
May .. *    # May through December

空のレンジが反復されることができない；それは戻るNil その代わりに。 空のレンジがまだ確定を持っている.min そして.maxしかし次のことの1つ真の：1である. .min より大きい項目.max. 　2。 .min が.max そして少なくとも1つ.excludes_min あるいは.excludes_max 真だ。 3．両方とも.excludes_min そして.excludes_max 真であるそして.min そして.max 連続した値だ。

反復されるレンジが演算子を対応する連続に変える、そして従って用途が連続の終わりを決定するために意味規則にスマートマッチする。

Unary レンジ

単項の（人たち・もの）^ 演算子がレンジを生み出すから0 上りそうすること（しかし含まない）その引数. それで^4 賛成で短い0..^4.

for ^4 { say $_ } # 0, 1, 2, 3

もし応用であるなら、型名に、それは、その代わりに、そうにメタクラスの例を示す^Moose 賛成で短いHOW(Moose) あるいはMoose.HOW. 　それは抽象的な種類の方法でまだまあ「このもののドメインであるところ」を意味する。

レンジを自動的にカリー化すること

［このセクションは推測であって、そして6.0で無視されるかもしれない。］

なぜなら使えRange コンテキストが通常そうである品目のオブジェクトは途方もない , a Range スカラー演算子の間オペランドとして使用されたオブジェクトが一般にその終端に演算子を配ろうと試みて、そして修正されてふさわしくもう1つを返すだろうRange その代わりに、2つの項目のジャンクションとほとんど同じように、ただ適切な間隔意味規則で。 （これの顕著な例外がインクルードを自動的に通すinfix:<~~>スマートなマッチング、をするそしてprefix:<+> それはレンジの長さを返す。） そのためにもしあなたが末端の代わりに長さを使ってスライスを書くことを望むなら、あなたは言うことができる

@foo[ start() + ^$len ]

それは賛成で短い：

@foo[ start() + (0..^$len) ]

どちらが何かと等しいかが好む：

@foo[ list do { my $tmp = start(); $tmp ..^ $tmp+$len } ]

言い換えれば、数の、そして他の順序づけられた型の演算子は上に思慮がある何かをするために一般に多く積み過ぎているRange オブジェクト。

連鎖式比較

Perl 6 は、多数のオペランドを許して、比較演算子に自然な延長をサポートする：

if 1 < $a < 100 { say "Good, you picked a number *between* 1 and 100." }

if 3 < $roll <= 6              { print "High roll" }

if 1 <= $roll1 == $roll2 <= 6  { print "Doubles!" }

もし最初の比較が失敗するなら、比較の連鎖が決裂する：

1 > 2 > die("this is never reached");

鎖でのそれぞれの引数がせいぜい1度評価するだろう：

1 > $x++ > 2    # $x increments exactly once

注意しろ：始まっているどんな演算子でもで< それの前（に・で）空白文字を持たなくちゃならない、あるいはそれはその代わりにハッシュ添え字として解釈されるだろう。

マッチしている Smart

スタンダード Perl 6 （すなわち、あなたのコンパイル単位のスタートで有効な Perl の方言）のためにここにスマートなマッチのテーブルがある。 マッチしている Smart は一般に、現在の「トピック」に関して終わっている、すなわち、上に$_. 　下のテーブルで、$_ 左側を表sno~~ 演算子、あるいはそうするための引数givenあるいは他のいかなる topicalizer にでも。 X 右の（人たち・もの）が一方に加担する上に対抗させられるべきパターンを表す~~あるいは後でwhen. 　（そして、実際、~~ 小さい topicalizer としての仕事；すなわち、それがバインドする演算子$_ 左側の値に右側の評価のために。 基礎をなしている（人たち・もの）を使え.ACCEPTS この topicalization を避けるためにできろ。）

最初のセクションはそれらの参加チームの1つとしての恵まれている構文；マッチがされることができるかどうか含んでいる、それはそうだろう。 これらの特別なシンタクスはそれら型よりむしろそれら形式によってディスパッチされる。 さもなければテーブルの残りが使われる、そしてマッチは標準のメソッドディスパッチルールに従ってディスパッチされるだろう。 オプティマイザは追加のマッチ演算子が定義されたコンパイル時間を求めている、そうもしじゃないと想定することを許される、型が明白なパターンは時間をコンパイルする、分岐表は最適化されることができる。 しかしながら、テーブルのこの部分の構文はまだいくぶん恵まれている、限りにおいて~~ 演算子は多数のディスパッチを使わない Perl に少数の演算子の1つだ。 その代わりに、型ベースの苦悩が単独でそうするための属している原因となっているメソッドまでのディスパッチとマッチするX パターンオブジェクト。

言い換えれば、スマートなマッチがパターンの形式あるいは型をベースにして最初にディスパッチされる（X 下に）、そして次にパターン自身がトピックの型に注意を払うべきかどうか、そしてもしそうであれば、どのようにか決めること（$_）. それで下の2番目のコラムは本当に主要なコラムだ。 Any 最初のコラムの中の参加者があるいはトピックの型のことを気にかけない、あるいは、いっそう特定の型がそれの上に傾いたから、その参加者をデフォルトとして選ぶパターンがマッチしなかったことを示す。

$_        X         Type of Match Implied   Match if (given $_)
======    =====     =====================   ===================
Any       True      ~~ True                 (parsewarn)
Any       False     ~~ False match          (parsewarn)
Any       *         block signature match   block successfully binds to |$_

Any       Callable:($)  item sub truth          X($_)
Any       Callable:()   simple closure truth    X() (ignoring $_)
Any       Bool      simple truth            X
Any       Numeric   numeric equality        +$_ == X
Any       Stringy   string equality         ~$_ eq X
Any       Whatever  always matches          True
Any       Nil       is nil                  $_ === Nil

Hash      Pair      test hash mapping       $_{X.key} ~~ X.value
Any       Pair      test object attribute   ?."{X.key}" === ?X.value (e.g. filetests)

Set       Set       identical sets          $_ === X
Hash      Set       hash keys same set      $_.keys === X
Any       Set       force set comparison    Set($_) === X

Array     Array     arrays are comparable   $_ «===» X (dwims * wildcards!)
Set       Array     array equiv to set      $_ === Set(X)
Any       Array     lists are comparable    @$_ «===» X

Hash      Hash      hash keys same set      $_.keys === X.keys
Set       Hash      hash keys same set      $_ === X.keys
Array     Hash      hash slice existence    X.{any @$_}:exists
Regex     Hash      hash key grep           any(X.keys).match($_)
Cool      Hash      hash entry existence    X.{$_}:exists
Any       Hash      hash slice existence    X.{any @$_}:exists

Str       Regex     string pattern match    .match(X)
Hash      Regex     hash key "boolean grep" .any.match(X)
Array     Regex     array "boolean grep"    .any.match(X)
Any       Regex     pattern match           .match(X)

Any       Match     identity                $_

Num       Range     in numeric range        X.min <= $_ <= X.max (mod ^'s)
Str       Range     in string range         X.min le $_ le X.max (mod ^'s)
Any       Range     in generic range        [!after] X.min,$_,X.max (etc.)

Any       Type      type membership         $_.does(X)

Signature Signature sig compatibility       $_ is a subset of X      ???
Callable  Signature sig compatibility       $_.sig is a subset of X  ???
Capture   Signature parameters bindable     $_ could bind to X (doesn't!)
Any       Signature parameters bindable     |$_ could bind to X (doesn't!)

Signature Capture   parameters bindable     X could bind to $_

Any       Any       scalars are identical   $_ === X

最終的な統治は、他のどのようなパターン型もXを主張しない場合に限り、適用される。

すべては型にスマートマッチする；共に、「項目別に分類される」~~ そしてgiven/ when それら引数と自動装填に項目コンテキストに junctive がそれほどそれほど終局の（人たち・もの）的なディスパッチとマッチする何でも提供しろ.ACCEPTS 決して「複数形の」何も見ない。 それで両方とも$_ そしてX 上に潜在的にスカラーとして扱われるコンテナ・オブジェクトだ。 （あなたは hyperize するかもしれない~~ けれども明示的に。 この場合すべてのスマートマッチが型ベースのディスパッチをそうするために使い終わっている.ACCEPTSテーブルの前部における形式ベースのディスパッチじゃない。）

原因となっている型ベースのメソッドディスパッチの正確な形態はそうだ：

X.ACCEPTS($_)

これが型にだけ注意を払う一つのディスパッチ呼び出しとしてX 初めに。 ACCEPTS 接合点が定義されるメソッドPattern ロール。 構成している Any クラスPattern ロールがシングルを供給することに決めるかもしれないACCEPTS 一緒にたった1つの項目を持っているそれらのパターン型に対応するすべてを扱うべきメソッドAny 左手に上に。 あるいはクラスは複数を提供することに決めるかもしれないACCEPTS クラスとこれらがそれから型の上にクラス・ベースの中で再び破るであろう中の多メソッド$_.

テーブルにスマートマッチする主にコンパイル時間に識別されるフォームと型を反映するように意図される. 項目の爆発を避けるために、テーブルは次の型が同様に振る舞うであろうと想定する：

Actual type                 Use entries for
===========                 ===============
Iterator Seq                Array
KeySet KeyBag KeyHash       Hash
named values created with
  Class, Enum, or Role,
  or generic type binding   Type
Char Cat                    Str
Int UInt etc.               Num
Match                       Capture
Byte                        Str or Int
Buf                         Str or Array of Int

（しかしながら、これらのマッピングが適切な（人たち・もの）の明示的な定義によってオーバーライドされることができるとは注意しろACCEPTS メソッド。 もし再定義がスマートなマッチの分析のコンパイル時間に前に起こるなら、情報は同じくオプティマイザにとって入手可能だ。）

ABuf ASCIIのレンジの外のバイトあるいは整数が静かに促進するかもしれない何でも含んでいる型をそうすることStr もし Unicode とのその関係が明らかに宣言されるか、あるいはタイプされる場合に限り、そしてその場合には必ず、マッチしているパターンのためにタイプだ。 この型情報はインプットファイルハンドルから来るかもしれない、あるいはBuf ロールはあなたに種々の周知のエンコーディングと一緒にバッファーのインスタンスを作ることを許すパラメータを伴う型であるかもしれない。 このようなタイピング情報がないので、あなたはまだバッファーに対してマッチしてパターンをしてもよい、しかし（離れて最も低く7ビットが ASCII を表すと想定することから）、何でもおごろうと試みる、シーケンス以外に整数としてのバッファーは誤っている、そして警告が気前良く表示されるかもしれない。

反対のマッチングGrammar 文法としてではなく、 typename として文法を扱う。 あなたは使う必要がある.parse あるいは.parsefile メソッドが文法を行使する。

反対のマッチングSignature 実際に変数をバインドしない、しかしシグネチャーがバインドすることができたかどうか見る唯一のテスト。 本当に、シグネチャーに、使用をバインドすること* バインディングを委任するべきパターンwhen その代わりに文のがブロックする。 反対のマッチング* それが次のブロックがトピックに対してバインドされるか否かにかかわらずその真実をとるそれでのスペシャルだ、それであなたはマッチして順序づけられたシグネチャーをすることができる：

given $capture {
    when * -> Int $a, Str $b { ... }
    when * -> Str $a, Int $b { ... }
    when * -> $a, $b         { ... }
    when *                   { ... }
}

多数のディスパッチの整然としていない意味規則がコードの「序列」を定義するには不十分であるとき、これは有用であり得る。 あなたがそのままのブロックあるいは pointy ブロックにバインドすることができる注目。 バインディングがそのままのブロックに好都合にトピックを残しておく$_上記の最終形式が同等であるようにそうすることdefault. 　（もちろんそれら型がそのように指定されることができないけれども、プレースホルダーパラメータは同じくそのままのブロック形式で使われるかもしれない。）

賛成のパターンマッチング確定がないAny パターン、もしあなたが欠けることについての状況にあなた自身を見いだすならそうだ反転させるテストにスマートマッチすでAny 右手に、あなたはほとんど常にそれを明示的な呼び出しまでに基礎をなしている（人たち・もの）に渡すことができるACCEPTS $_ をパターンとして使用しているメソッド。 例：

$_      X    Type of Match Wanted   What to use on the right
======  ===  ====================   ========================
Callable Any  item sub truth         .ACCEPTS(X) or .(X)
Range   Any  in range               .ACCEPTS(X)
Type    Any  type membership        .ACCEPTS(X) or .does(X)
Regex   Any  pattern match          .ACCEPTS(X)
etc.

あなたが $_ にドットを打たれたメソッドから始める限り、類似のトリックがあなたが合成のオブジェクトのためにデフォルトのマッチしているルールを曲げることを可能にするだろう：

given $somethingordered {
    when .values.'[<=]'     { say "increasing" }
    when .values.'[>=]'     { say "decreasing" }
}

切羽詰まればあなたは「いつ反転させられる」をするためにマクロを定義することができる：

my macro statement_control:<ACCEPTS> () { "when .ACCEPTS: " }
given $pattern {
    ACCEPTS $a      { ... }
    ACCEPTS $b      { ... }
    ACCEPTS $c      { ... }
}

ただ行動が容易にそうであるかもしれないけなされた － がスマートマッチする種々の提案された － （そして我々は、いっそう読めるように、希望する）、次のように：模倣された

$_      X      Type of Match Wanted   What to use on the right
======  ===    ====================   ========================
Array   Num    array element truth    .[X]
Array   Num    array contains number  *,X,*
Array   Str    array contains string  *,X,*
Array   Seq    array begins with seq  X,*
Array   Seq    array contains seq     *,X,*
Array   Seq    array ends with seq    *,X
Hash    Str    hash element truth     .{X}
Hash    Str    hash key existence     .{X}:exists
Hash    Num    hash element truth     .{X}
Hash    Num    hash key existence     .{X}:exists
Buf     Int    buffer contains int    .match(X)
Str     Char   string contains char   .match(X)
Str     Str    string contains string .match(X)
Array   Scalar array contains item    .any === X
Str     Array  array contains string  X.any
Num     Array  array contains number  X.any
Scalar  Array  array contains object  X.any
Hash    Array  hash slice exists      .{X.all}:exists .{X.any}:exists
Set     Set    subset relation        .{X.all}:exists
Set     Hash   subset relation        .{X.all}:exists
Any     Set    subset relation        .Set.{X.all}:exists
Any     Hash   subset relation        .Set.{X.all}:exists
Any     Set    superset relation      X.{.all}:exists
Any     Hash   superset relation      X.{.all}:exists
Any     Set    sets intersect         .{X.any}:exists
Set     Array  subset relation        X,*          # (conjectured)
Array   Regex  match array as string  .Cat.match(X)  cat(@$_).match(X)

（それに注意する.cat method そして the Cat 両方ともがそれと異なり、一つのオブジェクト、をとる型強要cat リスト演算子として、構文的なリスト（あるいは多重リスト）を受けて、そしてそれを平らにする関数。 しかしながら、これらのすべてが猫オブジェクトを返す。）

ブールの展開式は、比較のような、ブールの値あるいは単項の（人たち・もの）を返すことが知られているそれらだ? 演算子。 それらがそうするかもしれない参照$_ 明示的に、あるいは暗黙のうちに。 もしそれらであるならそうする参照$_ 同じく、問題がないすべてで － このような場合あなたは elsifs の文字列にただスイッチ構造をいっそう読み取り可能な代替物として使用しているだけだ。 しかしながら、これがあなたが書くことができないことを意味するとは注意しろ：

given $boolean {
    when True  {...}
    when False {...}
}

それが常に選択するであろうからTrue ケース。 その代わりに条件付きのコンテキストとほぼ同じ使用が内部的に使う：

given $boolean {
    when .Bool == 1 {...}
    when .Bool == 0 {...}
}

もっと良くて、ただ使用if 文。 何ででも場合、あなたがスマートマッチしようとするもしで~~ あるいはwhenそれ認知するだろうTrue あるいはFalse 統語論上、そしてあなたにそれがあなたが期待することをしないであろうことを警告しろ。 コンパイラは同じく何についてでもテストではなくする他のブールの構造に警告することを可能にされる$_それがそれを発見することができる限りにおいて。

類似の静脈、何にでも、作用しろ（そんなものけれどもgrep）付くMatcher 型の引数を受け入れないだろうBool、それからほとんど常にプログラミングエラーを示す。 （1人は常に使うかもしれない* もしそれがあなたが本当に欲するものであるなら、何とでもマッチするために。 あるいは不変のブールの値を返すクロージャを使え。）

同じくマッチしている正規表現が戻らないことを注意するBoolしかしただMatch 論理値として使用されることができるオブジェクト。 明示を使え? あるいはtrue 勢力にBool もし望ましいなら値。

主要な使用の~~ 演算子がブールの値をブールのコンテキストで返すはずだ。 しかしながら、正規表現のようなある特定のオペランドのために、項目あるいはリストコンテキストの中の演算子の使用がコンテキストをそのオペランドに転送する、それで、例えば、正規表現が、 Perl 5 のように、マッチされたサブストリングのリストを返すことができる。 これは、リストコンテキストでリストを返すことができる、あるいはブールを返すことができるオブジェクトをブールのコンテキストで返すことによって、される。 マッチしているケース正規表現でMatch オブジェクトが種類であるのCaptureそれはこれらの能力を持っている。

スマートマッチ、すべての目的でSet そしてBag 値が型の（こと・もの）であると見なされるKeyHashすなわち、Hash キーがユニークなオブジェクトと値を表すコンテナがそれらのユニークキーの複製カウントを表す。 （明らかに , a Set ユニークさの保証のためにたった0あるいは1つの複製を持つことができる）.

Cat 型があなたに非常に拡張可能な文字列を持っていることを許す。 権限：が、それに餌をやることによって、配列あるいはイテレータとマッチするそうすることCat本質的にであるStr ある種のイテレータにわたって相互に作用しろ。 それからRegex それが普通の文字列であるかのように、それに対して使用されることができる。 Regex 機関が文字列にそれがもっと多くの文字を持っているかどうか尋ねることができる、そして、もしその原因となっているイテレータから可能であるなら、文字列はそれ自身を拡張するだろう。 （それほどもしあなたが使うなら、このような文字列が文字の不明確な数を持っているとは、注意しろ.* あなたのパターンで、あるいはもしあなたが文字列にそれがその中にいくつの文字を持っているか尋ねるなら、あるいはもしあなたが文字列全体を印刷しさえするなら、それは迅速であるかもしれない、あるいはそうしないかもしれない文字列の残りで音をたてて飲むように強制されて手触りであるかもしれない。）

cat 演算子が（潜在的にいい加減な）リストを受けて、そして戻るCat オブジェクト。 文字列コンテキストでこれはいい加減に文字列にその要素のそれぞれを強制して、そして不確定な長さについて文字列として作用する。 あなたはこのようなギャザーを捜索することができる：

my $lazystr := cat gather for @foo { take .bar }

$lazystr ~~ /pattern/;

Cat 接合点が一緒に要素の境界とマッチするべき正規表現を許す<,> アサーション、そしてStrPos マッチによって返されたオブジェクトがそのリスト要素の中で要素指数とポジションに分解されることができる。 もし基礎資料構造であるなら変更可能な配列だ、配列に対する変更（通り過ぎてのようにshift あるいはpop）通り過ぎて無限軌道であるCat 要素番号が正しいままでいるように。 文字列、配列、リスト、連続、キャプチャとツリーノードはすべてもっと、あるいはより低度に交換可能に正規表現によってあるいはシグネチャーによって一致されたパターンであり得る。

インボカントマーカー

付加する: Perl 6 メソッド呼び出しのために間接的なオブジェクトの構文を使うとき、インボカントに記録を残す。 次の2つの文は同等だ：

$hacker.feed('Pizza and cola');
feed $hacker: 'Pizza and cola';

コロンが同じく上に使われるかもしれない、普通のメソッドがそれを呼び出して、から示す、それはリスト演算子と解析されるべきだ：

$hacker.feed: 'Pizza and cola';

このコロンは別個のトークンだ。 副詞を前接続しているコロンは別個のトークンじゃない。 そのために、最も長いトークンの規則の下で、

$hacker.feed:xxx('Pizza and cola');

その「演算子に先行する toplevel」としてメソッドに当てはまっている副詞として tokenized される：

$hacker.feed :xxx('Pizza and cola');

.feed の引数リストでの xxx sub としてではなく：

$hacker.feed: xxx('Pizza and cola');  # wrong

もしあなたが順に両方ともに副詞を与えるコロンの意味と若干の位置の引数両方を欲するなら、あなたは2度コロンを置かなければならない：

$hacker.feed: :xxx('Pizza and cola'), 1,2,3;

（類似の理由でラベルのコロンの後に空白文字を置くことは必要とされる。）

副詞の優先のために特にそれに注意しろ：

1 + $hacker.feed :xxx('Pizza and cola');

適用されるだろう:xxx そうするための副詞+ メソッド呼び出しではなく、演算子。 成功する可能性が高いこのではない。

飼料演算子

新しい演算子==> そして<== UNIX パイプに類似だが、リストを受け入れて、そして返す関数あるいは文と共に働く。 これらのリストが液体ではなく、不連続のオブジェクトで構成されているから、我々はパイプよりむしろこれらの飼料演算子を呼び出す。 例えば、

 @result = map { floor($^x / 2) },
             grep { /^ \d+ $/ },
               @data;

同じく今右への放送で書かれることができるけれども：

 @data ==> grep { /^ \d+ $/ }
       ==> map { floor($^x / 2) }
       ==> @result;

あるいは左方の放送でけれども : 

 @result <== map { floor($^x / 2) }
         <== grep { /^ \d+ $/ }
         <== @data;

あるいは形式がいっそう明らかにデータの流れを示す。 これらの2つの演算子についての（－ 以下しか明白じゃない）詳細のさらに多くのために S06 を見ろ。

Meta 演算子

6の演算子がその人と共に、ストリングとして、数そしてブールの演算子を前接続して通り過ぎて首尾一貫して、例えば、大いに規則化された Perl +~ そして? それぞれ数、文字列、あるいは一つのビットにビットワイズ演算がされるかどうかを示すために。 けれどもそれはただネーミング規定とあなたが新しいビットワイズを加えることを望んだかどうかだ¬ 演算子は、あなたは加えなければならないだろう+¬~¬そして?¬ あなた自身演算子。 同様に、レンジに末端を排除するキャレットは協定のみによってそこにある。

それと対照して、所定の存在する演算子をいっそう強力だ（あるいは少なくとも異なって強力な）関連した演算子に変えることに対して、 Perl 6 は8つのスタンダードメタ演算子を持っている。 これらは、ビルトインからと同様、 Perl が自動的にユーザー定義の演算子からこれらの新しい演算子を生成するという点で、単なるネーミング規定とは違う。 実際、あなたは一般に個別の metaoperations を定義すると思われない － それら意味規則はベース演算子の変換によって自明であるはずだ。 言い換えれば、これらのメタ演算子は高次関数（他の関数を引数であると思う関数）のために本当にただ速記に過ぎない。

メタ演算子を含んでいる構造は、それらコンポーネントがそうであるけれども、（それによって）我々がそのそれらを意味する熟考された「metatokens」が普通の最も長いトークンのマッチしているルールの適用を受けないということだ。 しかしながら、普通のトークンのように、 metatokens がそれら下位部分の間に空白文字を許さない。

割り当て演算子

割り当て演算子はすでにCと Perl プログラマーによく知られている。 （けれども.= 演算子が今左手にオブジェクトの上に突然変異しているメソッドを呼び出すつもりである、そして~= 文字列連結だ。） 2項演算子が接尾辞によっての（彼・それ）らの対応する代入演算子に変えられるかもしれないたいていの非関係=. 　限界は実際に左側がいつもの連絡によって共に右辺値と左辺値として作用することができるかどうかに基づいている：

A op= B;
A = A op B;

終わっている存在するフォームが入っている= このメタ演算子で修正されないかもしれない。

ベース演算子の優先、何の優先にでもかかわらず割り当て演算子が普通の割り当てのそれと同じであることを強いられる。 もしベース演算子がカンマよりもっときついなら、展開式は項目割り当てと解析される。 もしベース演算子が同じであるか、あるいはカンマよりゆるく、展開式がリスト割り当てと解析されるなら：

$a += 1, $b += 2    # two separate item assignments
@foo ,= 1,2,3       # same as push(@foo,1,2,3)
@foo Z= 1,2,3       # same as @foo = @foo Z 1,2,3

ベース演算子がそうしないなら、リストへの metaassignment が自動的に割り当てられたリストに右の引数を散布しないとは、注意しろ（同じぐらい中にZ 上記の事例）. 従ってもしあなたが言うことを望むなら：

($a,$b,$c) += 1;    # ILLEGAL

あなたはその代わりに超演算子を使う（下を見る）ければならな：

($a,$b,$c) »+=» 1;  # add one to each of three variables

もしあなたが（未定義である）型オブジェクトを含んでいて割り当て演算子をコンテナに適用するなら、あなたがアキュムレータ変数に何らかの種類の観念的な「縮小」を実装していると想定される。 それを目指して、演算は型オブジェクトが autovivifies に演算子のに値を識別する対応する縮小演算子に関して定義される。 それでもしあなたが言うなら：

$x -= 1;

そうすることは多かれ少なかれ同等だ：

$x = [-]() unless defined $x;  # 0 for [-]()
$x = $x - 1;

そして、期待されるように、 $x がその中に－1を持つことになる。

従ってあなたは正確に書いてもよい：

my Num $prod;
for @factors -> $f {
    $prod *= $f;
}

これがスカラ変数のケースでかろうじて有用に思われるかもしれない間に、修正された場所がほんの少し前に autovivification によって引き起こされたかもしれないとき、それがこのように機能することはずっと重要だ。 言い換えれば、もしあなたが書くなら：

%prod{$key} *= $f

あなたはハッシュ要素がまだ存在するかどうか心配する必要がない。 もしそれがそうしない、それが簡単にそうするであろうなら、の値で初期化されろ$f.

関係演算子を否定した

Any インフィックス関係演算子が型を返すBool プレフィックス変換によってそのネガに変換されるかもしれなで!. 　2つのこれらが伝統的な近道を持っている：

Full form   Shortcut
---------   --------
!==         !=
!eq         ne

けれどもそれらの大部分がそうしない：

!~~
!<
!>=
!ge
!===
!eqv
!=:=

視覚の混乱を避けることで!! 演算子は、あなたはすでに演算子を修正してはならない!.

演算子がそうである否定された何の優先でもベース演算子と同じもの。

あなたはただ戻るそれらの演算子だけを否定するかもしれないBool. 　それほど論理的な演算子的に注意するよう|| そして^^ 戻るBoolしかしどちらかと言えば演算数の1つ。

演算子を反転させた

インフィックス演算子がそれと一緒プレフィックス変換によって反転させられたその2つの引数で呼び出されるかもしれない Any R. 　例えば、反転させられた比較をするために：

Rcmp
Rleg
R<=>

何の優先でも後退した、演算子はベース演算子と同じだ。 結合性ではないが、それほど、反転させられる

[R-] 1,2,3   # produces 2 from 3 - (2 - 1)

他の影響を表明すること減量する、反位、リスト：

[-] reverse 1,2,3  # produces 0

超演算子

Unicode 文字» （\x[BB]）そして« （\x[AB]）そして（彼・それ）らの ASCII 2字表現>> そして<< そのリスト（あるいは配列）のそれぞれの要素に引数（あるいは引数）を操作して、そして結果の一つのリスト（あるいは配列）を返す「リスト操作」を意味するために使われる。 言い換えれば、超演算子が項目コンテキストでその引数を評価するが、リストとしてそれからそれらに演算子を散布する。

ハイパー演算子を書くとき、スペースが、すなわち、何の間にも、内側に入ることを許されない「ハイパー」それが修正しているマーカーと演算子. 間隔ポリシーの外の曜日で指定はベース演算子と同じだ。 同じくそのベース演算子として超演算子が同じようにそうである何もの優先。 これはあなたがたいていの演算子のためにあなたのコンマリストを括弧で括らなくちゃならないことを意味する。 例：

 -« (1,2,3);                   # (-1, -2, -3)
 (1,1,2,3,5) »+« (1,2,3,5,8);  # (2,3,5,8,13)

単項のハイパー演算子（いずれかの接頭辞あるいは後尾辞）がその引数サイドに位置しているたった1本のハイパーマーカーを持っている、他方インフィックス演算子が2つの引数があることを示すために常に両側で1（人・つ）を持っている。 Unary 演算子が常にリストあるいは（彼・それ）らの一つの引数とまったく同じ状態の配列を生産する。 インフィックス演算子が2つのリストあるいは同一の状態の配列を与えられるとき、その同じ状態の結果が産み出される。 さもなければ結果は、あなたがどのように超マーカーを書くかについて、依存する。

インフィックス演算子、いずれかの引数が不十分に大きさを計測されるかどうかのために、 Perl はそれを「アップグレードする」、しかしただもしあなたがそれに超マーカーの「鮮明な」終端を向けるなら。

 (3,8,2,9,3,8) >>->> 1;          # (2,7,1,8,2,7)
 @array »+=» 42;                 # add 42 to each element

実際、引き上げられたスカラーが整然としていない型にそんなものをもたらすであろう唯一のことである as a Bag：

 Bag(3,8,2,9,3,8) >>->> 1;       # Bag(2,7,1,8,2,7) === Bag(1,2,2,7,7,8)

言い換えれば、引数に小さい終端を向けることはそちら側で「dwim」に超演算子に教える。 もしあなたが両側の上に片側あるいは他が過小に大きさを計測されるだろう、あなたが dwim することができるかどうか知らないなら：

$left «*» $right

［注意しろ：もしあなたがこのような何かによって混乱させられて Perl のことが心配であるなら：

func «*»

それからあなたはそれのことで心配するべきじゃない、なぜなら前バージョンと異なり、 Perl 6 は決して次のものが項あるいは演算子かどうか言い当てないから。 この場合それは常に項を期待していないならfunc 型あるいは値名であるために前もって宣言される。］

アップグレードは決して「率直な」終わりで起きないの超. もしあなたが書くなら

$bigger «*« $smaller
$smaller »*» $bigger

例外がスローされる、そしてもしあなたが書くなら

$foo »*« $bar

あなたは形が同一であることを必要としている、あるいは例外がスローされるだろう。

すべての超 dwimminess のために、もしスカラーが向こう側がリストを期待するところ（に・で）見いだされるなら、スカラーは1つのリストであると見なされる、要素が繰り返した* 時。

我々がプロセスに2つのリストを持っている途端に、我々はどのように要素を連絡に入れるべきか決めなければならない。 もし両側がその通りにやるなら、最終候補者リストは要素の適切な番号を作るために必要であるのと同じぐらい多くの時間が繰り返されるようにするだろう。

もしたった1つの側がその通りにやるなら、そちら側の上のリストはただその通りにやらない側にリストをはめるために栽培されるか、あるいは切り落とされるだろう。

dwim が配列の形から強制されているか、あるいは新興かどうかにかかわらず、 dwim するという側が選択された途端に、その通りにやる側の上の dwim 意味規則は常に存在する：

(@dwimmyside xx *).batch(@otherside.elems)

これは他の側に対応する次元と同じ長さリストを作成する。 扱うべき次元がもっとある場合に備えて、オリジナルの演算子はそれから回帰的にそれぞれの対応する1対の要素に適用される。

ここに若干の例がある：

(1,2,3,4) »+« (1,2)   # always error
(1,2,3,4) «+» (1,2)   # 2,4,4,6     rhs dwims to 1,2,1,2
(1,2,3)   «+» (1,2)   # 2,4,4       rhs dwims to 1,2,1
(1,2,3,4) «+« (1,2)   # 2,4         lhs dwims to 1,2
(1,2,3,4) »+» (1,2)   # 2,4,4,6     rhs dwims to 1,2,1,2
(1,2,3)   »+» (1,2)   # 2,4,4       rhs dwims to 1,2,1
(1,2,3)   »+» 1       # 2,3,4       rhs dwims to 1,1,1

それを見るもう1方法は必要に応じて多くとしてあるいはほとんど要素として生産しないようにその通りにやるリストの要素が索引作成済み法であるとはその要素の数だ。

その通りにやるリストのそれぞれの要素が今度はもし必要ならもう1つの次元の中に拡大されるかもしれない、それであなたが、例えば、その次元数にかかわらずマトリックスのすべての要素に1（人・つ）を加えることができることに注意を払え：

@fancy »+=» 1

その通りにやらない側、何でもどのようにするべきか知らないスカラー値Iterable OR素子のリストとして取り扱われるだろう、そして2項演算子のために他の側に同等のOR素子リストによって一致されなくちゃならない。 すなわち、ハイパー演算子が保証されている、からそのすべての引数が非リストの引数である対応するスカラー演算に変化している。

単項演算子を使って、 dwimmery が今までに起きないから、あなたが常に一つの演算数に率直な終わりを向けるとき：

 @negatives = -« @positives;

 @positions»++;            # Increment all positions

 @positions.»++;           # Same thing, dot form
 @positions».++;           # Same thing, dot form
 @positions.».++;          # Same thing, dot form
 @positions\  .»\  .++;    # Same thing, unspace form

 @objects.».run();
 ("f","oo","bar").>>.chars;   # (1,2,3)

メソッド呼び出しが本当に演算子、が挿入しない、それであなたが示すべきじゃない接尾辞であることを注意する« ドットの後に。

超演算子は回帰的にネストされた配列に定義されていて、そうだ：

-« [[1, 2], 3]               #    [-«[1, 2], -«3]
                             # == [[-1, -2], -3]

同じくその通りにやるインフィックスの dwimminess は繁殖する：

[[1, 2], 3] «+» [4, [5, 6]]  #    [[1,2] «+» 4, 3 «+» [5, 6]]
                             # == [[5, 6], [8, 9]]

いっそう一般には、その通りにやる超演算子が回帰的に何にでもマッチしているオブジェクトをもたらすIterable ロールがたとえオブジェクトであるとしてもそれ自身問題の演算子をサポートしない：

Bag(3,8,[2,Seq(9,3)],8) >>->> 1;         # Bag(2,7,[1,Seq(8,2)],7)
Seq(3,8,[2,Seq(9,3)],8) >>->> (1,1,2,1); # Seq(2,7,[0,Seq(7,1)],7)

特に、ノード種別を木に追い上げろIterable 意味規則使用可能訪問権：

$tree.».foo;        # short for $tree.foo, $tree.list: { .».foo }

もしすべてのノードが演算をサポートしないなら、あなたは呼び出しがオプションであることを明示するそれのフォームを必要とする：

$tree.».?foo;       # short for $tree.?foo, $tree.list: { .».?foo }
$tree.».*foo;       # short for $tree.*foo, $tree.list: { .».*foo }

あなたはあなた自身の超演算子を定義することを許されない、なぜならそれらが修正されたスカラー演算子から完全に一貫した意味規則 derivable を持つために想定されるから。 もしあなたが数学的なベクトル積を探しているなら、これはあなたがそれを見いだすであろうところじゃない。 超演算子はあなたのコードが parallelizable であるあなたがオプティマイザに約束することができる方法の1つだ。 （上の木訪問は副作用を持つことを可能にされる、しかし方法で何ででも訪問権のオーダーで依存することはそれらの副作用を意味することにとって誤っている。 デフォルトまでに、少なくとも、 DAG 意味規則の後に続くために必要とされる超木の訪問ではない。）

並列処理をすることができるハードウェアがないのでさえ、もしそれらがより低いレベルのコードに環状になっているオーバーヘッドを要因から外すことができるなら、超演算子は対応するスカラー演算子より速いかもしれないか、あるいはループ展開最適化を応用することができるか、あるいはオペランドの周知の型に基づいて、（そして同じくハイパー演算子が「繰り返し」の間で相互作用を約束しないのに対して、ループの中のすべての演算が副作用なしであることが知られていないなら、ループの対応するスカラー演算子が同じ約束をすることができないという事実に基づいて） MMD ディスパッチオーバーヘッドのいくらかあるいはすべてを要因から外すことができる

特に、2時に超演算子を挿入しろint あるいはnum 配列がただ型 - 調べてすべてのために呼び出すべき正しい関数が対になって、そしてさらに何でも迂回することができることに気付く一つの MMD ディスパッチをすることが必要であるだけだ、あるいは、適切な型の低レベルの入り口点があることを知られているとき、型強制エントリーがこのような関数を指し示す。 （そして同様に賛成だ単項int あるいはnum オペ。）

finalizable オブジェクトタイプのアプリケーション規模の分析が同じくこのような最適化に当てはまられることができるようにするかもしれないIntNumそしてそんなもの。 それがないので、部分的な MMD ディスパッチの実行時分析がオーバーヘッドを捜索して若干の MMD をセーブするかもしれない。 あるいは特定のオブジェクト配列が（彼・それ）ら自身の実行時型純粋を記録・追跡しさえして、そして部分的な MMD ディスパッチテーブルをキャッシュするかもしれない、それらがそれらを知っているときで超演算子で使われる可能性が高い。

そのすべてを越えて、「スカラーの配列」型がコンパイル時間に回帰的な hypers を必要としないことを知られている、それで演算は積極的に vectorized されることができる。

Hypers はハッシュにリストにと同様適用されるかもしれない。 この場合「dwimminess」が他のハッシュに存在しないキーを無視するべきかどうか言う、他方「非 dwimminess」がいずれかのハッシュにあるすべてのキーを使うように言う。 すなわち、

%foo «+» %bar;

あなたに鍵の交差点を与える、他方

%foo »+« %bar;

あなたにキーの組合を与える。 非対称の hypers は同じく有用だ；例えば、もしあなたが言うなら：

%outer »+» %inner;

ただ％すでに％の外の意志に存在する内面的なカギは結果に存在する。 しかしながら、あなたが欲するとは注意しろ

%outer »+=« %inner;

あなたが欲すると想定して、木の上に蓄積された統計値をパスするためにキーの組合を持つために、％外の。

たった1つのハッシュオペランドを持っている Unary ハッシュ hypers と2進法の hypers がハイパー演算子をただ値に適用するが、オリジナルのハッシュと同じキーのセットを持っている新しいハッシュ値を返すだろう。

なぜなら何でもまあジッパーでとまるから、あるいはその通りにやる超演算子は、何でも終わって傾く* その最終の要素をとって、そしてそれを繰り返すことによって、非常に拡張可能であると考えられる：

@array, *

何かのために短い同種のもの：

@array[0..^@array], @array[*-1] xx *

hypers があなたが処理がどんなオーダーで起きるか気にしないこと、ただ結果として生じている構造がインプットと一貫した形式で終わるだけことを約束することに注意を払え。 演算が parallelized されるであろうというシステムからの約束がない。 有効な平行化があなたが救うより多くの付加の仕事をしないで仕事を分割する若干の手段を必要とする。 これは構造物から構造物へと異なるだろう。 特に、無限の構造が完全に処理されることができない、そしてシステムは怠惰の需要の外に並列処理と釣り合うことを可能にされる。 例えば、リストを2つの等しい部分リストに分けることを望むアルゴリズムが、あなたが長さを計算することが常にできるというわけじゃないから、もしあなたが前もって長さを計算しなければならないなら、機能しないだろう。 種々のアプローチがとられることができる：要求次第並列に処理されるためにバッチを渡すこと、あるいはNプロセッサ、あるいは何でものセットで roundrobin に挟むこと。 限界、単純な、非パラレルの、項目ごとのいい加減な実装以内にある仕様で、けれども効率的にマルチコアを使うことがありそうもない。 性能要件の外で、もし、これらのアプローチのどちらがとられるかについて、アルゴリズムが依存するなら、誤っている。

縮小演算子

Any インフィックス演算子（連合しない演算子以外）がその演算を使って減量するリスト演算子を作成するために項ポジションで正方形の括弧によって囲まれることができる：

[+] 1, 2, 3;      # 1 + 2 + 3 = 6
my @a = (5,6);
[*] @a;           # 5 * 6 = 30

すべてのメタ演算子と同じように、スペースではないが metatoken が中に入るのを許した。

縮小演算子がリスト演算子と同じ優先を持っている。 実際、縮小演算子が本当はリスト演算子であって、そして1（人・つ）として訴えられる。 従って、あなたは2つの方法の1つで縮小演算子を実装することができる。 あるいはあなたは明示的なリスト演算子を書くことができる：

proto prefix:<[+]> (*@args) {
    my $accum = 0;
    while (@args) {
        $accum += @args.shift();
    }
    return $accum;
}

あるいはあなたは文通することに基づいたあなたに対する1が、おそらく通り過ぎてカリー化して演算子を挿入するシステム自（己・動）生成をそうさせることができる：

&prefix:<[*]> ::= &reduce.assuming(&infix:<*>, 1);
&prefix:<[**]> ::= &reducerev.assuming(&infix:<**>);

もし縮小演算子が別に定義される、インフィックス演算子から、それが演算子が使ったと同じ方法を関連づけなくちゃならないなら：

[-] 4, 3, 2;      # 4-3-2 = (4-3)-2 = -1
[**] 4, 3, 2;     # 4**3**2 = 4**(3**2) = 262144

なぜならチェーン - 連合の演算子（好む<）、引数がそうであるすべてで、一緒に、とるただあなたが、明示的に：それを書き上げたかのように

[<] 1, 3, 5;      # 1 < 3 < 5

もし2以下の引数が与えられるなら、ディスパッチが引数が与えられるものは何ででもまだ試みられる、そして2以下の引数を取り扱うことはそのディスパッチのレシーバー次第だ。 proto リスト演算子定義が最も一般的だ、それであなたが型に依存して1つの引数のケースを扱う異なった方法を定義することを許されることに注意を払え：

multi prefix:<[foo]> (Int $x) { 42 }
multi prefix:<[foo]> (Str $x) { fail "Can't foo a single Str" }

しかしながら、ゼロ引数のケースはディスパッチに上に、型情報がないから、このように定義されているはずがない。 識別情報値を指定することを望む演算子が、ゼロ引数をとる多変形を指定することによって、そうするべきだ：

multi prefix:<[foo]> () { 0 }

組込み演算子の間で、[+]() 0を返すそして[*]() 例えば1を返す。

デフォルトまでに、もし引数、組込みが減らす（の・もの・人）があるなら、演算子がそれを引数リターンする。 しかしながら、このデフォルトは演算子のための感覚を好ませない< これらの種類の演算子がいっそう有意義な何かを返すために一つの引数のケースに負担をかけ過ぎるように、それら撮影と同じ型を返さない. 連鎖法と矛盾しないために、意味規則、すべて比較演算子が戻るBool::True なぜなら1あるいは0の引数。

権限：が同じくコンマ演算子の減算演算子を作る。 これはただリスト演算子形に過ぎないのcircumfix:<[ ]> 匿名の配列生成するもの：

[1,2,3]     # make new Array: 1,2,3
[,] 1,2,3   # same thing

組込みが減量する、演算子が次の識別情報値を返す：

[**]()      # 1     (arguably nonsensical)
[*]()       # 1
[/]()       # fail  (reduce is nonsensical)
[%]()       # fail  (reduce is nonsensical)
[x]()       # fail  (reduce is nonsensical)
[xx]()      # fail  (reduce is nonsensical)
[+&]()      # -1    (from +^0, the 2's complement in arbitrary precision)
[+<]()      # fail  (reduce is nonsensical)
[+>]()      # fail  (reduce is nonsensical)
[~&]()      # fail  (sensical but 1's length indeterminate)
[~<]()      # fail  (reduce is nonsensical)
[~>]()      # fail  (reduce is nonsensical)
[+]()       # 0
[-]()       # 0
[~]()       # ''
[+|]()      # 0
[+^]()      # 0
[~|]()      # ''    (length indeterminate but 0's default)
[~^]()      # ''    (length indeterminate but 0's default)
[&]()       # all()
[|]()       # any()
[^]()       # one()
[!==]()     # Bool::True    (also for 1 arg)
[==]()      # Bool::True    (also for 1 arg)
[before]()  # Bool::True    (also for 1 arg)
[after]()   # Bool::True    (also for 1 arg)
[<]()       # Bool::True    (also for 1 arg)
[<=]()      # Bool::True    (also for 1 arg)
[>]()       # Bool::True    (also for 1 arg)
[>=]()      # Bool::True    (also for 1 arg)
[~~]()      # Bool::True    (also for 1 arg)
[!~~]()     # Bool::True    (also for 1 arg)
[eq]()      # Bool::True    (also for 1 arg)
[!eq]()     # Bool::True    (also for 1 arg)
[lt]()      # Bool::True    (also for 1 arg)
[le]()      # Bool::True    (also for 1 arg)
[gt]()      # Bool::True    (also for 1 arg)
[ge]()      # Bool::True    (also for 1 arg)
[=:=]()     # Bool::True    (also for 1 arg)
[!=:=]()    # Bool::True    (also for 1 arg)
[===]()     # Bool::True    (also for 1 arg)
[!===]()    # Bool::True    (also for 1 arg)
[eqv]()     # Bool::True    (also for 1 arg)
[!eqv]()    # Bool::True    (also for 1 arg)
[&&]()      # Bool::True
[||]()      # Bool::False
[^^]()      # Bool::False
[//]()      # Any
[min]()     # +Inf
[max]()     # -Inf
[=]()       # Nil    (same for all assignment operators)
[,]()       # []
[Z]()       # []

ユーザー定義の演算子が（彼・それ）ら自身の識別情報値を定義するかもしれない、しかし明示的な識別情報プロパティがない。 値は0 - arg の振る舞いでの暗黙が、それほど数学的なコードが見い出すことを望むという状態で、演算のための値が呼び出すことができる識別情報を和らげるということだprefix:["[$opname]"]() それを発見するために。

減算演算子として何か他の非インフィックスの関数を呼び出すために、あなたはインフィックスフォームでエイリアスを定義してもよい。 たとえ aliasedな関数がそれをリストと解析したであろうとしても、インフィックスフォームは右の引数を項目と解析するだろう：

&infix:<dehash> ::= postcircumfix:<{ }>;
$x = [dehash] $a,'foo','bar';  # $a<foo><bar>, not $a<foo bar>

代わる代わる、ただあなた自身のものを定義しろprefix:<[dehash]> ルーチン。

それ、に注意するから減量するリスト演算子だ、引数リストはリストコンテキストで評価される. そのために次のことは正しくないだろう：

$x = [dehash] %a,'foo','bar';

あなたはその代わりに持っているだろう、から1（人・つ）を言え：

$x = [dehash] \%a,'foo','bar';
$x = [dehash] %a<foo>,'bar';

プラス面では、これはスターなしでうまくいく：

@args = (\%a,'foo','bar');
$x = [dehash] @args;

同じく、リストコンテキストが内部の配列を平らにして、そして傾くという事実から、減少した割り当てが特別でない構文的な dwimmery をする、そして従ってただスカラー割り当てだけがサポートされることは続く。 そのために

[=] $x, @y, $z, 0
[+=] $x, @y, $z, 1

同等であるそうすること

$x = @y[0] = @y[1] = @y[2] ... @y[*-1] = $z = 0
$x += @y[0] += @y[1] += @y[2] ... @y[*-1] += $z += 1

よりむしろ

$x = @y = $z = 0;
$x += @y += $z += 1;

（そして、実際、後者はすでにとにかく表明することが容易で、そしていっそう明らかに途方もない。）

同様に、（ショート演算子のような）マクロの thunk - izing 特徴を持っているリスト - 結合の演算子がそれらのマクロのような特徴を失う。 権限：発言権

[||] a(), b(), c(), d()

最初の真の結果、しかしリストの評価が、意味規則ではなく、リストの意味規則までにコントロールされる復帰に||.

大部分の人たちが減量する、演算子が単純なスカラ値を返す、そして従って、項目あるいはリストコンテキストで評価されてそれらが存在するかどうか気にしない。 しかしながら、他のリスト演算子と関数と同じように、減算演算子が自動的に、あなたがインフィックスにそれを使うかもしれないように、リストコンテキストの中に補間挿入されるであろう傾きを、スカラーと同様、リストの上に稼働する演算子リターンするかもしれない：

my ($min, $max) = [minmax] @minmaxpairs;

縮小メタ演算子の変形がおおかたリストを作り出すことを保証される；最終の結果とともにいい加減にすべての中間結果を生成するために、あなたは演算子をバックスラッシュすることができる：

say [\+] 1..*  #  (1, 3, 6, 10, 15, ...)

偶然のトライアングルではないの視覚的写真。 リストの三角形のリストを生産するために、あなたは「三角形のコンマ」を使うことができる：

[\,] 1..5
[1],
[1,2],
[1,2,3],
[1,2,3,4],
[1,2,3,4,5]

もし中間のあいまい性があるなら三角形減量するそしてバックスラッシュから始まる2項演算子、2項演算子が選ばれる、そして付加のバックスラッシュが対応する三角形の人たちが減量することを示す. インフィックスを定義している結果としてバックスラッシュで始まっている演算子infix:<\x> ねえ、それ以来、ある特定の三角形の簡約演算子を書くことを不可能にするだろう[\x] 標準の縮小を意味するだろうのinfix:<\x> 三角形の縮小ではなく、演算子のinfix:<x>. 　これはささいな問題であるとみなされる。

演算子を鎖でつなぐことについての三角形の縮小が常に1つ以上から成り立つTrue 値が0かそれ以上によって後に続かれるFalse 値。

Cross 演算子

クロスメタ演算子、X存在するかもしれない、そしてそれに続いて何でも演算子を挿入する. それはすべての普通の（人たち・もの）によって同じぐらいリターンされるそのリスト引数の組分けの向こう側に修正された演算子を応用するinfix:<X> 演算子。 すべての生み出されたクロス演算子はリストインフィックス優先の（こと・もの）であって、そしてリスト結合性だ。

フォームを連結している文字列はそうだ：

<a b> X~ 1,2           #  'a1', 'a2', 'b1', 'b2'

X~ 演算子 desugars 値：

(<a b>; 1,2).crosswith(&[~])

それは今度は意味する

(<a b>; 1,2).cross.lol.map { .reduce(&[~]) }

それに注意しろ

<a b> X~ 1,2 X+ 3,4

何かが好むことを意味することができた

(<a b>; 1,2; 3,4).cross.lol.map { .reduce({$^a ~ $^b + $^c}) }

けれどもそれは連合じゃない状態でそうな同一でないリスト結合性演算子が見なした（とき・から・につれて・ように）現在非合法だ。 権限：が、しかしながら、常に括弧を明示的であるために使う：

<a b> X~ (1,2 X+ 3,4)

フォームを連結しているリスト、X,使われるとき、これが好きだ：

<a b> X, 1,2 X, <x y>

生産する

('a', 1, 'x'),
('a', 1, 'y'),
('a', 2, 'x'),
('a', 2, 'y'),
('b', 1, 'x'),
('b', 1, 'y'),
('b', 2, 'x'),
('b', 2, 'y')

X, 演算子が多分いっそう明らかに書かれるけれどもX[,]. 　しかしながら、このリスト形式はショートカット、普通のインフィックスを持つのに十分よくあるX 以前に記述された演算子。

汎用書式、何のためにも存在する、突然変異しないインフィックス演算子が使われるかもしれない。

1,2 X* 3,4               # 3,4,6,8

（それに注意しろ<== そして==> すべての代入演算子と同様、突然変異することと見なされる。）

もし原因となっている演算子が非を関連づけるなら、クロス演算子もそうだ：

@a Xcmp @b Xcmp @c       # ILLEGAL
@a Xeq @b Xeq @c         # ok

実際、けれどもX 演算子は統語論上連合のすべてのリストだ、原因となっている演算子はそれ自身の結合性で常に適用されている、対応する人たちが減量するのとちょうど同じ（ように・時に）、演算子が十分だろう。

その唯一の最初項に注意すのX 演算子は適度に無限のリストであるかもしれない。

すべてのリストはフラットであると考えられる；多次元のリストが、最初の次元を唯一の次元として扱うことによって、扱われる。

演算子をジッパーで締めろ

活気メタ演算子、Z存在するかもしれない、そしてそれに続いて何でも演算子を挿入する. それはすべての普通の（人たち・もの）によって同じぐらいリターンされるそのリスト引数の組分けの向こう側に修正された演算子を応用するinfix:<Z> 演算子。 すべての生み出された zip 演算子はリストインフィックス優先の（こと・もの）であって、そしてリスト結合性だ。

フォームを連結している文字列はそうだ：

<a b> Z~ 1,2           #  'a1', 'b2'

Z~ 演算子 desugars 値：

(<a b>; 1,2).zipwith(&[~])

それは今度は意味する

(<a b>; 1,2).zip.lol.map: { .reduce(&[~]) }

それに注意しろ

<a b> Z~ 1,2 Z+ 3,4

何かが好むことを意味することができた

(<a b>; 1,2; 3,4).zip.lol.map: { .reduce({$^a ~ $^b + $^c}) }

けれどもそれは連合じゃない状態でそうな同一でないリスト結合性演算子が見なした（とき・から・につれて・ように）現在非合法だ。 権限：が、しかしながら、常に括弧を明示的であるために使う：

<a b> Z~ (1,2 Z+ 3,4)

［推測：もう1つのアプローチが寄付を伴うだろうX そしてZ メタ演算子オリジナルの演算子の優先に対応しているリスト演算優先の中の subprecedence 、それでそれZ~ そしてZ+ 実際に、リスト演算優先の中で異なったオペレータ順位文法を持て。 それから、あなたが言ったかのように、上の（人たち・もの）は解析をするだろう<a b> Z~ ( 1,2 Z+ 3,4> )、リスト以外ピュッという音よりしっかりと、カンマで、リストインフィックス優先においてまだ解析をするだろう。 （これは実際にかなり些細だろう、から、我々がどのように文字列として我々の優先を表すかという状況で、実装しろ。） 同じく、説明することが複雑であるけれども、中で subprecedence しろZ 正確に世間知らずのユーザーが期待するものであるかもしれない。］

フォームを連結しているリスト、Z,使われるとき、これが好きだ：

<a b> Z, 1,2 Z, <x y>

生産する

('a', 1, 'x'),
('b', 2, 'y')

Z, 演算子が多分いっそう明らかに書かれるけれどもZ[,]. 　しかしながら、このリスト形式はショートカット、普通のインフィックスを持つのに十分よくあるZ 以前に記述された演算子。

汎用書式、何のためにも存在する、突然変異しないインフィックス演算子が使われるかもしれない。

1,2 Z* 3,4               # 3,8

（それに注意しろ<== そして==> すべての代入演算子と同様、突然変異することと見なされる。）

もし原因となっている演算子が非を関連づけるなら、クロス演算子もそうだ：

@a Zcmp @b Zcmp @c       # ILLEGAL
@a Zeq @b Zeq @c         # ok

実際、けれどもZ 演算子は統語論上連合のすべてのリストだ、原因となっている演算子はそれ自身の結合性で常に適用されている、対応する人たちが減量するのとちょうど同じ（ように・時に）、演算子が十分だろう。

それに注意する、同じじゃないX 演算子、すべて項のZ 演算子がそうするかもしれない、合理的な be の無限のリスト、それ以来ジッパーでとまることはいい加減だ。

すべてのリストはフラットであると考えられる；多次元のリストが、最初の次元を唯一の次元として扱うことによって、扱われる。

連続的な演算子

連続メタ演算子、Sどんな非 fiddly 2項演算子によってでも後に続かれるかもしれない. それは明白な何もあるいは暗黙の平行を隠して、そしてオプティマイザがオペランド評価を再注文するのを阻止する。 「S」は連続的で、連続的な、同時の、ショート、シングルスレッドと Safe のために地位と考えられることができる。 とりわけ。 特に、我々はそうしたことがあり得る：

a S& b S& c         short-circuited AND junction
a S| b S| c         short-circuited OR junction
a S^ b S^ c         short-circuited XOR junction
a S»op« b           single-threaded hyperop
a SX* b             single-threaded X*
a SX[*] b           single-threaded X*
a S[X*] b           single-threaded X*
a S+ b              suppress arg reordering by ignorant optimizer

このメタ演算子はそのベース演算子として同じ優先と結合性を持っている。 コンパイラは何でも捨てることが自由だS 1インチのように、証明可能なように冗長なメタ演算子S||. 　コンパイラは直感で知ることが自由だS 何に関してもそれがさもなければ演算子の意味規則を変えない周知の激しやすい演算数に関する演算子。

［推測の：メタ演算子が内側から外部まで観念的に応用であるときから時、メタ演算子の保有、オーダー、を直列化して、そして逆にすることについての意味規則：

a SR/ b             evaluates b, then a, then does b/a
a RS/ b             evaluates a, then b, then does b/a
a RSR/ b            evaluates b, then a, then does a/b

・・・多分。 同じく他の方法で．．．そのすべてを論じることができる。］

メタ演算子をネストすること

どこでもあなたは普通のインフィックス演算子を使ってもよい、あなたはインフィックスを使ってもよい、演算子が意味を同じを持っている角カッコで囲った。 （空白文字が許されない。） 従ってあなたは正方形の括弧を metatoken の中でさもなければ誤解されるかもしれない連続のあいまいさを排除することか、あるいは、 metatoken に多数のメタ演算子があるとき、特定の適用順序を強制するために使うかもしれない：

@a [X+]= @b
@a X[+=] @b

metatokens が決して内部の空白文字であいまいさを排除されないかもしれないから、演算子とその関連づけられたメタ演算子がコンパイラにもしそうでなければさえ、リーダーに、紛らわしいであろう文字を共有するとき、括弧の使用は特に有用だ：

@a >>>>> $b        # huh?
@a >>[>]>> $b      # oh yeah

Any インフィックス関数が直接後で正方形の括弧を使って標準のロング形式あるいは短縮フォームによって名詞として参照されるかもしれない& シギル：

&infix:<+>
&[+]

これは関数出願のために都合が良い：

1, 1, &[+] ... *       # fibonacci sequence
sort &[Rleg], @list    # reverse sort as strings

&[op] たとえそれが根本的に variadic リスト - 結合性演算子と定義されるとしても、形式が常に演算子の2進法の関数を参照する。

演算子、しかしそれらが演算子を用いて通常、通り過ぎて作成されて存在するかもしれない単項の賛成の対応する形式がない*：

sort -*, @list        # sort reversed numerically

Declarators

変数宣言子のリストは拡張したからmy そしてour 次のものを含む：ために

my $foo             # ordinary lexically scoped variable
our $foo            # lexically scoped alias to package variable
has $foo            # object attribute
state $foo          # persistent lexical (cloned with closures)

Variable 宣言子のようmy 今シグネチャーをそれら引数であると思え。 （関数シグネチャーの構文はいっそう完全に S06 で記述される。）

シグネチャーの周りの括弧はシングルをその関連づけられた型で進んだ変数、トレイトと初期化演算子だと宣言する単純な宣言のために除かれるかもしれない：

my Dog $foo is woof = 123;    # okay: initializes $foo to 123
my (Dog $foo is woof = 123);  # same thing (with explicit parens)
my :(Dog $foo is woof = 123); # same thing (full Signature form)

constant 宣言詞がいずれかの変数を宣言することができるか、あるいは定数をコンパイル時と名付ける：

constant $foo = 1;      # compile-time constant variable
constant bar = 2;       # compile-time constant symbol

なぜならそれは「型」スペースに名前を宣言することができるから、constant 宣言詞が、シグネチャーを使って、どちらがあいまいであるであろうかについて意志表示しないかもしれない。

それぞれの宣言詞が（あなたがどの宣言詞を使うかについて、初期化のタイミングが今度は依存するコンテナの自然の生涯スコアの上に依存するから、標準の割り当てと混同されるべきじゃない）等号に引き続いて初期化演算子を飲むことができる。

my $foo = 1;         # happens at the same time as normal assignment
our $foo = 1;        # happens at INIT time
has $foo = 1;        # happens at BUILD time
state $foo = 1;      # happens at START time
constant $foo = 1;   # happens at BEGIN time

（それほど意味規則的に注意するのour 同時に初期化が起きる Perl 5 と異なった as a my. 　あなたが持つであろう Perl 6 での同じ効果に言うようにさせるために「(our $foo) = 1;」その代わりに。）

もしあなたがコンテナを初期化しないなら、それはその自然の生涯スコアの始まりに未定義に始まる。 （言い換えれば、あなたは古い Perl 5 トリックを使うことができないの「my $foo if 0」静的な変数を得るために、からmy 変数はその前の値を維持するよりむしろ Perl 6 に毎回完全にイニシャライズされていないように始まる。） 未定義のコンセプトをサポートしないネイティブの整数コンテナがその代わりに0に初期化されるべきだ。 （浮動小数点のコンテナがデフォルトによって初期化される Native NaN.） タイプされたオブジェクトコンテナが正しい型の未定義の型オブジェクトを含んでい始める。

リスト - コンテキスト擬似割り当てがシグネチャーデフォルトでではなく、単純な宣言のためにサポートされる：

my @foo = 1,2,3;      # okay: initializes @foo to (1,2,3)
my (@foo = 1,2,3);    # wrong: 2 and 3 are not variable names

括弧が除かれる、あなたが何でも使うかもしれないとき、割り当て演算子を挿入しろ= 初期化演算子として。 このような場合、左側はインフィックス演算子について変数のプロトタイプオブジェクトだろう：

my Dog $fido .= new;      # okay: a Dog object
my Dog $fido = Dog.new;   # same thing
my Dog $fido = $fido.new; # wrong: invalid self-reference
my (Dog $fido .= new);    # wrong: cannot use .= inside signature

極めて少数しか突然変異している演算子が、しかしながら、型から型オブジェクトの上に意味をなさない、オブジェクトが一種の未定義のオブジェクトであるとは、注意しろ。 （識別情報値と一緒のそれらの演算子は同じぐらい上に指摘された例外だ。）

括弧が常に、多数のパラメータを宣言するとき、使われなくちゃならない：

my $a;                  # okay
my ($b, $c);            # okay
my ($b = 1, $c = 2);    # okay - "my" initializers assign at runtime
my $b, $c;              # wrong: "Use of undeclared variable: $c"

宣言詞とシグネチャーの間に起こっている型がそれぞれの変数の中に配られる：

my Dog ($b, $c);
my (Dog $b, Dog $c);    # same thing

［30次のことがおそらく S06 に属する。］ 作成している賛成の構文Signature パーサーがすでに1（人・つ）を期待していないオブジェクトがそうだ：

:(Dog $a, *@c)

これはこのように使われるかもしれない：

my $sig = :(Dog $a, *@c);

シグネチャーが宣言子の後にそんなものに予想されるけれどもmysubmethodruleなど. このような宣言子でコロンは除かれるかもしれない。 けれどもそれはそれを使うために同じく正当だ：

my :($b, $c);               # okay
sub foo :($a,$b) {...}      # okay

-> 「pointy ブロック」トークンが同じくシグネチャーを開始する、しかしこの場合あなたはコロンと括弧両方を除かなくちゃならない。 例えば、もしあなたがループについて「変数を輪にしろ」を定義しているなら、ブロックしろ：

for @dogpound -> Dog $fido { ... }

もしシグネチャーがそうであるなら割り当てたから（宣言されるか否かにかかわらず、あるいはコロン形式）、シグネチャーは変数と割り当ての普通のルールが適用する左辺値のリストに変換されるが、右側と割り当ての評価が起きること以外時間に決定する宣言詞によって. （でmy これは常に普通の割り当てが起きるであろう時だ。） もしシグネチャーが割り当てに変換するにはあまりにも複雑であるなら、コンパイル時エラーが発生する。 シグネチャーへの割り当てが、それほど、普通の割り当てと同じ項目 / リスト特質を作る

my $a = foo();      # foo in item context
my ($a) = foo();    # foo in list context

もしシグネチャーが引数にバインドされるなら、シグネチャーが関数のために、それ以外、関数呼び出しの場合と異なり仮パラメータであるかのように、リスト、それから引数をバインドすることが進む、パラメータはバインドされるrw デフォルトによってよりむしろreadonly. 　上にバインディングを見ろ。

それに注意しろtemp そしてlet それら結果がただランタイムに起きるだけであるから、変数宣言子じゃない。 そのために、それらが普通の左辺値オブジェクトをそれら引数であると思う。 もっと多くの詳細については S04 を見ろ。

変数宣言子じゃない多くの他の宣言子がある。 これらは両方の型宣言子を含む：

package Foo
module Foo
class Foo
role Foo
subset Foo
enum Foo
constant Foo

そしてコード宣言子：

sub foo
method foo
submethod foo
multi foo
proto foo
macro foo
quote qX
regex foo
rule foo
token foo

これらはすべてそれらの使用を持って、そして次の Synopses に説明される。

それほどそれ以来注意しろconstant （本質的に一つの値で型を宣言している）型宣言詞と解析される、それは先頭で実際に範囲宣言詞を要することができる：

my constant companion = 'Fido';
has constant $.pi = 22/7;
state constant $latch = snapshot(); # careful with this!

しかしながら、一定の宣言詞はコンパイラがインライン化することができる値を作成するように意図される、それでそれは常に BEGIN 時間にその値を評価する。 それで付加の範囲宣言詞が値がどこ（で・に）記憶されるか、そしてその記憶域がいつ初期化されるか言うかもしれない間に、それはインスタンスからインスタンスまでそれの値を変えることができない。 一般に、もしあなたが範囲宣言詞の標準の生涯にわたってさまざまじゃない何かを欲するなら、それを読み取り専用値使用方法に初期化しろ::= 定数としてそれを宣言するよりむしろ。 それで範囲宣言詞が使われるたびに、それは値を異なった読み取り専用に初期化することができる：

state $latch ::= snapshot();  # each clone gets its own value of $latch

引数 List が補間挿入される

5が使用によって関数の引数リストの補間を強制した Perl & 接頭辞。 それほどその代わりに、 Perl 6 のそのオプション is no longer available | 前置演算子が補間回路として、その演算数を配役することによって、そうするのに役立つCapture オブジェクトとキャプチャの部分を現在の引数リストに挿入すること。 この演算子は補間挿入されるために使われることができるArray あるいはHash 現在の呼び出しに打ち込んでいて、同じぐらいそれぞれ守備の、そして引数という名前の。

結果として生じている引数がまだサブルーチンのシグネチャー、しかしプレゼンスに従わなくちゃならない注目| その引数（そして何のためにでも次の引数）の間ランタイムまでそのテストを延期する：

my $args = \(@foo, @bar);
push |$args;

同等の値：だ

push @foo, @bar;

しかしながら、

my $args = \(@foo: @bar);
push |$args;

その代わりに同等の値：だ

@foo.push(@bar);

| その引数を回す中にArrayけれども、その代わりに直接その引数を変換する中にCapture：

my @args = \$x, 1, 2, 3;
say |@args;     # say(\$x, 1, 2, 3);

これのために、|%args 常に名指された引数、を生産するそして|@args 常に位置の引数を生産する。

リストコンテキスト、でScalar 持ちこたえるArray オブジェクトが平らにならない。 従って

$bar = @bar;
@foo.push($bar);

ただシングルを押すArray 反対しろ@foo. 　権限：がこれらの方法の1つで明示的にそれを平らにする：

@foo.push(@$bar);
@foo.push($bar[]);
@foo.push(|$bar);

素晴らしい人たちがインチを配列するから、それらの3つのフォームは機能するpush「sシグネチャーが平らになるArray リスト引数の中へのオブジェクト。

最初の2つのフォームが同じくあなたを許すとは、注意しろ、から割り当てにリストコンテキストを指定しろ：

@$bar = 1,2,3;
$bar[] = 1,2,3;

長い間そうである必要がある展開式が配列に左辺値を投げる、形式が左辺値の「arrayness」を近くしておくことができる第2が割り当て演算子を投げる：

$foo.bar.baz.bletch.whatever.attr[] = 1,2,3;

空き[] そして.[] 後置演算子が、要素を返さない1次元のゼロのスライスとしてではなく、配列全体を返しているゼロ - 次元の添え字として解釈される。 同じく賛成だ{} そして.{} ハッシュに、同様に as the <>.<>«»そして.«» 一定の、そしてスライス添え字指定フォームを補間挿入している。

| 演算子がいい加減に賛成に補間挿入されるArray そしてRange オブジェクト。 5がする Perl のような直前の書き入れを得て、付け加えることeager リスト演算子：

func(|(1..Inf));       # works fine
func(|eager 1..Inf);   # never terminates (well, actually...)

関数の帰りの値を補間挿入するために、あなたは言うことができる：

push |func();

このような引数リストの中で、あなたが言ったかのように、関数リターン値はそれら各地の中に自動的に分解だ：

my $capture = \(func());
push $$capture: @$capture, %$capture;

あるいは何かそのようなもの。 | それからコンテキストに適切に依存している種々の地域を扱う。 インボカントがただ外の関数呼び出しに最初の引数として意味をなすだけだ。 どこでもほかにただ差し込まれたインボカントがそのリストの前部において、そのコロンがコンマに戻るかのように位置の引数になる。

もしあなたがすでにキャプチャ変数を持っているなら、あなたはすぐに使ってそのすべてのビットを補間挿入することができるprefix:<|> 演算子：

my (|$capture) := func();
push |$capture;

並列に配列を横断する

多数の配列にわたって平行した繰り返しをサポートするために、 Perl 6 はそうしたzip それがリストを作る関数Seq 2かそれ以上の配列の要素からのオブジェクト。 これがリストとして作用する普通のリストコンテキストでCaptures そして自動的に平らになる。

for zip(@names; @codes) -> $name, $zip {
    print "Name: $name;   Zip code: $zip\n";
}

zip インフィックス同義語、を持つZ 演算子。

しかしながら、明示的に多次元のリストコンテキストで、連続は subarrays に変わる、そしてそれぞれの要素がそれからシグネチャーによって包みから取り出されなければならないだろう：

for lol(zip(@names; @codes)) -> [$name, $zip] {
    print "Name: $name;   Zip code: $zip\n";
}

デフォルトによってzip 関数が最も短いリストの終わりに読む、しかし最終候補者リストが常にパッティングによって独断的に延長されるかもしれない* 決勝戦の後に値、どちらかは必要に応じて多くの回数として最終の値を繰り返す。 もし、最終候補者リストのためにデフォルト値を供給する代わりに、あなたがただ欠けている項目、使用を省略することを望むならroundrobin その代わりに：

for roundrobin(@queue1; @queue2; @queue3) -> $next {
    ...
}

Minimal 空白文字 DWIMmery

空白文字が配列あるいはハッシュ添え字の括弧開始、あるいは引数リストの冒頭の括弧の前にもう許されない。 すなわち、：

@deadbeef[$x]         # okay
@a       [$b]         # WRONG
%monsters{'cookie'}   # okay
%people  {'john'}     # WRONG
saymewant('cookie')   # okay
mewant   ('cookie')   # WRONG

この制限のいくつかの有用な副作用の1つが括弧がコントロール構造の状態の頃にもう必要とされないということだ：

if $value eq $target {
    print "Bullseye!";
}
while $i < 10 { $i++ }

それは添え字を一列に並べるために、しかしながら、まだ可能である、そして他の後置演算子が（S02 参照）通り過ぎて明示的に unspace 構文を使っている：

 %squirrels{'fluffy'} = Squirrel.new;
 %monsters.{'cookie'} = Monster.new;
 %beatles\.{'ringo'}  = Beatle.new;
 %people\ .{'john'}   = Person.new;

空白文字は中に入っている、概要が何の間にもキーワードと添え字あるいは関数引数を開始していない括弧を開始している何でも必要とした。 括弧によって直接後に続かれた Any キーワードがその代わりに関数呼び出しと思われるだろう。

if $a == 1 { say "yes" }            # preferred syntax
if ($a == 1) { say "yes" }          # P5-ish if construct
if($a,$b,$c)                        # if function call

それは賛成で可能だif() 同じくマクロ呼び出しに訴えるために、しかしもしそうであるなら、それprefix:<if> マクロよりむしろstatement_control:<if> マクロ。

連続ポイント

ある特定の演算子がシーケンスポイントを供給することを保証される。 いずれかの thunk （いい加減なかなりのコード）が何か他の評価の結果に基づいて条件付きで評価されるときはいつでも、シーケンスポイントは保証されている、それでショートと条件演算子はすべてシーケンスポイントを提供する。

ある特定の他の演算子が、 junctional 演算子、超演算子と飼料演算子を含めて、シーケンスポイントの欠如を保証する。 これらの演算子はあなたがコードのビットだと見なす編集者に、もしそれらのようであるなら、それらが並列に稼働することができるように、お互いに依存しないことを約束する。

多数の演算子（そんなものけれども+）中央の中で立ち往生していて、そして明日ではなく今日であるが、かもしれない連続的な振る舞いを示すかもしれない. これらの演算子の1つを連続的であるか、あるいは平行した振る舞いに頼るプログラムが誤っている。 我々が parallelizing オプティマイザを書いている人々からもっと多くのフィードバックを受けとる（とき・から・につれて・ように）、我々は2つの指定されたセットの1つの中に分類していない演算子について種々であると分類するべき権利を保留する。 （我々はこれらの3セットの演算子に良い名前を与える必要がある。）