式

この章では、文の構成要素となる式について定義する。

演算子の定義に関する規則

演算子の優先順位

演算子の優先順位は、解析表現の定義に基づいて定める。 一つの解析表現に複数の演算子が現れる場合、それらの演算子の優先順位は等しい。 ある解析表現 e₁ の中に非終端記号として別の解析表現 e₂ が含まれる場合、e₂ で定義する演算子の優先順位は e₁ で定義する演算子の優先順位よりも高い。

演算子の結合法則

同じ優先順位の中置二項演算子が続けて用いられるとき、それらの演算子を どの順番で適用するかという問題が生じる。#Script では、全ての中置二項演算子は 左結合と右結合のどちらかに分類され、演算子の適用順位は明確に定められる。

同じ優先順位の中置二項演算子同士において、先に書いてあるものから順に演算子を 適用するとき、その中置二項演算子は左結合 (left-associative)であると言う。例えば、式 1 * 2 * 3 において、演算子 * は左結合であるため、この式は (1 * 2) * 3 と同じように評価する。

同じ優先順位の中置二項演算子同士において、後に書いてあるものから順に演算子を 適用するとき、その中置二項演算子は右結合 (right-associative)であると言う。例えば、式 1 ^ 2 ^ 3 において、演算子 ^ は右結合であるため、この式は 1 ^ (2 ^ 3) と同じように評価する。

前置演算子および後置演算子では、結合法則に関する問題は起こらない。#Script では、前置演算子と後置演算子が同じ優先順位になることは無い。 同じ優先順位の前置演算子または後置演算子を続けて用いるとき、 それらは単純に被演算子に最も近い演算子から順に適用する。

基本式

基本式は、式の最小構成要素である。

Primary

This

Precision

VoidLiteral

NullLiteral

BooleanLiteral

Parenthesized

StringLiteral

FloatLiteral

IntegerLiteral

InfinityLiteral

NaNLiteral

#? Identifier

# (IntegerLiteral / #? D)

Function

Tensor

@this 値

This

@this KD

キーワード @this の評価結果は、[[現在の実行コンテクストの @this 値]] である。

精度参照

Precision

@prec KD

キーワード @prec の評価結果は、以下のような参照を値とする正常終了の結果である。

この参照に対する check-reference-value の処理内容は、以下の通りである:

1. [[初期の Boolean.true]] を返す。

この参照に対する get-reference-value の処理内容は、以下の通りである:

1. 現在の実行コンテクストのデフォルトの精度を p として、実数 p を表す Float オブジェクトを P とする。ここで P の Float オブジェクトとしての精度は p の精度 (実行環境が原始制限実数型の値として p を扱っている精度) とする。
2. [[P]] を返す。

この参照とオブジェクト O に対する set-reference-value の処理内容は、以下の通りである:

1. O が Real オブジェクトでなければ、新しい TypeError のインスタンスを投げる。
2. O が表している実数が 0 以下ならば、新しい OutOfRangeError のインスタンスを投げる。
3. O が表している実数に出来るだけ近い原始制限実数型の値を p とする。ただし、O の表す値を有限の 原始制限実数型の値として表せない場合は、新しい OverflowError のインスタンスを投げる。
4. 現在の実行コンテクストのデフォルトの精度を p に変更する。
5. [[O]] を返す。

この参照に対する delete-reference-value の処理内容は、以下の通りである:

1. 新しい UnsupportedOperationError のインスタンスを投げる。

Void リテラル

VoidLiteral

@void KD

Void リテラルの評価結果は、[[初期の Void.void]] である。

Null リテラル

NullLiteral

@null KD

Null リテラルの評価結果は、[[初期の Null.null]] である。

真偽値リテラル

BooleanLiteral

@true KD

@false KD

真偽値リテラル @true の評価結果は、[[初期の Boolean.true]] である。

真偽値リテラル @false の評価結果は、[[初期の Boolean.false]] である。

括弧式

Parenthesized

LeftParen Expression RightParen

LeftParen

( D

RightParen

) D

括弧式を使うと、Expression を Primary として扱うことができる。

Parenthesized: LeftParen Expression RightParen の評価は、Expression を評価し、その結果を返す。

文字列リテラル

Primary: StringLiteral の評価結果は、[[その文字列リテラルが表す Unicode 文字列を内容とする文字列オブジェクト]] である。

整数リテラル

Primary: IntegerLiteral の評価結果は、以下のような Number オブジェクトを値とする 正常終了の結果である:

整数リテラルに ImaginaryMark が含まれていない場合

このリテラルが表す整数値を表す Integer オブジェクトが結果となる。

整数リテラルに ImaginaryMark が含まれている場合

結果の値は Complex オブジェクトである。このオブジェクトの re プロパティの値は 0 を表す Integer オブジェクトであり、im プロパティの値は、リテラルに ImaginaryMark が含まれていない場合の評価結果として得られるものと同等の Integer オブジェクトである。

ただし、メモリ不足などのためにリテラルの値を Integer オブジェクトによって正確に表すことができない場合は、オーバーフローエラーとする。

浮動小数点数リテラル

Primary: FloatLiteral の評価結果は、以下のような Number オブジェクトを値とする 正常終了の結果である:

浮動小数点数リテラルに ImaginaryMark が含まれていない場合

結果の値は Float オブジェクトである。このオブジェクトの表す実数値は 浮動小数点リテラルの表す値の絶対値であり、 その精度は浮動小数点リテラルの精度である。

浮動小数点数リテラルに ImaginaryMark が含まれている場合

結果の値は Complex オブジェクトである。このオブジェクトの re プロパティの値は 0 を表す Integer オブジェクトであり、im プロパティの値は、リテラルに ImaginaryMark が含まれていない場合の評価結果として得られるものと同等の Float オブジェクトである。

ただし、メモリ不足などのためにリテラルの値を Float オブジェクトによって正確に表すことができない場合は、オーバーフローエラーとする。

無限大リテラル

InfinityLiteral

@inf KD

@cinf KD

無限大リテラル InfinityLiteral: @inf KD の評価結果は、[[正の無限大を表す Infinity オブジェクト]] である。

無限大リテラル InfinityLiteral: @cinf KD の評価結果は、[[複素無限大を表す Infinity オブジェクト]] である。

NaN リテラル

NaNLiteral

@nan KD

NaN リテラルの評価結果は、[[NaN オブジェクト]] である。

識別子

Primary: Identifier の評価は、 次のように行われる:

1. 現在の実行コンテクストを c とする。
2. Identifier トークンを構成する Unicode 文字列を n とする。(ただし Identifier トークン末尾の D は除く)
3. 結果が決まるまで次の処理を繰り返し行う:
   1. c の変数領域に n という名前のメンバが存在するならば、[[その変数領域を参照先オブジェクトとし、 n を参照先メンバ名とするメンバ参照]] を返す。
   2. c が基底実行コンテクストならば、[[基底変数領域を参照先オブジェクトとし、n を参照先メンバ名とするメンバ参照]] を返す。
   3. c の親実行コンテクストを改めて c とする。

Primary: # Identifier の評価は、次のように行われる:

1. 現在の実行コンテクストの @this 値を O とする。
2. Primary: # Identifier を構成する Unicode 文字列を n とする。(ただし Identifier トークン末尾の D は除く)
3. [[O を参照先オブジェクトとし、n を参照先メンバ名とするメンバ参照]] を返す。

引数参照式

引数参照式 Primary: # IntegerLiteral の評価は、IntegerLiteral を I として、左辺式 $args[I] の評価と同様である。

実行環境は、文法解析において、IntegerLiteral の中に ImaginaryMark が含まれるような Primary: # IntegerLiteral に遭遇した場合は、 文法エラーとしてよい。

引数参照式 Primary: # # D の評価は、左辺式 $args.count の評価と同様である。

引数参照式 Primary: # D の評価は、引数参照式 #1 の評価と同様である。

関数生成式

Function

@ D (LeftSquareBracket IdentifierList? RightSquareBracket)? Block

LeftSquareBracket

[ D

RightSquareBracket

] D

IdentifierList

Identifier (Comma Identifier)*

Comma

, D

関数生成式 Function は、新たな関数を生成する。Function を評価するたびに、 関数生成式の内容に基づいて新たな関数オブジェクトが生成され、 それを値とする正常終了が評価結果となる。

生成される関数オブジェクトの詳細については、別途定める。(→関数生成式によって生成される関数)

テンソル生成式

Tensor

LeftBrace Expressions? Comma? RightBrace

LeftBrace (&MatrixTester Expressions Comma? EOS)+ RightBrace

MatrixTester

MatrixTesterRec Comma? EOS

Expressions Comma? EOS RightBrace

MatrixTesterRec

Expression Comma MatrixTesterRec Comma Expression

Expression Comma? EOS Expression

LeftBrace

{ D

RightBrace

} D

テンソル生成式は、新たなテンソルを生成する。Tensor を評価するたびに、 テンソル生成式の内容に基づいて新たなテンソルオブジェクトが生成される。 テンソルオブジェクトが問題なく生成されれば、 それを値とする正常終了が評価結果となる。

具体的なテンソルオブジェクトの生成の仕方は、別途定める。(→テンソル生成式の評価)

解析表現 MatrixTester は、行列の各行に含まれる要素の 個数を全て等しくするために存在する。行列の行の要素数が異なっている (つまり行列が長方形でない) 場合、文法エラーとなる。

左辺式

LeftHandSide

Primary (Dot Identifier / LeftSquareBracket Expressions? RightSquareBracket / LeftSquareBracket2 (Expression Comma)? Expression RightSquareBracket2)*

Dot

. D

LeftSquareBracket2

[[ D

RightSquareBracket2

]] D

左辺式は、Primary に 0 個以上のメンバアクセス演算または関数呼出し演算を適用したものである。 メンバアクセス演算および関数呼出し演算は後置演算子として振舞う。

被演算子 A に対するメンバアクセス演算: A Dot Identifier の評価は次のように行う:

1. A を評価し、その結果に対し get-reference-value を行い、その結果を c とする。
2. c が正常終了でなければ、それを返す。
3. [[c の値を参照先オブジェクトとし、Identifier トークンを構成する Unicode 文字列を参照先メンバ名とするメンバ参照]] を評価結果とする。

被演算子 A に対する関数呼出し演算: A LeftSquareBracket Expressions? RightSquareBracket の評価は次のように行う:

1. A を評価し、その結果を c とする。
2. c が正常終了でなければそれを返す。
3. c の値がメンバ参照ならば、その参照先オブジェクトを t とする。 さもなくば、初期の Void.void を t とする。
4. c の値に対して get-reference-value を実行し、その結果を o とする。
5. o が正常終了でなければそれを返す。
6. Expressions が存在するならば、それを評価し、その結果を p とする。ここで p が正常終了でなければそれを返す。
7. o の値が関数として呼出し可能でなければ、新しい NotCallableError のインスタンスを投げる。
8. 以下の @this 値と引数で o の値を関数として呼出し、その結果を返す。

   @this 値

   t

   引数

   Expressions が存在するならば、p の値 (これは原始リストである) に含まれる全てのオブジェクト (原始リストに含まれるオブジェクトの順序は保たれる)。Expressions が存在しなければ、引数は無し (0 個のオブジェクト)。

被演算子 A に対する関数呼出し演算: A LeftSquareBracket2 Expression RightSquareBracket2 の評価は次のように行う:

1. A を評価し、その結果を c とする。
2. c が正常終了でなければそれを返す。
3. c の値がメンバ参照ならば、その参照先オブジェクトを t とする。 さもなくば、初期の Void.void を t とする。
4. c の値に対して get-reference-value を実行し、その結果を o とする。
5. o が正常終了でなければそれを返す。
6. Expression を評価し、その結果に対して get-reference-value を実行し、その結果を p とする。ここで p が正常終了でなければそれを返す。
7. p の値に対して enumerate-all を行い、その結果を q とする。
8. q が正常終了でなければそれを返す。
9. o の値が関数として呼出し可能でなければ、新しい NotCallableError のインスタンスを投げる。
10. 以下の @this 値と引数で o の値を関数として呼出し、その結果を返す。

    @this 値

    t

    引数

    q の値に含まれる全てのオブジェクト (原始リストに含まれるオブジェクトの順序は保たれる)。

被演算子 A に対する関数呼出し演算: A LeftSquareBracket2 Expression Comma Expression RightSquareBracket2 の評価は次のように行う:

1. A を評価し、その結果に対して get-reference-value を実行し、その結果を o とする。
2. o が正常終了でなければそれを返す。
3. 一つ目の Expression を評価し、その結果に対して get-reference-value を実行し、その結果を t とする。ここで t が正常終了でなければ直ちにそれを返す。
4. 二つ目の Expression を評価し、その結果に対して get-reference-value を実行し、その結果を p とする。ここで p が正常終了でなければ直ちにそれを返す。
5. p の値に対して enumerate-all を行い、その結果を q とする。
6. q が正常終了でなければそれを返す。
7. o の値が関数として呼出し可能でなければ、新しい NotCallableError のインスタンスを投げる。
8. 以下の @this 値と引数で o の値を関数として呼出し、その結果を返す。

   @this 値

   t の値

   引数

   q の値に含まれる全てのオブジェクト (原始リストに含まれるオブジェクトの順序は保たれる)。

後置単項演算子

Postfix

LeftHandSide (PlusPlus / MinusMinus)*

PlusPlus

++ D

MinusMinus

-- D

この後置単項演算は、結合式に 0 回以上後置演算子 ++ (PlusPlus) または -- (MinusMinus) を適用するものである。

被演算子 A に対する後置単項演算 ++ の評価は次のように行う:

1. A を評価し、その結果を p とする。
2. p に対して get-reference-value を実行し、その結果を r とする。
3. r が正常終了でなければそれを返す。
4. r を LeftHandSide に含まれる Primary の評価結果と見なして、左辺式 r.$increment[] を評価し、その結果に対して get-reference-value を実行し、その結果を s とする。
5. s が正常終了でなければそれを返す。
6. p の値が参照型でなければ新しい NotAssignableError のインスタンスを投げる。
7. p の値と s に対して set-reference-value を実行し、その結果が正常終了でなければそれを返す。
8. r を評価結果とする。

後置単項演算 -- の評価は後置単項演算 ++ の評価と同様である。ただし、左辺式 r.$increment[] の代わりに左辺式 r.$decrement[] を評価する。

冪演算子

Power

Postfix (PowerOperator Prefix)?

PowerOperator

((^ / **) D

冪演算子は、中置二項演算子である。

被演算子 A, B に対する二項演算 ^ または ** の評価は次の式の評価と同様である: (A).$power[B]

二つの冪演算子 ^ と ** の効果は全く同じである。#Script では前者の使用を推奨する。

前置単項演算子

Prefix

(PlusPlus / MinusMinus / Plus / Minus / Slash / BangBang / Bang / ExistsKeyword / DeleteKeyword / BindKeyword)* Power

BangBang

!! D

Bang

! D

ExistsKeyword

@exists KD

DeleteKeyword

@delete KD

BindKeyword

@bind KD

この前置単項演算は、後置単項演算式に以下に定める前置演算子を 0 回以上適用するものである。

被演算子 A に対する前置単項演算 + (Plus) の評価は次の式の評価と同様である: (A).$plus[]

被演算子 A に対する前置単項演算 - (Minus) の評価は次の式の評価と同様である: (A).$minus[]

被演算子 A に対する前置単項演算 / (Slash) の評価は次の式の評価と同様である: (A).$reciprocal[]

被演算子 A に対する前置単項演算 !! (BangBang) の評価は次のように行う:

1. A を評価し、その結果に対して get-reference-value を実行し、その結果を p とする。
2. p が正常終了でなければそれを返す。
3. p の値に対して to-boolean を実行し、その結果が true なら [[初期の Boolean.true]] を、false なら [[初期の Boolean.false]] を返す。

被演算子 A に対する前置単項演算 ! (Bang) の評価は次のように行う:

1. A を評価し、その結果に対して get-reference-value を実行し、その結果を p とする。
2. p が正常終了でなければそれを返す。
3. p の値に対して to-boolean を実行し、その結果が true なら [[初期の Boolean.false]] を、false なら [[初期の Boolean.true]] を返す。

被演算子 A に対する前置単項演算 @delete (DeleteKeyword) の評価は次のように行う:

1. A を評価し、その結果を r とする。
2. r が正常終了でなければ、直ちにそれを返す。
3. r の値が参照でなければ、新しい NotDeletableError のインスタンスを投げる。
4. r の値に対して delete-reference-value を実行し、その結果を返す。

被演算子 A に対する前置単項演算 @exists (ExistsKeyword) の評価は次のように行う:

1. A を評価し、その結果を r とする。
2. r が正常終了でなければ、直ちにそれを返す。
3. r の値が参照でなければ、新しい TypeError のインスタンスを投げる。
4. r の値に対して check-reference-value を実行し、その結果を返す。

被演算子 A に対する前置単項演算 @bind (BindKeyword) の評価は次のように行う:

1. A を評価し、その結果を r とする。
2. r が正常終了でなければ、直ちにそれを返す。
3. r の値がメンバ参照でなければ、直ちに r を返す。
4. r の値の参照先オブジェクトを t とする。
5. r に対して get-reference-value を実行し、その結果を s とする。 これが正常終了で無ければ、直ちにそれを返す。
6. s の値を f とする。f が関数として呼出し可能でなければ、s を返す。
7. 以下のような新しいオブジェクトを値とする正常終了の結果を返す:
   • メンバを持たない。
   • 唯一の内部メンバは $prototype であり、その値は f である。
   • 関数として呼出し可能であり、呼出されると次の動作を行う:
     1. t を @this 値とし、この呼出しと全く同じ引数で f を関数として呼出し、その結果を返す。

被演算子 A に対する前置単項演算 ++ (PlusPlus) の評価は次のように行う:

1. A を評価し、その結果を p とする。
2. p に対して get-reference-value を実行し、その結果を r とする。
3. r が正常終了でなければそれを返す。
4. r を LeftHandSide に含まれる Primary の評価結果と見なして、左辺式 r.$increment[] を評価し、その結果に対して get-reference-value を実行し、その結果を s とする。
5. s が正常終了でなければそれを返す。
6. p の値が参照型でなければ新しい NotAssignableError のインスタンスを投げる。
7. p の値と s に対して set-reference-value を実行し、その結果を返す。

前置単項演算 -- (MinusMinus) の評価は前置単項演算 ++ の評価と同様である。ただし、左辺式 r.$increment[] の代わりに左辺式 r.$decrement[] を評価する。

結合式

Juxtaposition

Prefix (&JuxtapositionDeterminant Prefix)*

JuxtapositionDeterminant

( / " / ' / . / @ / # / {

! !=

IdentifierChar

結合式は、連続する一つ以上の Prefix である。連続する Prefix には、 中置二項演算子 [空] による結合演算を適用する。この演算は、左結合である。

被演算子 A, B に対する結合演算の評価は 次の式の評価と同様である: (A).$juxtapose[B]

JuxtapositionDeterminant は、構文解析において Prefix の後に別の Prefix があるかどうかを判別するための条件を簡略化する。一つ目の Prefix の直後に JuxtapositionDeterminant が当てはまり、かつ二つ目の Prefix の解析に失敗した場合、文法エラーである。

乗算演算子

Multiplication

Juxtaposition ((Star / Slash / Backslash / Percent) Juxtaposition)*

Star

* D

Slash

/ D

Backslash

\ D

Percent

% D

乗算演算子は、左結合の中置二項演算子である。

被演算子 A, B に対する二項演算 * (Star) の評価は次の式の評価と同様である: (A).$multiply[B]

被演算子 A, B に対する二項演算 / (Slash) の評価は次の式の評価と同様である: (A).$divide[B]

被演算子 A, B に対する二項演算 \ (Backslash) の評価は次の式の評価と同様である: (A).$quotient[B]

被演算子 A, B に対する二項演算 % (Percent) の評価は次の式の評価と同様である: (A).$mod[B]

加算演算子

Addition

Multiplication ((Plus / Minus) Multiplication)*

Plus

+ D

Minus

- D

加算演算子は、左結合の中置二項演算子である。

被演算子 A, B に対する二項演算 + (Plus) の評価は次の式の評価と同様である: (A).$add[B]

被演算子 A, B に対する二項演算 - (Minus) の評価は次の式の評価と同様である: (A).$subtract[B]

区間生成演算子

Interval

IntervalOperator Addition?

Addition (IntervalOperator Addition?)?

IntervalOperator

EndpointType Tilde EndpointType

EndpointType

Less / LessEqual / [空]

Tilde

~ D

区間生成演算子は区間オブジェクトを生成する。この演算子は二項演算子であるが、左辺・右辺共に省略可能である。

被演算子 A, B に対する区間生成演算の評価は次の式の評価と同様である: Interval[A, B, C, D]

ただし上の評価において、部分式 C の評価結果は、IntervalOperator の一つ目の EndpointType が Less ならば [[初期の Boolean.false]]、さもなくば [[初期の Boolean.true]] とする。また部分式 D の評価結果は、IntervalOperator の二つ目の EndpointType が Less ならば [[初期の Boolean.false]]、さもなくば [[初期の Boolean.true]] とする。

この演算子の左辺が省略されているとき、左辺の評価結果は [[初期の Infinity.negativeInfinity]] とする。 この演算子の右辺が省略されているとき、右辺の評価結果は [[初期の Infinity.positiveInfinity]] とする。

0 < ~ < 1   // 0 から 1 までの開区間
0 <= ~ <= 1 // 0 から 1 までの開区間
0 ~ 1       // 同上
0 ~<        // 0 以上の全実数を表す半開区間
<~<         // 実数全てを表す開区間

多項関係演算子

ChainableRelation

Interval ((LessEqual / Less / GreaterEqual / Greater / EqualEqual / BangEqual) Interval)*

LessEqual

<= D

Less

< D

GreaterEqual

>= D

Greater

> D

EqualEqual

== D

BangEqual

!= D

多項関係演算子は、左結合の中置二項演算子である。

被演算子 A, B に対する二項演算 <= (LessEqual) の評価は次の式の評価と同様である: (A).$lessEqual[B]

被演算子 A, B に対する二項演算 < (Less) の評価は次の式の評価と同様である: (A).$less[B]

被演算子 A, B に対する二項演算 >= (GreaterEqual) の評価は次の式の評価と同様である: (A).$greaterEqual[B]

被演算子 A, B に対する二項演算 > (Greater) の評価は次の式の評価と同様である: (A).$greater[B]

被演算子 A, B に対する二項演算 == (EqualEqual) の評価は次の式の評価と同様である: (A).$equal[B]

被演算子 A, B に対する二項演算 != (BangEqual) の評価は次の式の評価と同様である: (A).$unequal[B]

二項関係演算子

BinaryRelation

ChainableRelation ((EqualEqualEqual / BangEqualEqual) ChainableRelation)?

EqualEqualEqual

=== D

BangEqualEqual

!== D

二項関係演算子は、中置二項演算子である。

被演算子 A, B に対する二項演算 === (EqualEqualEqual) の評価は次のように行う:

1. A を評価し、その結果に対して get-reference-value を実行し、その結果を a とする。
2. a が正常終了でなければ、それを返す。
3. B を評価し、その結果に対して get-reference-value を実行し、その結果を b とする。
4. b が正常終了でなければ、それを返す。
5. a の値と b の値が同じオブジェクトならば [[初期の Boolean.true]] を、さもなくば [[初期の Boolean.false]] を返す。

被演算子 A, B に対する二項演算 !== (BangEqualEqual) の評価は次の式の評価と同様である: !(A === B)

条件演算子

ConditionalAnd

BinaryRelation (AndAnd BinaryRelation)*

ConditionalOr

ConditionalAnd (PipePipe ConditionalAnd)*

Condition

ConditionalOr (Query Expression Colon Expression)?

AndAnd

&& D

PipePipe

|| D

Query

? D

Colon

: D

条件演算子 && と || は右結合の中置二項演算子である。

被演算子 A, B に対する二項演算 && の評価は次のように行う:

1. A を評価し、その結果を a とする。
2. a が正常終了でなければ、それを返す。
3. a の値がメンバ参照ならば、それに対して get-property を実行し、その結果を v とする。そして v の値がオブジェクトでなければ、[[初期の Void.void]] を改めて v とする。
4. a の値がメンバ参照でなければ、a の値に対して get-reference-value を実行し、その結果を v とする。
5. v が正常終了でなければ、それを返す。
6. v の値に対して to-boolean を実行し、その結果が false ならば、v を返す。
7. B を評価し、その結果に対して get-reference-value を実行し、その結果を返す。

被演算子 A, B に対する二項演算 || の評価は次のように行う:

1. A を評価し、その結果を a とする。
2. a が正常終了でなければ、それを返す。
3. a の値がメンバ参照ならば、それに対して get-property を実行し、その結果を v とする。そして v の値がオブジェクトでなければ、[[初期の Void.void]] を改めて v とする。
4. a の値がメンバ参照でなければ、a の値に対して get-reference-value を実行し、その結果を v とする。
5. v が正常終了でなければ、それを返す。
6. v の値に対して to-boolean を実行し、その結果が true ならば、v を返す。
7. B を評価し、その結果に対して get-reference-value を実行し、その結果を返す。

条件演算子 ? : は便宜的に三項演算子として分類される。

Condition: ConditionalOr の評価結果は ConditionalOr の評価結果である。

Condition: ConditionalOr Query Expression Colon Expression の評価は次のように行う:

1. ConditionalOr を評価し、その結果を a とする。
2. a が正常終了でなければ、それを返す。
3. a の値がメンバ参照ならば、それに対して get-property を実行し、その結果を c とする。そして c の値がオブジェクトでなければ、[[初期の Void.void]] を改めて c とする。
4. a の値がメンバ参照でなければ、a の値に対して get-reference-value を実行し、その結果を c とする。
5. c が正常終了でなければ、それを返す。
6. c の値に対して to-boolean を実行し、その結果が true ならば一つ目の Expression を、false ならば二つ目の Expression を評価し、その結果を返す。

代入演算子

Assignment

Condition (AssignmentOperator Expression)?

AssignmentOperator

Equal

+= D

-= D

*= D

^= D

**= D

/= D

\= D

%= D

&&= D

||= D

Equal

= D

代入演算子は、式の中で最も優先順位が低い中置二項演算子である。 代入演算子は複数の種類があり、種類によって動作が異なる。 代入演算子の種類は、AssignmentOperator から D を除いた部分により決定する。

被演算子 A, B に対する二項演算 = (Equal) の評価は次のように行う:

1. A を評価し、その結果を a とする。
2. a が正常終了でなければそれを返す。
3. B を評価し、その結果に対して get-reference-value を実行し、その結果を b とする。
4. b が正常終了でなければそれを返す。
5. a の値が参照型の値でない場合は新しい NotAssignableError のインスタンスを投げる。
6. a の値と b の値に対して set-reference-value を実行し、その結果を返す。

被演算子 A, B に対する二項演算 &&= の評価は次のように行う:

1. A を評価し、その結果を a とする。
2. a が正常終了でなければ、それを返す。
3. a の値がメンバ参照ならば、それに対して get-property を実行し、その結果を v とする。そして v の値がオブジェクトでなければ、[[初期の Void.void]] を改めて v とする。
4. a の値がメンバ参照でなければ、a の値に対して get-reference-value を実行し、その結果を v とする。
5. v が正常終了でなければそれを評価結果として評価を終了する。
6. v の値に対して to-boolean を実行し、その結果が false ならば v を返す。
7. B を評価し、その結果に対して get-reference-value を実行し、その結果を b とする。
8. a の値が参照型の値でない場合は新しい NotAssignableError のインスタンスを投げる。
9. a の値と b の値に対して set-reference-value を実行し、その結果を返す。

被演算子 A, B に対する二項演算 ||= の評価は次のように行う:

1. A を評価し、その結果を a とする。
2. a が正常終了でなければ、それを返す。
3. a の値がメンバ参照ならば、それに対して get-property を実行し、その結果を v とする。そして v の値がオブジェクトでなければ、[[初期の Void.void]] を改めて v とする。
4. a の値がメンバ参照でなければ、a の値に対して get-reference-value を実行し、その結果を v とする。
5. v が正常終了でなければそれを評価結果として評価を終了する。
6. v の値に対して to-boolean を実行し、その結果が true ならば v を返す。
7. B を評価し、その結果に対して get-reference-value を実行し、その結果を b とする。
8. a の値が参照型の値でない場合は新しい NotAssignableError のインスタンスを投げる。
9. a の値と b の値に対して set-reference-value を実行し、その結果を返す。

被演算子 A, B に対する二項演算 X= の評価は次のように行う (ここで X とは次の演算子のどれか一つである: +、-、*、^、**、/、\、%):

1. A を評価し、その結果を a とする。
2. a が正常終了でなければそれを返す。
3. a と B をそれぞれ演算子 X の左辺と右辺の評価結果と見なして演算子 X を評価し、その評価結果に対して get-reference-value を実行し、その結果を r とする。
4. r が正常終了でなければそれを返す。
5. a の値が参照型の値でない場合は新しい NotAssignableError のインスタンスを投げる。
6. a の値と r の値に対して set-reference-value を実行し、その結果を返す。

関数生成演算子

Expression

And Expression

Assignment

And

& D

関数生成演算子は、構文上は前置単項演算子である。

被演算子 A に対する関数生成演算 & (And) の評価は次の式の評価と同様である: @ { A }

Expression の評価結果は、常に正常終了またはエラー終了である。

複式

Expressions

Expression (Comma Expression)*

複式は、一つ以上の式の配列である。

複式 Expressions: Expression (Comma Expression)* の評価は次のように行う:

1. Expressions に含まれる Expression の数を n とする。
2. i = 1, 2, …, n について、i = 1 から i = n まで順に以下の処理を行う:
   1. Expressions の i 番目の Expression を評価し、その結果に対して get-reference-value を実行し、その結果を r_i とする。
   2. r_i が正常終了でなければ、直ちにそれを返す。
   3. r_i の値を v_i とする。
3. [[v₁ から v_n までの n 個のオブジェクトを要素とする原始リスト]] を返す。このとき、原始リストの要素の順序は v の添字の順序を保つ。

条件判定

値が真であるか偽であるかを判定する操作 to-boolean は一つのオブジェクト v に対して true または false のどちらかの値を結果として返す。判定基準は、v がいずれも初期の Void.void、Null.null、Boolean.false、NaN.nan のどれかなら false、さもなくば true である。