diff options
| author | Marshall Lochbaum <mwlochbaum@gmail.com> | 2022-01-28 16:34:41 -0500 |
|---|---|---|
| committer | Marshall Lochbaum <mwlochbaum@gmail.com> | 2022-01-28 16:34:41 -0500 |
| commit | 0c716e4c6b7c2c44bbfd02b6503cae66af7b7480 (patch) | |
| tree | ac880382ea281825027b34768d6512d340596e56 /docs/spec | |
| parent | 4821f231a00dc93c42fb437359ea657c59c63053 (diff) | |
Separate syntax highlighting category for header/body characters ;:?
Diffstat (limited to 'docs/spec')
| -rw-r--r-- | docs/spec/complex.html | 2 | ||||
| -rw-r--r-- | docs/spec/evaluate.html | 8 | ||||
| -rw-r--r-- | docs/spec/grammar.html | 44 | ||||
| -rw-r--r-- | docs/spec/inferred.html | 2 | ||||
| -rw-r--r-- | docs/spec/literal.html | 6 | ||||
| -rw-r--r-- | docs/spec/primitive.html | 2 |
6 files changed, 32 insertions, 32 deletions
diff --git a/docs/spec/complex.html b/docs/spec/complex.html index a5d4826e..3ef70e13 100644 --- a/docs/spec/complex.html +++ b/docs/spec/complex.html @@ -8,7 +8,7 @@ <p>Complex numbers are an optional extension to BQN's numeric system. If they are supported, the following functionality must also be supported. This extension is a draft and is versioned separately from the rest of the BQN specification.</p> <p>A <em>complex number</em> is a value with two <em>components</em>, a <em>real part</em> and an <em>imaginary part</em>. The type of each component is a real number, as described in the <a href="types.html">type</a> specification. However, this type replaces the number type given there.</p> <p>The <a href="literal.html">numeric literal</a> notation is extended with the character <code><span class='Value'>i</span></code>, which separates two real-valued components (in effect, it has lower "precedence" than other characters like <code><span class='Value'>e</span></code> and <code><span class='Number'>Β―</span></code>). If a second component is present (using <code><span class='Value'>i</span></code> or <code><span class='Function'>I</span></code>), that component's value is multiplied by the <a href="https://en.wikipedia.org/wiki/Imaginary_unit">imaginary unit</a> <em>i</em> and added to the first component; otherwise the value is the first component's value without modification. As with real numbers, the exact complex number given is rounded to fit the number system in use.</p> -<pre><span class='Value'>complexnumber</span> <span class='Function'>=</span> <span class='Value'>number</span> <span class='Paren'>(</span> <span class='Paren'>(</span> <span class='String'>"i"</span> <span class='Function'>|</span> <span class='String'>"I"</span> <span class='Paren'>)</span> <span class='Value'>number</span> <span class='Paren'>)</span><span class='Value'>?</span> +<pre><span class='Value'>complexnumber</span> <span class='Function'>=</span> <span class='Value'>number</span> <span class='Paren'>(</span> <span class='Paren'>(</span> <span class='String'>"i"</span> <span class='Function'>|</span> <span class='String'>"I"</span> <span class='Paren'>)</span> <span class='Value'>number</span> <span class='Paren'>)</span><span class='Head'>?</span> </pre> <p>Basic arithmetic functions <code><span class='Function'>+-ΓΓ·</span></code> are extended to complex numbers. A monadic case for the function <code><span class='Function'>+</span></code> is added, which returns the conjugate argument: a number with real part equal to the real part of <code><span class='Value'>π©</span></code> and imaginary part negated relative to <code><span class='Value'>π©</span></code>.</p> <p>The primitive function <code><span class='Value'>β³</span></code> is added: the character <code><span class='Value'>β³</span></code> forms a primitive function <a href="token.html">token</a>, and its value is the function <code><span class='Brace'>{</span><span class='Value'>π¨</span><span class='Function'>β’</span><span class='Modifier2'>β</span><span class='Function'>+</span><span class='Number'>0j1</span><span class='Function'>Γ</span><span class='Value'>π©</span><span class='Brace'>}</span></code>. This function multiplies <code><span class='Value'>π©</span></code> by <em>i</em>, then adds <code><span class='Value'>π¨</span></code> if given.</p> diff --git a/docs/spec/evaluate.html b/docs/spec/evaluate.html index ef0bd0ca..9bb02864 100644 --- a/docs/spec/evaluate.html +++ b/docs/spec/evaluate.html @@ -20,9 +20,9 @@ <h3 id="assignment"><a class="header" href="#assignment">Assignment</a></h3> <p>An <em>assignment</em> is one of the four rules containing <code><span class='Function'>ASGN</span></code>. It is evaluated by first evaluating the right-hand-side <code><span class='Value'>subExpr</span></code>, <code><span class='Function'>FuncExpr</span></code>, <code><span class='Modifier'>_m1Expr</span></code>, or <code><span class='Modifier2'>_m2Exp_</span></code> expression, and then storing the result in the left-hand-side identifier or identifiers. The result of the assignment expression is the result of its right-hand side. Except for subjects, only a lone identifier is allowed on the left-hand side and storage sets it equal to the result. For subjects, <em>destructuring assignment</em> is performed when an <code><span class='Value'>lhs</span></code> is <code><span class='Value'>lhsList</span></code> or <code><span class='Value'>lhsStr</span></code>. Destructuring assignment is performed recursively by assigning right-hand-side values to the left-hand-side targets, with single-identifier assignment as the base case. The target <code><span class='String'>"Β·"</span></code> is also possible in place of a <code><span class='Function'>NAME</span></code>, and performs no assignment.</p> <p>The right-hand-side value, here called <code><span class='Value'>v</span></code>, in destructuring assignment must be a list (rank 1 array) or namespace. If it's a list, then each <code><span class='Function'>LHS_ENTRY</span></code> node must be an <code><span class='Function'>LHS_ELT</span></code>. The left-hand side is treated as a list of <code><span class='Value'>lhs</span></code> targets, and matched to <code><span class='Value'>v</span></code> element-wise, with an error if the two lists differ in length. If <code><span class='Value'>v</span></code> is a namespace, then the left-hand side must be an <code><span class='Value'>lhsStr</span></code> where every <code><span class='Function'>LHS_ATOM</span></code> is an <code><span class='Function'>NAME</span></code>, or an <code><span class='Value'>lhsList</span></code> where every <code><span class='Function'>LHS_ENTRY</span></code> is an <code><span class='Function'>NAME</span></code> or <code><span class='Value'>lhs</span> <span class='String'>"β"</span> <span class='Function'>NAME</span></code>, so that it can be considered a list of <code><span class='Function'>NAME</span></code> nodes some of which are also associated with <code><span class='Value'>lhs</span></code> nodes. To perform the assignment, the value of each name is obtained from the namespace <code><span class='Value'>v</span></code>, giving an error if <code><span class='Value'>v</span></code> does not define that name. The value is assigned to the <code><span class='Value'>lhs</span></code> node if present (which may be a destructuring assignment or simple subject assignment), and otherwise assigned to the same <code><span class='Function'>NAME</span></code> node used to get it from <code><span class='Value'>v</span></code>.</p> -<p><em>Modified assignment</em> is the subject assignment rule <code><span class='Value'>lhs</span> <span class='Function'>Derv</span> <span class='String'>"β©"</span> <span class='Value'>subExpr?</span></code>. In this case, <code><span class='Value'>lhs</span></code> is evaluated as if it were a <code><span class='Value'>subExpr</span></code> (the syntax is a subset of <code><span class='Value'>subExpr</span></code>), and passed as an argument to <code><span class='Function'>Derv</span></code>. The full application is <code><span class='Value'>lhs</span> <span class='Function'>Derv</span> <span class='Value'>subExpr</span></code>, if <code><span class='Value'>subExpr</span></code> is given, and <code><span class='Function'>Derv</span> <span class='Value'>lhs</span></code> otherwise. Its value is assigned to <code><span class='Value'>lhs</span></code>, and is also the result of the modified assignment expression.</p> +<p><em>Modified assignment</em> is the subject assignment rule <code><span class='Value'>lhs</span> <span class='Function'>Derv</span> <span class='String'>"β©"</span> <span class='Value'>subExpr</span><span class='Head'>?</span></code>. In this case, <code><span class='Value'>lhs</span></code> is evaluated as if it were a <code><span class='Value'>subExpr</span></code> (the syntax is a subset of <code><span class='Value'>subExpr</span></code>), and passed as an argument to <code><span class='Function'>Derv</span></code>. The full application is <code><span class='Value'>lhs</span> <span class='Function'>Derv</span> <span class='Value'>subExpr</span></code>, if <code><span class='Value'>subExpr</span></code> is given, and <code><span class='Function'>Derv</span> <span class='Value'>lhs</span></code> otherwise. Its value is assigned to <code><span class='Value'>lhs</span></code>, and is also the result of the modified assignment expression.</p> <h3 id="expressions"><a class="header" href="#expressions">Expressions</a></h3> -<p>We now give rules for evaluating an <code><span class='Value'>atom</span></code>, <code><span class='Function'>Func</span></code>, <code><span class='Modifier'>_mod1</span></code> or <code><span class='Modifier2'>_mod2_</span></code> expression (the possible options for <code><span class='Function'>ANY</span></code>). A literal or primitive <code><span class='Value'>sl</span></code>, <code><span class='Function'>Fl</span></code>, <code><span class='Modifier'>_ml</span></code>, or <code><span class='Modifier2'>_cl_</span></code> has a fixed value defined by the specification (<a href="literal.html">literals</a> and <a href="primitive.html">built-ins</a>). An identifier <code><span class='Value'>s</span></code>, <code><span class='Function'>F</span></code>, <code><span class='Modifier'>_m</span></code>, or <code><span class='Modifier2'>_c_</span></code>, if not preceded by <code><span class='Value'>atom</span> <span class='String'>"."</span></code>, must have an associated variable due to the scoping rules, and returns this variable's value, or causes an error if it has not yet been set. If it is preceded by <code><span class='Value'>atom</span> <span class='String'>"."</span></code>, then the <code><span class='Value'>atom</span></code> node is evaluated first; its value must be a namespace, and the result is the value of the identifier's name in the namespace, or an error if the name is undefined. A parenthesized expression such as <code><span class='String'>"("</span> <span class='Modifier'>_modExpr</span> <span class='String'>")"</span></code> simply returns the result of the interior expression. A braced construct such as <code><span class='Function'>BraceFunc</span></code> is defined by the evaluation of the statements it contains after all parameters are accepted. Finally, a list <code><span class='String'>"β¨"</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Paren'>(</span> <span class='Paren'>(</span> <span class='Function'>EXPR</span> <span class='Separator'>β</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Function'>EXPR</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='String'>"β©"</span></code> or <code><span class='Function'>ANY</span> <span class='Paren'>(</span> <span class='String'>"βΏ"</span> <span class='Function'>ANY</span> <span class='Paren'>)</span><span class='Function'>+</span></code> consists grammatically of a list of expressions. To evaluate it, each expression is evaluated in source order and their results are placed as elements of a rank-1 array. The two forms have identical semantics but different punctuation.</p> +<p>We now give rules for evaluating an <code><span class='Value'>atom</span></code>, <code><span class='Function'>Func</span></code>, <code><span class='Modifier'>_mod1</span></code> or <code><span class='Modifier2'>_mod2_</span></code> expression (the possible options for <code><span class='Function'>ANY</span></code>). A literal or primitive <code><span class='Value'>sl</span></code>, <code><span class='Function'>Fl</span></code>, <code><span class='Modifier'>_ml</span></code>, or <code><span class='Modifier2'>_cl_</span></code> has a fixed value defined by the specification (<a href="literal.html">literals</a> and <a href="primitive.html">built-ins</a>). An identifier <code><span class='Value'>s</span></code>, <code><span class='Function'>F</span></code>, <code><span class='Modifier'>_m</span></code>, or <code><span class='Modifier2'>_c_</span></code>, if not preceded by <code><span class='Value'>atom</span> <span class='String'>"."</span></code>, must have an associated variable due to the scoping rules, and returns this variable's value, or causes an error if it has not yet been set. If it is preceded by <code><span class='Value'>atom</span> <span class='String'>"."</span></code>, then the <code><span class='Value'>atom</span></code> node is evaluated first; its value must be a namespace, and the result is the value of the identifier's name in the namespace, or an error if the name is undefined. A parenthesized expression such as <code><span class='String'>"("</span> <span class='Modifier'>_modExpr</span> <span class='String'>")"</span></code> simply returns the result of the interior expression. A braced construct such as <code><span class='Function'>BraceFunc</span></code> is defined by the evaluation of the statements it contains after all parameters are accepted. Finally, a list <code><span class='String'>"β¨"</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Paren'>(</span> <span class='Paren'>(</span> <span class='Function'>EXPR</span> <span class='Separator'>β</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Function'>EXPR</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='String'>"β©"</span></code> or <code><span class='Function'>ANY</span> <span class='Paren'>(</span> <span class='String'>"βΏ"</span> <span class='Function'>ANY</span> <span class='Paren'>)</span><span class='Function'>+</span></code> consists grammatically of a list of expressions. To evaluate it, each expression is evaluated in source order and their results are placed as elements of a rank-1 array. The two forms have identical semantics but different punctuation.</p> <p>Rules in the table below are function and modifier evaluation.</p> <table> <thead> @@ -38,7 +38,7 @@ <tbody> <tr> <td><code><span class='Value'>π¨</span></code></td> -<td><code><span class='Paren'>(</span> <span class='Value'>subject</span> <span class='Function'>|</span> <span class='Value'>nothing</span> <span class='Paren'>)</span><span class='Value'>?</span></code></td> +<td><code><span class='Paren'>(</span> <span class='Value'>subject</span> <span class='Function'>|</span> <span class='Value'>nothing</span> <span class='Paren'>)</span><span class='Head'>?</span></code></td> <td><code><span class='Function'>Derv</span></code></td> <td><code><span class='Value'>arg</span></code></td> <td><code><span class='Value'>π©</span></code></td> @@ -82,7 +82,7 @@ <td><code><span class='Brace'>{</span><span class='Paren'>(</span><span class='Value'>π¨</span><span class='Function'>L</span><span class='Value'>π©</span><span class='Paren'>)</span><span class='Function'>C</span><span class='Paren'>(</span><span class='Value'>π¨</span><span class='Function'>R</span><span class='Value'>π©</span><span class='Paren'>)</span><span class='Brace'>}</span></code></td> </tr> <tr> -<td><code><span class='Value'>nothing?</span></code></td> +<td><code><span class='Value'>nothing</span><span class='Head'>?</span></code></td> <td><code><span class='Function'>Derv</span></code></td> <td><code><span class='Function'>Fork</span></code></td> <td><code><span class='Brace'>{</span> <span class='Function'>C</span><span class='Paren'>(</span><span class='Value'>π¨</span><span class='Function'>R</span><span class='Value'>π©</span><span class='Paren'>)</span><span class='Brace'>}</span></code></td> diff --git a/docs/spec/grammar.html b/docs/spec/grammar.html index 3b18a102..fc8e2542 100644 --- a/docs/spec/grammar.html +++ b/docs/spec/grammar.html @@ -8,19 +8,19 @@ <p>BQN's grammar is given below. Terms are defined in a <a href="https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form">BNF</a> variant. However, handling special names properly is possible but difficult in BNF, so they are explained in text along with the braced block grammar.</p> <p>The symbols <code><span class='Value'>s</span></code>, <code><span class='Function'>F</span></code>, <code><span class='Modifier'>_m</span></code>, and <code><span class='Modifier2'>_c_</span></code> are identifier tokens with subject, function, 1-modifier, and 2-modifier classes respectively. Similarly, <code><span class='Value'>sl</span></code>, <code><span class='Function'>Fl</span></code>, <code><span class='Modifier'>_ml</span></code>, and <code><span class='Modifier2'>_cl_</span></code> refer to literals and primitives of those classes. While names in the BNF here follow the identifier naming scheme, this is informative only: syntactic roles are no longer used after parsing and cannot be inspected in a running program.</p> <p>A program is a list of statements. Almost all statements are expressions. Namespace export statements, and valueless results stemming from <code><span class='Nothing'>Β·</span></code>, or <code><span class='Value'>π¨</span></code> in a monadic brace function, can be used as statements but not expressions.</p> -<pre><span class='Function'>PROGRAM</span> <span class='Function'>=</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Paren'>(</span> <span class='Function'>STMT</span> <span class='Separator'>β</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Function'>STMT</span> <span class='Separator'>β</span><span class='Value'>?</span> +<pre><span class='Function'>PROGRAM</span> <span class='Function'>=</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Paren'>(</span> <span class='Function'>STMT</span> <span class='Separator'>β</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Function'>STMT</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Function'>STMT</span> <span class='Function'>=</span> <span class='Function'>EXPR</span> <span class='Function'>|</span> <span class='Value'>nothing</span> <span class='Function'>|</span> <span class='Function'>EXPORT</span> <span class='Separator'>β</span> <span class='Function'>=</span> <span class='Paren'>(</span> <span class='String'>"β"</span> <span class='Function'>|</span> <span class='String'>","</span> <span class='Function'>|</span> <span class='Value'>\n</span> <span class='Paren'>)</span><span class='Function'>+</span> <span class='Function'>EXPR</span> <span class='Function'>=</span> <span class='Value'>subExpr</span> <span class='Function'>|</span> <span class='Function'>FuncExpr</span> <span class='Function'>|</span> <span class='Modifier'>_m1Expr</span> <span class='Function'>|</span> <span class='Modifier2'>_m2Expr_</span> -<span class='Function'>EXPORT</span> <span class='Function'>=</span> <span class='Function'>LHS_ELT</span><span class='Value'>?</span> <span class='String'>"β"</span> +<span class='Function'>EXPORT</span> <span class='Function'>=</span> <span class='Function'>LHS_ELT</span><span class='Head'>?</span> <span class='String'>"β"</span> </pre> <p>Here we define the "atomic" forms of functions and modifiers, which are either single tokens or enclosed in paired symbols. Stranded lists with <code><span class='Ligature'>βΏ</span></code>, which binds more tightly than any form of execution, are also included.</p> <pre><span class='Function'>ANY</span> <span class='Function'>=</span> <span class='Value'>atom</span> <span class='Function'>|</span> <span class='Function'>Func</span> <span class='Function'>|</span> <span class='Modifier'>_mod1</span> <span class='Function'>|</span> <span class='Modifier2'>_mod2_</span> -<span class='Modifier2'>_mod2_</span> <span class='Function'>=</span> <span class='Paren'>(</span> <span class='Value'>atom</span> <span class='String'>"."</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Modifier2'>_c_</span> <span class='Function'>|</span> <span class='Modifier2'>_cl_</span> <span class='Function'>|</span> <span class='String'>"("</span> <span class='Modifier2'>_m1Expr_</span> <span class='String'>")"</span> <span class='Function'>|</span> <span class='Modifier2'>_blMod2_</span> -<span class='Modifier'>_mod1</span> <span class='Function'>=</span> <span class='Paren'>(</span> <span class='Value'>atom</span> <span class='String'>"."</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Modifier'>_m</span> <span class='Function'>|</span> <span class='Modifier'>_ml</span> <span class='Function'>|</span> <span class='String'>"("</span> <span class='Modifier'>_m2Expr</span> <span class='String'>")"</span> <span class='Function'>|</span> <span class='Modifier'>_blMod1</span> -<span class='Function'>Func</span> <span class='Function'>=</span> <span class='Paren'>(</span> <span class='Value'>atom</span> <span class='String'>"."</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Function'>F</span> <span class='Function'>|</span> <span class='Function'>Fl</span> <span class='Function'>|</span> <span class='String'>"("</span> <span class='Function'>FuncExpr</span> <span class='String'>")"</span> <span class='Function'>|</span> <span class='Function'>BlFunc</span> -<span class='Value'>atom</span> <span class='Function'>=</span> <span class='Paren'>(</span> <span class='Value'>atom</span> <span class='String'>"."</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Value'>s</span> <span class='Function'>|</span> <span class='Value'>sl</span> <span class='Function'>|</span> <span class='String'>"("</span> <span class='Value'>subExpr</span> <span class='String'>")"</span> <span class='Function'>|</span> <span class='Value'>blSub</span> <span class='Function'>|</span> <span class='Value'>list</span> -<span class='Value'>list</span> <span class='Function'>=</span> <span class='String'>"β¨"</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Paren'>(</span> <span class='Paren'>(</span> <span class='Function'>EXPR</span> <span class='Separator'>β</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Function'>EXPR</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='String'>"β©"</span> +<span class='Modifier2'>_mod2_</span> <span class='Function'>=</span> <span class='Paren'>(</span> <span class='Value'>atom</span> <span class='String'>"."</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Modifier2'>_c_</span> <span class='Function'>|</span> <span class='Modifier2'>_cl_</span> <span class='Function'>|</span> <span class='String'>"("</span> <span class='Modifier2'>_m1Expr_</span> <span class='String'>")"</span> <span class='Function'>|</span> <span class='Modifier2'>_blMod2_</span> +<span class='Modifier'>_mod1</span> <span class='Function'>=</span> <span class='Paren'>(</span> <span class='Value'>atom</span> <span class='String'>"."</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Modifier'>_m</span> <span class='Function'>|</span> <span class='Modifier'>_ml</span> <span class='Function'>|</span> <span class='String'>"("</span> <span class='Modifier'>_m2Expr</span> <span class='String'>")"</span> <span class='Function'>|</span> <span class='Modifier'>_blMod1</span> +<span class='Function'>Func</span> <span class='Function'>=</span> <span class='Paren'>(</span> <span class='Value'>atom</span> <span class='String'>"."</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Function'>F</span> <span class='Function'>|</span> <span class='Function'>Fl</span> <span class='Function'>|</span> <span class='String'>"("</span> <span class='Function'>FuncExpr</span> <span class='String'>")"</span> <span class='Function'>|</span> <span class='Function'>BlFunc</span> +<span class='Value'>atom</span> <span class='Function'>=</span> <span class='Paren'>(</span> <span class='Value'>atom</span> <span class='String'>"."</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Value'>s</span> <span class='Function'>|</span> <span class='Value'>sl</span> <span class='Function'>|</span> <span class='String'>"("</span> <span class='Value'>subExpr</span> <span class='String'>")"</span> <span class='Function'>|</span> <span class='Value'>blSub</span> <span class='Function'>|</span> <span class='Value'>list</span> +<span class='Value'>list</span> <span class='Function'>=</span> <span class='String'>"β¨"</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Paren'>(</span> <span class='Paren'>(</span> <span class='Function'>EXPR</span> <span class='Separator'>β</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Function'>EXPR</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='String'>"β©"</span> <span class='Value'>subject</span> <span class='Function'>=</span> <span class='Value'>atom</span> <span class='Function'>|</span> <span class='Function'>ANY</span> <span class='Paren'>(</span> <span class='String'>"βΏ"</span> <span class='Function'>ANY</span> <span class='Paren'>)</span><span class='Function'>+</span> </pre> <p>Starting at the highest-order objects, modifiers have simple syntax. In most cases the syntax for <code><span class='Gets'>β</span></code> and <code><span class='Gets'>β©</span></code> is the same, but only <code><span class='Gets'>β©</span></code> can be used for modified assignment. The export arrow <code><span class='Gets'>β</span></code> can be used in the same ways as <code><span class='Gets'>β</span></code>, but it can also be used at the beginning of a header to force a namespace result, or with no expression on the right in an <code><span class='Function'>EXPORT</span></code> statement.</p> @@ -46,12 +46,12 @@ </pre> <p>Subject expressions consist mainly of function application. We also define nothing-statements, which have very similar syntax to subject expressions but do not permit assignment. They can be used as an <code><span class='Function'>STMT</span></code> or in place of a left argument.</p> <pre><span class='Value'>arg</span> <span class='Function'>=</span> <span class='Value'>subExpr</span> - <span class='Function'>|</span> <span class='Paren'>(</span> <span class='Value'>subject</span> <span class='Function'>|</span> <span class='Value'>nothing</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Function'>Derv</span> <span class='Value'>arg</span> + <span class='Function'>|</span> <span class='Paren'>(</span> <span class='Value'>subject</span> <span class='Function'>|</span> <span class='Value'>nothing</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Function'>Derv</span> <span class='Value'>arg</span> <span class='Value'>nothing</span> <span class='Function'>=</span> <span class='String'>"Β·"</span> - <span class='Function'>|</span> <span class='Paren'>(</span> <span class='Value'>subject</span> <span class='Function'>|</span> <span class='Value'>nothing</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Function'>Derv</span> <span class='Value'>nothing</span> + <span class='Function'>|</span> <span class='Paren'>(</span> <span class='Value'>subject</span> <span class='Function'>|</span> <span class='Value'>nothing</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Function'>Derv</span> <span class='Value'>nothing</span> <span class='Value'>subExpr</span> <span class='Function'>=</span> <span class='Value'>arg</span> <span class='Function'>|</span> <span class='Value'>lhs</span> <span class='Function'>ASGN</span> <span class='Value'>subExpr</span> - <span class='Function'>|</span> <span class='Value'>lhs</span> <span class='Function'>Derv</span> <span class='String'>"β©"</span> <span class='Value'>subExpr?</span> <span class='Comment'># Modified assignment + <span class='Function'>|</span> <span class='Value'>lhs</span> <span class='Function'>Derv</span> <span class='String'>"β©"</span> <span class='Value'>subExpr</span><span class='Head'>?</span> <span class='Comment'># Modified assignment </span></pre> <p>The target of subject assignment can be compound to allow for destructuring. List and namespace assignment share the nodes <code><span class='Value'>lhsList</span></code> and <code><span class='Value'>lhsStr</span></code> and cannot be completely distinguished until execution. The term <code><span class='Value'>sl</span></code> in <code><span class='Function'>LHS_SUB</span></code> is used for header inputs below: as an additional rule, it cannot be used in the <code><span class='Value'>lhs</span></code> term of a <code><span class='Value'>subExpr</span></code> node.</p> <pre><span class='Function'>NAME</span> <span class='Function'>=</span> <span class='Value'>s</span> <span class='Function'>|</span> <span class='Function'>F</span> <span class='Function'>|</span> <span class='Modifier'>_m</span> <span class='Function'>|</span> <span class='Modifier2'>_c_</span> @@ -61,7 +61,7 @@ <span class='Function'>LHS_ELT</span> <span class='Function'>=</span> <span class='Function'>LHS_ANY</span> <span class='Function'>|</span> <span class='Value'>lhsStr</span> <span class='Function'>LHS_ENTRY=</span> <span class='Function'>LHS_ELT</span> <span class='Function'>|</span> <span class='Value'>lhs</span> <span class='String'>"β"</span> <span class='Function'>NAME</span> <span class='Value'>lhsStr</span> <span class='Function'>=</span> <span class='Function'>LHS_ATOM</span> <span class='Paren'>(</span> <span class='String'>"βΏ"</span> <span class='Function'>LHS_ATOM</span> <span class='Paren'>)</span><span class='Function'>+</span> -<span class='Value'>lhsList</span> <span class='Function'>=</span> <span class='String'>"β¨"</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Paren'>(</span> <span class='Paren'>(</span> <span class='Function'>LHS_ENTRY</span> <span class='Separator'>β</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Function'>LHS_ENTRY</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='String'>"β©"</span> +<span class='Value'>lhsList</span> <span class='Function'>=</span> <span class='String'>"β¨"</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Paren'>(</span> <span class='Paren'>(</span> <span class='Function'>LHS_ENTRY</span> <span class='Separator'>β</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Function'>LHS_ENTRY</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='String'>"β©"</span> <span class='Value'>lhsComp</span> <span class='Function'>=</span> <span class='Function'>LHS_SUB</span> <span class='Function'>|</span> <span class='Value'>lhsStr</span> <span class='Function'>|</span> <span class='String'>"("</span> <span class='Value'>lhs</span> <span class='String'>")"</span> <span class='Value'>lhs</span> <span class='Function'>=</span> <span class='Value'>s</span> <span class='Function'>|</span> <span class='Value'>lhsComp</span> </pre> @@ -81,19 +81,19 @@ </pre> <p>There are some extra possibilities for a header that specifies arguments. As a special rule, a monadic function header specifically can omit the function when the argument is not just a name (as this would conflict with a subject label). Additionally, an inference header doesn't affect evaluation of the function, but describes how an inferred property (<a href="inferred.html#undo">Undo</a>) should be computed. Here <code><span class='String'>"Λ"</span></code> and <code><span class='String'>"βΌ"</span></code> are both specific instances of the <code><span class='Modifier'>_ml</span></code> token.</p> <pre><span class='Function'>ARG_HEAD</span> <span class='Function'>=</span> <span class='Function'>LABEL</span> - <span class='Function'>|</span> <span class='Value'>headW?</span> <span class='Function'>IMM_HEAD</span> <span class='String'>"βΌ"</span><span class='Value'>?</span> <span class='Value'>headX</span> + <span class='Function'>|</span> <span class='Value'>headW</span><span class='Head'>?</span> <span class='Function'>IMM_HEAD</span> <span class='String'>"βΌ"</span><span class='Head'>?</span> <span class='Value'>headX</span> <span class='Function'>|</span> <span class='Value'>headW</span> <span class='Function'>IMM_HEAD</span> <span class='String'>"Λ"</span> <span class='String'>"βΌ"</span> <span class='Value'>headX</span> - <span class='Function'>|</span> <span class='Function'>FuncName</span> <span class='String'>"Λ"</span><span class='Value'>?</span> <span class='String'>"βΌ"</span> + <span class='Function'>|</span> <span class='Function'>FuncName</span> <span class='String'>"Λ"</span><span class='Head'>?</span> <span class='String'>"βΌ"</span> <span class='Function'>|</span> <span class='Value'>lhsComp</span> </pre> -<p>A braced block contains bodies, which are lists of statements, separated by semicolons and possibly preceded by headers, which are separated from the body with a colon. A non-final expression can be made into a predicate by following it with the separator-like <code><span class='Value'>?</span></code>. Multiple bodies allow different handling for various cases, which are pattern-matched by headers. A block can have any number of bodies with headers. After these there can be bodies without headersβup to one for an immediate block and up to two for a block with arguments. If a block with arguments has one such body, it's ambivalent, but two of them refer to the monadic and dyadic cases.</p> -<pre><span class='Function'>BODY</span> <span class='Function'>=</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Paren'>(</span> <span class='Function'>STMT</span> <span class='Separator'>β</span> <span class='Function'>|</span> <span class='Function'>EXPR</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='String'>"?"</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Function'>STMT</span> <span class='Separator'>β</span><span class='Value'>?</span> +<p>A braced block contains bodies, which are lists of statements, separated by semicolons and possibly preceded by headers, which are separated from the body with a colon. A non-final expression can be made into a predicate by following it with the separator-like <code><span class='Head'>?</span></code>. Multiple bodies allow different handling for various cases, which are pattern-matched by headers. A block can have any number of bodies with headers. After these there can be bodies without headersβup to one for an immediate block and up to two for a block with arguments. If a block with arguments has one such body, it's ambivalent, but two of them refer to the monadic and dyadic cases.</p> +<pre><span class='Function'>BODY</span> <span class='Function'>=</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Paren'>(</span> <span class='Function'>STMT</span> <span class='Separator'>β</span> <span class='Function'>|</span> <span class='Function'>EXPR</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='String'>"?"</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Function'>STMT</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Function'>CASE</span> <span class='Function'>=</span> <span class='Function'>BODY</span> -<span class='Function'>I_CASE</span> <span class='Function'>=</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Function'>IMM_HEAD</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='String'>":"</span> <span class='Function'>BODY</span> -<span class='Function'>A_CASE</span> <span class='Function'>=</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Function'>ARG_HEAD</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='String'>":"</span> <span class='Function'>BODY</span> +<span class='Function'>I_CASE</span> <span class='Function'>=</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Function'>IMM_HEAD</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='String'>":"</span> <span class='Function'>BODY</span> +<span class='Function'>A_CASE</span> <span class='Function'>=</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Function'>ARG_HEAD</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='String'>":"</span> <span class='Function'>BODY</span> <span class='Function'>IMM_BLK</span> <span class='Function'>=</span> <span class='String'>"{"</span> <span class='Paren'>(</span> <span class='Function'>I_CASE</span> <span class='String'>";"</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Paren'>(</span> <span class='Function'>I_CASE</span> <span class='Function'>|</span> <span class='Function'>CASE</span> <span class='Paren'>)</span> <span class='String'>"}"</span> -<span class='Function'>ARG_BLK</span> <span class='Function'>=</span> <span class='String'>"{"</span> <span class='Paren'>(</span> <span class='Function'>A_CASE</span> <span class='String'>";"</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Paren'>(</span> <span class='Function'>A_CASE</span> <span class='Function'>|</span> <span class='Function'>CASE</span> <span class='Paren'>(</span> <span class='String'>";"</span> <span class='Function'>CASE</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Paren'>)</span> <span class='String'>"}"</span> -<span class='Value'>blSub</span> <span class='Function'>=</span> <span class='String'>"{"</span> <span class='Paren'>(</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='Value'>s</span> <span class='Separator'>β</span><span class='Value'>?</span> <span class='String'>":"</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Function'>BODY</span> <span class='String'>"}"</span> +<span class='Function'>ARG_BLK</span> <span class='Function'>=</span> <span class='String'>"{"</span> <span class='Paren'>(</span> <span class='Function'>A_CASE</span> <span class='String'>";"</span> <span class='Paren'>)</span><span class='Value'>*</span> <span class='Paren'>(</span> <span class='Function'>A_CASE</span> <span class='Function'>|</span> <span class='Function'>CASE</span> <span class='Paren'>(</span> <span class='String'>";"</span> <span class='Function'>CASE</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Paren'>)</span> <span class='String'>"}"</span> +<span class='Value'>blSub</span> <span class='Function'>=</span> <span class='String'>"{"</span> <span class='Paren'>(</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='Value'>s</span> <span class='Separator'>β</span><span class='Head'>?</span> <span class='String'>":"</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Function'>BODY</span> <span class='String'>"}"</span> <span class='Function'>BlFunc</span> <span class='Function'>=</span> <span class='Function'>ARG_BLK</span> <span class='Modifier'>_blMod1</span> <span class='Function'>=</span> <span class='Function'>IMM_BLK</span> <span class='Function'>|</span> <span class='Function'>ARG_BLK</span> <span class='Modifier2'>_blMod2_</span> <span class='Function'>=</span> <span class='Function'>IMM_BLK</span> <span class='Function'>|</span> <span class='Function'>ARG_BLK</span> @@ -145,10 +145,10 @@ </tr> </tbody> </table> -<p>The rules for special names can be expressed in BNF by making many copies of all expression rules above. For each "level", or row in the table, a new version of every rule should be made that allows that level but not higher ones, and another version should be made that requires exactly that level. The values themselves should be included in <code><span class='Value'>s</span></code>, <code><span class='Function'>F</span></code>, <code><span class='Modifier'>_m</span></code>, and <code><span class='Modifier2'>_c_</span></code> for these copies. Then the "allowed" rules are made simply by replacing the terms they contain (excluding <code><span class='Value'>blSub</span></code> and so on) with the same "allowed" versions, and "required" rules are constructed using both "allowed" and "required" rules. For every part of a production rule, an alternative should be created that requires the relevant name in that part while allowing it in the others. For example, <code><span class='Paren'>(</span> <span class='Value'>subject</span> <span class='Function'>|</span> <span class='Value'>nothing</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Function'>Derv</span> <span class='Value'>arg</span></code> would be transformed to</p> +<p>The rules for special names can be expressed in BNF by making many copies of all expression rules above. For each "level", or row in the table, a new version of every rule should be made that allows that level but not higher ones, and another version should be made that requires exactly that level. The values themselves should be included in <code><span class='Value'>s</span></code>, <code><span class='Function'>F</span></code>, <code><span class='Modifier'>_m</span></code>, and <code><span class='Modifier2'>_c_</span></code> for these copies. Then the "allowed" rules are made simply by replacing the terms they contain (excluding <code><span class='Value'>blSub</span></code> and so on) with the same "allowed" versions, and "required" rules are constructed using both "allowed" and "required" rules. For every part of a production rule, an alternative should be created that requires the relevant name in that part while allowing it in the others. For example, <code><span class='Paren'>(</span> <span class='Value'>subject</span> <span class='Function'>|</span> <span class='Value'>nothing</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Function'>Derv</span> <span class='Value'>arg</span></code> would be transformed to</p> <pre><span class='Value'>arg_req1</span> <span class='Function'>=</span> <span class='Value'>subExpr_req1</span> <span class='Function'>|</span> <span class='Paren'>(</span> <span class='Value'>subject_req1</span> <span class='Function'>|</span> <span class='Value'>nothing_req1</span> <span class='Paren'>)</span> <span class='Function'>Derv_allow1</span> <span class='Value'>arg_allow1</span> - <span class='Function'>|</span> <span class='Paren'>(</span> <span class='Value'>subject_allow1</span> <span class='Function'>|</span> <span class='Value'>nothing_allow1</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Function'>Derv_req1</span> <span class='Value'>arg_allow1</span> - <span class='Function'>|</span> <span class='Paren'>(</span> <span class='Value'>subject_allow1</span> <span class='Function'>|</span> <span class='Value'>nothing_allow1</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Function'>Derv_allow1</span> <span class='Value'>arg_req1</span> + <span class='Function'>|</span> <span class='Paren'>(</span> <span class='Value'>subject_allow1</span> <span class='Function'>|</span> <span class='Value'>nothing_allow1</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Function'>Derv_req1</span> <span class='Value'>arg_allow1</span> + <span class='Function'>|</span> <span class='Paren'>(</span> <span class='Value'>subject_allow1</span> <span class='Function'>|</span> <span class='Value'>nothing_allow1</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Function'>Derv_allow1</span> <span class='Value'>arg_req1</span> </pre> <p>Quite tedious. The explosion of rules is partly due to the fact that the brace-typing rule falls into a weaker class of grammars than the other rules. Most of BQN is <a href="https://en.wikipedia.org/wiki/Deterministic_context-free_grammar">deterministic context-free</a> but brace-typing is not, only context-free. Fortunately brace typing does not introduce the parsing difficulties that can be present in a general context-free grammar, and it can easily be performed in linear time: after <a href="token.html">scanning</a> but before parsing, move through the source code maintaining a stack of the current top-level set of braces. Whenever a colon or special name is encountered, annotate that set of braces to indicate that it is present. When a closing brace is encountered and the top brace is popped off the stack, the type is needed if there was no colon, and can be found based on which names were present. One way to present this information to the parser is to replace the brace tokens with new tokens that indicate the type.</p> diff --git a/docs/spec/inferred.html b/docs/spec/inferred.html index fd247c65..11c27867 100644 --- a/docs/spec/inferred.html +++ b/docs/spec/inferred.html @@ -381,7 +381,7 @@ </tr> <tr> <td><code><span class='Modifier'>β</span></code></td> -<td><code><span class='Brace'>{</span><span class='Function'>!</span><span class='Number'>0</span><span class='Function'><β‘</span><span class='Value'>π©</span><span class='Separator'>β</span> <span class='Function'>π½</span><span class='Modifier'>βΌβ</span><span class='Value'>π©;</span><span class='Brace'>}</span></code></td> +<td><code><span class='Brace'>{</span><span class='Function'>!</span><span class='Number'>0</span><span class='Function'><β‘</span><span class='Value'>π©</span><span class='Separator'>β</span> <span class='Function'>π½</span><span class='Modifier'>βΌβ</span><span class='Value'>π©</span><span class='Head'>;</span><span class='Brace'>}</span></code></td> <td>Monadic case only</td> </tr> <tr> diff --git a/docs/spec/literal.html b/docs/spec/literal.html index c171dbf5..0dd938cd 100644 --- a/docs/spec/literal.html +++ b/docs/spec/literal.html @@ -8,9 +8,9 @@ <p>A <em>literal</em> is a single <a href="token.html">token</a> that indicates a fixed character, number, or array. While literals indicate values of a data type, <a href="primitive.html">primitives</a> indicate values of an operation type: function, 1-modifier, or 2-modifier.</p> <p>Two types of literal deal with text. As the source code is considered to be a sequence of unicode code points ("characters"), and these code points are also used for BQN's character <a href="types.html">data type</a>, the representation of a text literal is very similar to its value. In a text literal, the newline character is always represented using the ASCII line feed character, code point 10. A <em>character literal</em> is enclosed with single quotes <code><span class='String'>'</span></code> and its value is identical to the single character between them. A <em>string literal</em> is enclosed in double quotes <code><span class='String'>"</span></code>, and any double quotes between them must come in pairs, as a lone double quote marks the end of the literal. The value of a string literal is a rank-1 array whose elements are the characters in between the enclosing quotes, after replacing each pair of double quotes with only one such quote. The <em>null literal</em> is the token <code><span class='String'>@</span></code> and represents the null character, code point 0.</p> <p>The format of a <em>numeric literal</em> is more complicated. From the <a href="token.html">tokenization rules</a>, a numeric literal consists of a numeric character (one of <code><span class='Number'>Β―βΟ.0123456789</span></code>) followed by any number of numeric or alphabetic characters. Some numeric literals are <em>valid</em> and indicate a number, while others are invalid and cause an error. The grammar for valid numbers is given below in a <a href="https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form">BNF</a> variant. The alphabetic character allowed is "e" or "E", which functions as in scientific notation. Not included in this grammar are underscoresβthey can be placed anywhere in a number, including after the last non-underscore character, and are ignored entirely.</p> -<pre><span class='Value'>number</span> <span class='Function'>=</span> <span class='String'>"Β―"</span><span class='Value'>?</span> <span class='Paren'>(</span> <span class='String'>"β"</span> <span class='Function'>|</span> <span class='Value'>mantissa</span> <span class='Paren'>(</span> <span class='Paren'>(</span> <span class='String'>"e"</span> <span class='Function'>|</span> <span class='String'>"E"</span> <span class='Paren'>)</span> <span class='Value'>exponent</span> <span class='Paren'>)</span><span class='Value'>?</span> <span class='Paren'>)</span> -<span class='Value'>exponent</span> <span class='Function'>=</span> <span class='String'>"Β―"</span><span class='Value'>?</span> <span class='Value'>digit</span><span class='Function'>+</span> -<span class='Value'>mantissa</span> <span class='Function'>=</span> <span class='String'>"Ο"</span> <span class='Function'>|</span> <span class='Value'>digit</span><span class='Function'>+</span> <span class='Paren'>(</span> <span class='String'>"."</span> <span class='Value'>digit</span><span class='Function'>+</span> <span class='Paren'>)</span><span class='Value'>?</span> +<pre><span class='Value'>number</span> <span class='Function'>=</span> <span class='String'>"Β―"</span><span class='Head'>?</span> <span class='Paren'>(</span> <span class='String'>"β"</span> <span class='Function'>|</span> <span class='Value'>mantissa</span> <span class='Paren'>(</span> <span class='Paren'>(</span> <span class='String'>"e"</span> <span class='Function'>|</span> <span class='String'>"E"</span> <span class='Paren'>)</span> <span class='Value'>exponent</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Paren'>)</span> +<span class='Value'>exponent</span> <span class='Function'>=</span> <span class='String'>"Β―"</span><span class='Head'>?</span> <span class='Value'>digit</span><span class='Function'>+</span> +<span class='Value'>mantissa</span> <span class='Function'>=</span> <span class='String'>"Ο"</span> <span class='Function'>|</span> <span class='Value'>digit</span><span class='Function'>+</span> <span class='Paren'>(</span> <span class='String'>"."</span> <span class='Value'>digit</span><span class='Function'>+</span> <span class='Paren'>)</span><span class='Head'>?</span> <span class='Value'>digit</span> <span class='Function'>=</span> <span class='String'>"0"</span> <span class='Function'>|</span> <span class='String'>"1"</span> <span class='Function'>|</span> <span class='String'>"2"</span> <span class='Function'>|</span> <span class='String'>"3"</span> <span class='Function'>|</span> <span class='String'>"4"</span> <span class='Function'>|</span> <span class='String'>"5"</span> <span class='Function'>|</span> <span class='String'>"6"</span> <span class='Function'>|</span> <span class='String'>"7"</span> <span class='Function'>|</span> <span class='String'>"8"</span> <span class='Function'>|</span> <span class='String'>"9"</span> </pre> <p>The digits or arabic numerals correspond to the numbers from 0 to 9 in the conventional way (also, each corresponds to its code point value minus 48). A sequence of digits gives a natural number by evaluating it in base 10: the number is 0 for an empty sequence, and otherwise the last digit's numerical value plus ten times the number obtained from the remaining digits. The symbol <code><span class='Number'>β</span></code> indicates infinity and <code><span class='Number'>Ο</span></code> indicates the ratio <a href="https://en.wikipedia.org/wiki/Pi_(mathematics)">pi</a> of a perfect circle's circumference to its diameter. The <a href="https://aplwiki.com/wiki/High_minus">high minus</a> symbol <code><span class='Number'>Β―</span></code> indicates that the number containing it is to be negated. When an exponent is provided (with <code><span class='Value'>e</span></code> or <code><span class='Function'>E</span></code>), the corresponding mantissa is multiplied by ten to that power, giving the value <code><span class='Value'>mantissa</span><span class='Function'>Γ</span><span class='Number'>10</span><span class='Function'>β</span><span class='Value'>exponent</span></code>.</p> diff --git a/docs/spec/primitive.html b/docs/spec/primitive.html index b1c115f2..05ed2dcc 100644 --- a/docs/spec/primitive.html +++ b/docs/spec/primitive.html @@ -87,7 +87,7 @@ <li><strong>Before</strong>/<strong>Bind</strong> (<code><span class='Modifier2'>βΈ</span></code>)</li> <li><strong>After</strong>/<strong>Bind</strong> (<code><span class='Modifier2'>β</span></code>)</li> </ul> -<p>The somewhat complicated definition of Valences could be replaced with <code><span class='Brace'>{</span><span class='Function'>π½</span><span class='Value'>π©;π¨</span><span class='Function'>πΎ</span><span class='Value'>π©</span><span class='Brace'>}</span></code> using headers. However, reference.bqn uses a simple subset of BQN's syntax that doesn't include headers. Instead, the definition relies on the fact that <code><span class='Value'>π¨</span></code> works like <code><span class='Nothing'>Β·</span></code> if no left argument is given: <code><span class='Paren'>(</span><span class='Number'>1</span><span class='Modifier'>Λ</span><span class='Value'>π¨</span><span class='Paren'>)</span><span class='Function'>-</span><span class='Number'>0</span></code> is <code><span class='Number'>1</span><span class='Function'>-</span><span class='Number'>0</span></code> or <code><span class='Number'>1</span></code> if <code><span class='Value'>π¨</span></code> is present and <code><span class='Paren'>(</span><span class='Number'>1</span><span class='Modifier'>Λ</span><span class='Nothing'>Β·</span><span class='Paren'>)</span><span class='Function'>-</span><span class='Number'>0</span></code> otherwise: this reduces to <code><span class='Nothing'>Β·</span><span class='Function'>-</span><span class='Number'>0</span></code> or <code><span class='Number'>0</span></code>.</p> +<p>The somewhat complicated definition of Valences could be replaced with <code><span class='Brace'>{</span><span class='Function'>π½</span><span class='Value'>π©</span><span class='Head'>;</span><span class='Value'>π¨</span><span class='Function'>πΎ</span><span class='Value'>π©</span><span class='Brace'>}</span></code> using headers. However, reference.bqn uses a simple subset of BQN's syntax that doesn't include headers. Instead, the definition relies on the fact that <code><span class='Value'>π¨</span></code> works like <code><span class='Nothing'>Β·</span></code> if no left argument is given: <code><span class='Paren'>(</span><span class='Number'>1</span><span class='Modifier'>Λ</span><span class='Value'>π¨</span><span class='Paren'>)</span><span class='Function'>-</span><span class='Number'>0</span></code> is <code><span class='Number'>1</span><span class='Function'>-</span><span class='Number'>0</span></code> or <code><span class='Number'>1</span></code> if <code><span class='Value'>π¨</span></code> is present and <code><span class='Paren'>(</span><span class='Number'>1</span><span class='Modifier'>Λ</span><span class='Nothing'>Β·</span><span class='Paren'>)</span><span class='Function'>-</span><span class='Number'>0</span></code> otherwise: this reduces to <code><span class='Nothing'>Β·</span><span class='Function'>-</span><span class='Number'>0</span></code> or <code><span class='Number'>0</span></code>.</p> <h3 id="array-properties"><a class="header" href="#array-properties">Array properties</a></h3> <p>The reference implementations extend Shape (<code><span class='Function'>β’</span></code>) to atoms as well as arrays, in addition to implementing other properties. In all cases, an atom behaves as if it has shape <code><span class='Bracket'>β¨β©</span></code>. The functions in this section never cause an error.</p> <ul> |