From 59dc6500b113db05b9de17e5b49124d29defce3f Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Mon, 9 Mar 2026 10:51:36 +0100
Subject: [PATCH 01/41] updated lang-ref, compact grammar, ledger-adt.mdx.
 replaced all-keywords.mdx with compact-keywords.mdx and removed
 all-keywords.html. removed word-break: break-all from custom.css code {} to
 we don't get line breaks within words and constants in inline code segments.
 moved ledger-adt.mdx from static/language to docs/compact/reference.

---
 docs/compact/reference/all-keywords.mdx       |   12 -
 docs/compact/reference/compact-keywords.mdx   |   90 +
 docs/compact/reference/lang-ref.mdx           | 3979 +++++++++++------
 .../compact/reference}/ledger-adt.mdx         |    6 +-
 sidebars.compact.js                           |    2 +-
 src/css/custom.css                            |    1 -
 static/language/all-keywords.html             |  104 -
 static/language/compact.html                  |   47 +-
 8 files changed, 2716 insertions(+), 1525 deletions(-)
 delete mode 100644 docs/compact/reference/all-keywords.mdx
 create mode 100644 docs/compact/reference/compact-keywords.mdx
 rename {static/language => docs/compact/reference}/ledger-adt.mdx (98%)
 delete mode 100644 static/language/all-keywords.html

diff --git a/docs/compact/reference/all-keywords.mdx b/docs/compact/reference/all-keywords.mdx
deleted file mode 100644
index ddc9386d..00000000
--- a/docs/compact/reference/all-keywords.mdx
+++ /dev/null
@@ -1,12 +0,0 @@
----
-SPDX-License-Identifier: Apache-2.0
-copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
-title: Keywords and reserved words
-sidebar_position: 20
----
-
-# Keywords and reserved words
-
-import Iframe from "@site/src/components/IFrame/Iframe";
-
-<Iframe src="/language/all-keywords.html" />
diff --git a/docs/compact/reference/compact-keywords.mdx b/docs/compact/reference/compact-keywords.mdx
new file mode 100644
index 00000000..bdc7c3c9
--- /dev/null
+++ b/docs/compact/reference/compact-keywords.mdx
@@ -0,0 +1,90 @@
+# Compact keywords
+
+## Module-related keywords
+
+- export
+- from
+- import
+- module
+- prefix
+
+## Statement and expression keywords
+
+- as
+- assert
+- circuit
+- const
+- constructor
+- contract
+- default
+- disclose
+- else
+- enum
+- fold
+- for
+- if
+- include
+- ledger
+- map
+- new
+- of
+- pad
+- pragma
+- pure
+- return
+- sealed
+- slice
+- struct
+- type
+- witness
+
+## Built-in data type keywords.
+
+- Boolean
+- Bytes
+- Field
+- Opaque
+- Uint
+- Vector
+
+## Boolean literals
+
+- false
+- true
+
+## Keywords reserved for future use
+
+- await
+- break
+- case
+- catch
+- class
+- continue
+- debugger
+- delete
+- do
+- extends
+- finally
+- function
+- implements
+- in
+- instanceof
+- interface
+- let
+- null
+- package
+- private
+- protected
+- public
+- static
+- super
+- switch
+- this
+- throw
+- try
+- typeof
+- var
+- void
+- while
+- with
+- yield
diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 1e1f5ce9..737f140c 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -1,119 +1,439 @@
----
-SPDX-License-Identifier: Apache-2.0
-copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
-title: Compact reference
-sidebar_position: 05
----
-
 # Compact reference
 
-Compact is a strongly statically typed, bounded smart contract language, designed to be
-used in combination with TypeScript for writing smart contracts for the
-three-part structure of Midnight, where contracts have the following
+## Overview
+
+Compact is a strongly typed, statically typed, bounded smart contract language,
+designed to be used in combination with TypeScript for writing smart contracts
+for the three-part structure of Midnight, where contracts have the following
 components:
+
 - a replicated component on a public ledger
 - a zero-knowledge circuit component, confidentially proving the correctness of
   the former
 - a local, off-chain component that can perform arbitrary code
 
-Each contract in Compact can have four kinds of code:
-- type declarations, to support all of the following
-- declarations of the data that the contract stores in the public ledger
-- declarations of `witness` functions, to be supplied in TypeScript
-- `circuit` definitions, that serve as the operational core of a smart contract
+Each Compact program (also referred to as a *contract*) can contain several
+kinds of program elements:
+- module and import forms for management of namespaces and separate files,
+- declarations of program-defined types,
+- declarations of the data that the contract stores in the public ledger,
+- declarations of *witnesses*, which are callback functions supplied by the TypeScript runner, and
+- definitions of *circuits*, which are functions serving as the operational core of a smart contract, and
+- the definition of at most one *constructor*, which is a function used to intialize the public ledger.
+
+Compact is similar to TypeScript: it has a syntax similar to that of JavaScript,
+and it layers a type system over the JavaScript syntax.
+Compact deviates intentionally from TypeScript, however, in several important ways:
+- Unlike TypeScript, Compact is strongly typed.
+  Programs cannot bypass the static type system via missing type declarations or
+  unsafe casts.
+  Furthermore, the JavaScript code produced by the Compact compiler includes
+  run-time checks enforcing the static types of values that come from outside
+  Compact as well as preventing external application of a Compact circuit with
+  more or fewer than the declared number of arguments.
+- Compact provides namespace management via static rather than dynamic modules, and
+  these modules can be parameterized via compile-time generic parameters, which include size as
+  well as type parameters.
+- Because every Compact program must compile into a set of finite proving circuits,
+  all Compact types have sizes that are fixed at compile time, loops are bounded either
+  by constant bounds or by the size of an object of constant size, and recursion
+  is disallowed.
+- Compact numeric values are limited to unsigned integers either with a
+  program-declared range or with a range determined by the field size of the
+  target proving system.
+- Compact distinguishes certain values as potentially containing private data that
+  should typically be protected, and it requires explicit declaration of the
+  disclosure of any potential private data via `disclose()` wrappers.
+  The basics of this are discussed in the
+  [description of `disclose`](#explicit-disclosure), and a more thorough description
+  and discussion appears in the separate document
+  [Explicit disclosure in Compact](explicit-disclosure).
+
+Like TypeScript, Compact compiles into JavaScript, but it also produces a TypeScript
+definition file so that it effectively also compiles into TypeScript.
+It produces separate TypeScript definition files and JavaScript implementation files
+rather than simply producing TypeScript for three reasons:
+- to allow compiled Compact programs to be used without requiring an additional
+  TypeScript compilation step,
+- to permit the generated code to check function argument counts without disabling
+  compile-time argument-type checks when called from TypeScript, and
+- so that it can generate a sourcemap file that properly maps elements of the
+  generated JavaScript code (e.g., variable bindings and references) to the corresponding
+  elements of the source Compact code.
+
+For each circuit that touches the public ledger and hence requires a proof for
+on-chain execution, the Compact compiler also produces proving circuits in a
+zero-knowledge intermediate language (*zkir*), and it uses a zkir compiler to
+produce proving keys for each such circuit.
+
+Finally, the compact compiler also produces a JSON-formatted contract info file that contains
+information about the program and its compiled representation, including version numbers and the types and
+characteristics of the contract's exported circuits.
+
+This document explains each syntactic category individually.  It starts by
+introducing the building blocks that are used in various contexts: identifiers,
+constants, types, generic parameters, and patterns.  Then it describes
+the structure of Compact programs, each kind of program element, and the
+statements and expressions that can appear within circuit and constructor
+bodies.
+Finally, it discusses the TypeScript target.
+
+[Writing a contract](writing) provides a small example of what a
+Compact program looks like.  It also introduces the basic building blocks of a
+Compact contract.  [The full grammar of Compact](compact-grammar) is provided
+separately.
+
+## Notation
+
+The syntax of Compact programs is given by an EBNF grammar.  We use the
+following notational conventions in the grammar:
 
-A contract can also include code from external files, and it can declare and
-import modules.
+- Terminals are in <b><tt>bold monospaced</tt></b> font
+- Non-terminals are in <em>emphasized</em> font
+- Alternation is indicated by a vertical bar (`|`)
+- Optional items are indicated by a superscript <sup>opt</sup>
+- Repetition is specified by ellipses. The
+  notation <em>X</em> ... <em>X</em>, where <em>X</em> is a grammar symbol,
+  represents zero or more occurrences of <em>X</em>. The notation <em>X</em>
+  <b><tt>,</tt></b> ... <b><tt>,</tt></b> <em>X</em>, where <em>X</em> is a
+  grammar symbol and <b><tt>,</tt></b> is a literal comma, represents zero or more
+  occurrences of <em>X</em> separated by commas. In either case, when
+  the ellipsis is marked with the superscript 1, the notation represents a
+  sequence containing at least one <em>X</em>. When such a sequence is followed
+  by <em>,</em><sup>opt</sup>, an optional trailing comma is allowed, but
+  only if there is at least one <em>X</em>. For example, <em>id</em> &mldr;
+  <em>id</em> represents zero or more <em>id</em>s, and <em>expr</em>
+  <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em>
+  <b><tt>,</tt></b><sup>opt</sup> represents one or more comma-separated
+  <em>expr</em>s possibly followed by an extra comma.
+  The rules involving commas apply equally to semicolons, i.e., apply when
+  <b><tt>,</tt></b> is replaced by <b><tt>;</tt></b>.
+
+## Static and dynamic errors
+
+The compiler detects various kinds of *static errors*, e.g., malformed syntax,
+references to undefined identifiers, and type mismatches.
+When it detects one or more static errors, it prints descriptive error messages
+for the errors and terminates without generating any output.
+
+The code the compiler generates and the run-time libraries it uses detect various
+kinds of *dynamic errors*, e.g., attempts from code outside of Compact to call
+Compact circuits with wrong numbers or types of arguments.
+These errors are reported when the generated code is run.
+
+## Identifiers, bindings, and scope
+
+Identifiers are used in Compact, as in most other programming languages, to
+name things.
+Syntactally, an *identifier* is a *token* (atomic sequence of characters), beginning
+with with an alphabetic character, a dollar sign (`$`), or an underscore (`_`)
+followed by one or more alphabetic characters, digits (`0` - `9`), dollar signs,
+or underscores.
+
+Some identifiers are *reserved words*.
+Of these, some are used as *keywords* in the syntax of the Compact language, e.g.,
+`module`, `import`, `circuit`, and `for`.
+Others, specifically keywords reserved by JavaScript and TypeScript, are considered
+reserved for future use in Compact, e.g., `self` and `class`.
+Still others, specifically every identifier that begins with `__compact`,
+are reserved for use by the compiler.
+A comprehensive list of keywords and reserved words is given
+in [keywords and reserved words](compact-keywords).
+
+The remaining identifiers can be used to name specific instances of various kinds
+of entities, including modules, types, generic parameters, ledger fields, function
+(circuit or witness) names, function parameters, and local variables.
+An identifier associated with, i.e., *bound* to, one of these entities can be
+referenced anywhere within the *scope* of the binding.
+Compact is lexically scoped, so the scope of each binding is limited to a specific
+region of the program text.
+The binding might be *shadowed* (hidden from view) in some region of program text
+within its scope that contains a binding for the same identifier.
+
+It is a static error for an identifier to be bound more than once in a same scope,
+except that [function overloading](#circuit-and-witness-calls) allows
+more than one function with the same name to be visible in the same scope with
+different signatures, i.e., different numbers or kinds of generic parameters
+and/or different numbers or types of run-time parameters.
+
+The scope of each binding depends upon where it appears, as described below.
+(The caveat "except where shadowed" is not explicitly stated but applies in each case.)
+- Identifiers bound at the outermost level of a contract (refered to as the *top
+  level*) are visible throughout the contract, but not within any modules that are
+  imported from separate files.
+- Identifiers bound at the outermost level of a module are visible throughout the module.
+  They are not visible outside of the module unless exported: any exported
+  binding is also visible if and where it is imported from the module.
+- The generic parameters of a module, structure declaration, or function declaration
+  are visible throughout the declaration.
+- The run-time parameters of a circuit or constructor are visible within its body.
+- Identifiers defined by a `const` binding inside a block are visible throughout
+  the block.
+- Identifiers defined by a `const` binding inside a `for`-loop header are
+  visible throughout the `for` loop.
+
+Every reference to an identifier must appear within the scope of a binding for
+the identifier, in which case we say that the identifier is bound to the entity
+associated with the identifier by that binding.
+Otherwise, the reference is a static error.
 
-Like TypeScript, Compact is an eager call-by-value language.
+For example:
 
-## Compact Types
+```compact
+circuit c(): Field {
+  const answer = 42;
+  {
+    const answer = 12;
+    assert(answer != 42, "shadowing did not work!");
+  }
+  return answer; // returns 42 (the outer 'answer')
+}
+```
 
-Compact is **statically typed**: every expression in a Compact program has a
-static type.  Named circuits and witnesses require a type annotation on each of
-their parameters, and they require a return type annotation.  Anonymous circuit
-expressions can have optional parameter and return type annotations.  Constant
-binding statements can have an optional type annotation.
+The identifier `c` is bound to the circuit named `c`, and this binding is visible
+throughout the contract, though no references to `c` appear in the example.
+The first (outer) binding of the identifier `answer` to the value `42` is visible
+throughout the body of `c` except where shadowed by the second (inner) binding of
+`answer` within in the inner block, so the reference to `answer` in `return answer`
+evaluates to `42`.
+The second (inner) binding of `answer` to `42` is visible throughout the inner
+block, so the reference to `answer` in `answer != 42` evaluates to `12`.
+
+In addition to having a scope, every binding also has a lifetime.
+For circuit and witness bindings, the lifetime is effectively permanent, i.e.,
+the binding is always available for use whenever the program is run.
+
+The lifetimes of ledger-field bindings begin when they are first initialized
+and are effectively permanant from that point on; although the value of a
+field can change over time, the association of the ledger-field name with the
+ledger field's location in the (replicated) public state of a contract never
+changes.
+
+On the other hand, bindings for module names, type names, and generic
+parameters are live only when a program is compiled, i.e., they help determine
+the structure of the program and the shape of the data used by the program
+but are not needed once the program has been compiled.
+(TypeScript bindings for type names exported from the program's top level
+do live on, however, in the generated TypeScript definition file.)
+
+Variable bindings, i.e., bindings of circuit parameters, constructor parameters,
+and local variables bound by `const` statements and `for` loops, have dynamic
+lifetimes.
+The bindings of a circuit's or constructor's parameters start a new lifetime
+when the circuit or constructor is called that ends when the circuit or constructor
+exits.
+A variable binding established by a `const` statement starts a new lifetime when
+the `const` statement is evaluated that ends when the block containing the `const`
+statement exits.
+A `const` binding established by the `const` subform of a `for`-loop header starts
+a new lifetime on each iteration of the loop that ends when that iteration ends.
+
+Variable bindings can have multiple lifetimes, because a circuit might be called
+multiple times, a block might be evaluated multiple times, and a `for` loop might
+be evaluated multiple times and/or have multiple iterations.
+Variables in Compact are immutable, however: they have the same value over the
+entire lifetime of the variable's binding.
+Thus, they are referred to as variables not because their values can vary over
+any single lifetime but because they can have different values in different
+lifetimes.
+
+## Generic parameters and arguments
+
+Various entities, specifically
+[module declarations](#modules-exports-and-imports),
+[structure declarations](#structure-types),
+[type-alias declarations](#type-aliases),
+[circuit definitions](#circuits),
+and
+[witness declarations](#declaring-witnesses-for-private-state),
+can have *generic parameters*, i.e., compile-time type and numeric (natural-number)
+parameters whose values are given at the use site rather than fixed at the point
+of declaration.
+This allows the same *generic* code to be used with different specific types,
+bounds, and sizes.
+Except where shadowed, generic parameters are visible thoughout the entire entity.
+In particular, the generic parameters of a module are visible within the program
+elements that appear within the body of the module.
+
+When present, generic parameters are enclosed in angle brackets following the
+name of the generic entity (module, structure, type alias, circuit, or witness).
+Each parameter is either a type name (e.g., `T`) or a hash-prefixed natural-number name
+(e.g., `#N`).
+Generic natural-number parameters are prefixed by `#` to distingish them from
+generic type parameters.
+
+<table className="lang-ref-table"><tbody><tr><td><em>gparams</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>generic-param</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>generic-param</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr>
+<tr><td><em>generic-param</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>#</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr></tbody></table>
+
+Generic entities must be *specialized* at the point of use to produce non-generic
+entities at compile time by supplying them with *generic arguments*.
+Any attempt to use a generic entity without specializing it is a static error.
+Generic arguments are also enclosed in angle brackets.
+Each generic argument must be a type, a natural number literal, or the type or
+numeric value of a generic parameter.
+
+<table className="lang-ref-table"><tbody><tr><td><em>gargs</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>garg</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>garg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr>
+<tr><td><em>garg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
+
+The syntax of types allows for type references, including references to generic
+parameters, so any generic argument can pass along the value of a generic type
+or natural-number parameter that is visible at the point of specialization.
+
+The `#` used to distinguish generic natural-number parameters from generic type parameters
+need not and must not used at the point of specialization.
+It is a static error, however, if a generic argument supplied for a generic
+parameter is not numeric when a numeric value is expected or is not a type when
+a type is expected.
+
+The example below demonstrates the use of two levels of generic parameterization,
+one at the module level and one at the circuit level.
 
-The language is **strongly typed**: the compiler will reject programs that do
-not type check.  It will reject programs where a circuit or witness with a
-parameter type annotation is called with an incorrectly typed argument for that
-parameter.  It will reject programs where a circuit with a return type
-annotation returns an incorrectly typed value.  If an optional type annotation
-is omitted, the compiler will infer a type and it will reject programs where no
-such type can be inferred.
+```compact
+module M<T, #N> {
+  export circuit foo<A>(x: T, v: Vector<N, A>): Vector<N, [A, T]> {
+    return map((y) => [y, x], v);
+  }
+}
+import M<Boolean, 3>;
+export circuit bar1(): Vector<3, [Uint<8>, Boolean]> {
+  return foo<Uint<8>>(true, [101, 103, 107]);
+}
+export circuit bar2(): Vector<3, [Boolean, Boolean]> {
+  return foo<Boolean>(false, [true, false, true]);
+}
+```
 
-Types consist of built-in primitive types, user-defined types defined in the
-program, and generic type parameters in scope.  When the term "type" occurs in
-this document without any other qualifier, it means either a primitive type, a
-user-defined type, or a generic type parameter in scope.
+The body of circuit `foo` is generic with respect to the module's type parameters
+`T` and `N` as well as to the circuit's own parameter `A`.
+The module is specialized at the point of import, while the circuit is specialized
+at the point of call (in both `bar1` and `bar2`).
+
+## Compact types
+
+Compact is *statically typed*: every expression in a Compact program must have
+a static type.
+For named circuits and witnesses, the parameters and return types must be explicitly
+declared.
+For anonymous circuit expressions, the parameters and return types do not need to
+be declared but can be.
+The types of `const` bindings can also be declared or not.
+
+The language is *strongly typed*: the compiler rejects programs that do not
+type check.
+For example, it rejects programs in which a circuit or witness with a parameter
+type annotation is called with an incorrectly typed argument for that parameter,
+and it rejects programs where a circuit with a return-type annotation returns an
+incorrectly typed value.
+If an optional type annotation is omitted, the compiler attempts to infer a type
+and it rejects the program if no such type can be inferred.
+
+Types consist of built-in primitive types, ledger-state types, program-defined types,
+and references to generic type parameters in scope.
+When the term "type" occurs in this document without any other qualifier, it means
+either a primitive type, ledger-state type, a program-defined type, or a generic type
+parameter in scope.
+The use of ledger-state types is, at present, limited to typing the result of
+`default<T>` to obtain the default value of type `T`, and only constant bindings
+can have a ledger-state type.
+
+A generic type is not a valid type and so cannot, for example, be used as the
+type of a parameter or return value.
+Any attempt to do so is a static error.
+As with any other generic entity, it must be specialized at the point of use.
 
 ### Primitive types
 
 The following are the primitive types of Compact:
 
-- `Boolean` is the type of *boolean* values.  There are only two values of
+<table className="lang-ref-table"><tbody><tr><td><em>type</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>tref</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Boolean</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Field</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Opaque</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Vector</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>type</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>type</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>type</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr>
+<tr><td><em>tref</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gargs</em></a><sup>opt</sup></td></tr>
+<tr><td><em>tsize</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></tbody></table>
+
+- `Boolean` is the type of *Boolean* values.  There are only two values of
   `Boolean` type.  They are the values of the expressions `true` and `false`.
 
-- `Uint<m..n>`, where `m` is the literal `0` or a generic size parameter in
-  scope and bound to `0`, and where `n` is a natural number literal or a generic
-  size parameter in scope, is the type of *bounded unsigned integer* values
-  between `0` and `n`, both inclusive.  (The lower bound is currently required
-  to be `0`.)  `Uint` types with different bounds `0..n` are different types,
-  although [one may be a subtype of the other](#subtyping-and-least-upper-bounds).  In practice, there
-  is a (large) maximum unsigned integer value determined by the zero-knowledge
-  proving system.  The Compact implementation will signal an error if a `Uint`
-  type exceeds this maximum value.
-
-- `Uint<n>`, where `n` is a non-zero natural number literal or a generic size
-  parameter in scope and bound to a non-zero natural number, is the type of
+- `Uint<m..n>`, where `m` is the literal `0` or generic natural-number parameter bound
+  to `0`, and where `n` is a non-zero natural number literal or a generic
+  natural-number parameter bound to a non-zero natural number, is the type of
+  *bounded unsigned integer* values between `0` (inclusive) and `n` (exclusive).
+  (While the lower bound is currently required to be `0`, this restriction might
+  be lifted at some point.)
+  `Uint` types with different upper bounds are different types,
+  although the one with the lower bound is a
+  [subtype of the other](#subtyping-and-least-upper-bounds).
+  The compiler and run-time system might impose a limit on the range of supported
+  unsigned integer values.
+  If so, it is a static error whenever a `Uint` type includes values that exceed
+  this limit.
+  The current limit, if any, is given in
+  [Implementation-specific limits](#implementation-specific-limits).
+
+- `Uint<n>`, where `n` is a non-zero natural number literal or generic natural-number
+  parameter bound to a non-zero natural number, is the type of
   *sized unsigned integer* values with binary representations using up to `n`
-  bits.  This is the same type as `Uint<0..m>` where `m` is equal to `(2^n)-1`.
+  bits.  This is the same type as `Uint<0..m>` where `m` is equal to `2^n`.
   Sized integer types can be seen as a convenience for programmers.  `Uint<32>`,
   for example, can be more obvious and less error-prone than the equivalent
   `Uint<0..4294967295>`.  Any Compact program that uses sized integer types can
-  be rewritten to one that uses only bounded integer types.
-
-- `Field` is the type of elements in the scalar prime field of the
-  zero-knowledge proving system.
-
-- `[T, ...]`, where `T, ...` are zero or more comma-separated types is the type
-  of *tuple* values with element types `T, ...`.  Note that tuples are
-  heterogeneous: the element types can all be distinct.  The *length* of a tuple
-  type is the number of element types.  Tuple types with different lengths are
-  different types.  Tuple types with the same lengths but where at least one
-  element has different types are different types although [one may be a subtype
-  of the other](#subtyping-and-least-upper-bounds).
-
-- `Vector<n, T>`, where `n` is a natural number literal or else a generic size
-  parameter in scope and `T` is a type, is a shorthand notation for the tuple
-  type `[T, ...]` with `n` occurrences of the type `T`.  Note that a vector type
-  and the corresponding tuple type are two different ways of writing exactly the
-  same type.  Unless otherwise specified, type rules for vector types are
-  derived from the rules for the corresponding tuple type.
-
-- `Bytes<n>`, where `n` is a natural number literal or else a generic size
-  parameter in scope, is the type of _byte array_ values of length `n`.  `Bytes`
-  types with different lengths are different types.  `Bytes` types are used in
-  the Compact standard library for hashing.  String literals in Compact also
-  have a `Bytes` type, where `n` is the number of bytes in the UTF-8 encoding of
-  the string.
+  be rewritten to one that uses only bounded integer types, but the converse is
+  not true.
+
+- `Field` represents the set of unsigned integer values up to the maximum value of
+  the scalar prime field of the ZK proving system.
+  The current maximum field value is given in
+  [Implementation-specific limits](#implementation-specific-limits).
+
+- `[T, ...]`, where `T, ...` are zero or more comma-separated types, is the type
+  of *tuple* values with element types `T, ...`.
+  Tuples are heterogeneous: any element type can differ from any of the others.
+  The *length* of a tuple type is the number of element types.
+  Two tuple types with different lengths are different types.
+  Two tuple types where any element type of one differs from the corresponding
+  element type of the other are also different types, though one of the tuple
+  types might be a [subtype of the other](#subtyping-and-least-upper-bounds).
+
+- `Vector<n, T>`, where `n` is a natural number literal or generic natural-number
+  parameter and `T` is a type, is a shorthand notation for the tuple type
+  `[T, ...]` with `n` occurrences of the type `T`.
+  Note that a vector type and the corresponding tuple type are two different ways
+  of writing exactly the same type.
+  Unless otherwise specified, type rules for vector types are derived from the
+  rules for the corresponding tuple type.
+
+- `Bytes<n>`, where `n` is a natural number literal or a generic natural-number parameter,
+  is the type of _byte vectors_ of length `n`.
+  `Bytes` types with different lengths are different types.
+  `Bytes` types are used in the Compact standard library for hashing.
+  String literals in Compact also have a `Bytes` type, where `n` is the number
+  of bytes in the UTF-8 encoding of the string.
 
 - `Opaque<s>`, where `s` is a string literal, is the type of _opaque_ values
-  with tag `s`.  The syntax of string literals in Compact is the same as in
-  TypeScript.  `Opaque` types with different tags are different types.  Opaque
-  values can be manipulated in witnesses but they are opaque to circuits.  They
-  are represented in circuits as their hash.  The allowed tags are currently
-  only `"string"` and `"Uint8Array"`.
+  with tag `s`.
+  `Opaque` types with different tags are different types.
+  Opaque values can be manipulated in witnesses but they are opaque to circuits.
+  They are represented in circuits as their hash.
+  The only tags currently allowed are `"string"` and `"Uint8Array"`.
 
-### User-defined types
+### Program-defined types
 
-Users can define three kinds of types themselves: structures, enumerations, and contracts.
+Programs can define three kinds of new types: structures, enumerations, and
+contracts.
+They can also define structural and nominal aliases for existing types.
 
 #### Structure types
 
-Structure types are defined by a declaration beginning with the keyword
-`struct`.  Here are some examples:
+Structure types are defined via a `struct` declaration with the following form:
+
+<table className="lang-ref-table"><tbody><tr><td><em>struct-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> <em>typed-identifier</em> <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>typed-identifier</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr>
+<tr><td><em>typed-identifier</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
+
+A structure declaration has a sequence of named fields which must be separated
+either by commas or by semicolons.  Comma and semicolon separators cannot be
+mixed within a single structure declaration.  A trailing separator is allowed,
+but not required.
+
+Each structure field must have a type annotation.
+Here are a couple of examples:
 
 ```compact
 struct Thing {
@@ -127,56 +447,68 @@ struct NumberAnd<T> {
 }
 ```
 
-A _non-generic structure_ declaration introduces a named structure type, such as
-`Thing` in the first example above.  Each non-generic structure declaration
-introduces a distinct type, even when the content of the structure is identical
-to another.
+The first declaration introduces a structure type named `Thing` with two fields:
+`triple` (a vector with 3 field elements) and `flag` (a Boolean).
+The second introduces a *generic* structure type named `NumberAnd` with generic
+parameter `T` and two fields: `num` (a 32-bit unsigned integer) and `item`
+(a value of type `T`).
 
-Structure declarations can also be _generic structure_ declarations, such as
-`NumberAnd` in the second example above.  They have a non-empty list of
-comma-separated _generic parameter_ names enclosed in angle brackets.  The generic
-parameters of a generic structure declaration are in scope in its body.
-
-Generic structure declarations do not introduce a type.  To be used as a type,
-they must be _specialized_ by providing a comma-separated list of _generic
-arguments_, e.g., `NumberAnd<Uint<8>>`.  Generic arguments must be types,
-natural number literals, or a generic size parameter in scope.  Generic
-structures must be fully specialized: the number of generic arguments must match
-the number of generic parameters.
+Generic structure types are not fixed types and must eventually be *specialized*
+by supplying generic arguments, e.g., `NumberAnd<Uint<8>>`.
+When any generic structure type is specialized, it must be fully specialized:
+the number of supplied generic arguments must match the number of declared
+generic parameters.
+The effect of specializing a generic structure type is to produce the same type
+as one in which the generic parameters are replaced by the generic argument
+values.
+For example, `NumberAnd<Uint<8>>` is equivalent to `NumberAnd` if `NumberAnd`
+had been defined by:
 
-- Specializations of the same generic structure to the same types are the same
-  type.
-- Specializations of the same generic structure to different types are different
-  types.
-- Specializations of different generic structures are always different types,
-  even if the specializations are structurally equivalent.
-- Specializations of generic structures are always different from non-generic
-  structure types, even if the specialization is structurally equivalent to the
-  non-generic type.
+```compact
+struct NumberAnd {
+  num: Uint<32>;
+  item: Uint<8>
+}
+```
 
-A structure declaration has a sequence of named fields which must be separated
-either by commas or by semicolons.  Comma and semicolon separators cannot be
-mixed within a single structure declaration.  A trailing separator is allowed,
-but not required.
+It is possible and common for a generic structure type to be specialized via
+different generic arguments to produce different specialized structure types
+in different parts of a program.
 
-Each structure field must have a type annotation.
+Structure typing is always `nominal`: two types are equivalent only if they have
+the same names and same fields.
+They are distinct if they have different names even if they have the same fields.
+More precisely: each structure type is the same as any other structure type
+that has the same name, same element names (in the same order), and same element
+types (in the same order).
+It is distinct from every other type.
 
-Values of structure types are created with _structure creation_ expressions.
-These consist of the structure type (so generic structures must be specialized),
-followed by a sequence of field values enclosed in curly braces (`{ }`).  Field
-values can be given positionally, in the same order as they are declared in the
-`struct` declaration; or they can be named using the field names from the
-declaration.  Named field values can appear in any order.  Positional and named
-field values can be mixed in the same structure creation expression, but all the
-positional ones must come before any of the named ones.  See [Structure
-creation](#structure-creation) for the details.
+This means, for example, that the following program is well-typed:
 
-Using the example declarations above, structure values could be created with
-`Thing {[0, 1, 2], true}` or `NumberAnd<Uint<8>> { item: 255, num: 0 }`.
+```compact
+module M {
+  struct NumberAnd {
+    num: Uint<32>;
+    item: Uint<8>
+  }
+  export circuit bar(x: NumberAnd): NumberAnd {
+    return x;
+  }
+}
+import M;
+struct NumberAnd<T> {
+  num: Uint<32>;
+  item: T
+}
+export circuit foo(x: NumberAnd<Uint<8>>): NumberAnd<Uint<8>> {
+  return bar(x);
+}
+```
 
-Structures may not contain fields containing the same type as the structure,
-either directly or indirectly. For example, it is an error to use the following
-pair of declarations:
+Structure types must not be recursive, i.e., they cannot contain elements of the
+same type as the structure, either directly or indirectly.
+An attempt to define a recursive structure type is a static error.
+For example, it is a static error to use the following pair of declarations:
 
 ```compact
 struct Even {
@@ -192,50 +524,118 @@ export circuit doesntWork(s: Even): Odd {
 }
 ```
 
+Values of structure types are created with **structure-creation** expressions.
+These consist of the structure type (specialized if generic),
+followed by a sequence of field values enclosed in curly braces (`{ }`).
+Element values can be given positionally, in the same order as they are declared
+in the `struct` declaration; or they can be named using the element names from
+the declaration.
+Named element values can appear in any order.
+Positional and named element values can be mixed in the same structure creation
+expression, but all the positional ones must come before any of the named ones.
+See [Structure creation](#structure-creation) for the details.
+
+Using the example declarations above, structure values could be created with
+`Thing {[0, 1, 2], true}` or `NumberAnd<Uint<8>> { item: 255, num: 0 }`.
+
 #### Enumeration types
 
-Enumeration types are defined by a declaration beginning with the keyword
-`enum`.  Here is an example:
+Enumeration types are defined via a `enum` declaration with the following form:
+
+<table className="lang-ref-table"><tbody><tr><td><em>enum-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>enum</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>enum-name</em></a>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></tbody></table>
+
+An enumeration declaration has a non-empty sequence of named elements separated by commas.
+A trailing comma is allowed but not required.
+
+An enumeration declaration introduces a named enumeration type, such as `Arrow`
+in the example below:
 
 ```compact
-enum Fruit { apple, pear, plum }
+enum Arrow { up, down, left, right };
 ```
 
-An enumeration declaration introduces a named enumeration type, such as `Fruit`
-in the example above.  Each enumeration declaration introduces a distinct type.
-
-An enumeration declaration has a sequence of named values separated by commas.
-A trailing separator is allowed but not required.
+Within the scope of this declaration, a value of type `Arrow` can have one of
+three values, selected via `Arrow.up`, `Arrow.down`, `Arrow.left`, and `Arrow.right`.
 
-In the example above, the type `Fruit` has three values: `Fruit.apple`,
-`Fruit.pear`, and `Fruit.plum`.
+Two enumeration types are the same if they have the same name and the same element
+names (in the same order) and distinct otherwise.
 
 #### Contract types
 
-As of this writing, declarations of contracts and the cross-contract calls they support are
-not yet fully implemented, but the keyword `contract` used to declare contracts is reserved
-for this use.
+As of this writing, declarations of contracts and the cross-contract calls they
+support are not yet fully implemented, but the keyword `contract` used to
+declare contracts is reserved for this use.
+
+#### Type aliases
+
+Type aliases can be created via `type` declarations of the form:
+
+<table className="lang-ref-table"><tbody><tr><td><em>type-alias-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>new</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>type</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>type-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></tbody></table>
+
+Within the scope of a type-alias declaration of *type-name* for *type*, *type-name*
+is itself a type.
+Type aliases are either structural or nominal, depending on whether the optional
+`new` modifier is present:
+- A type alias *type-name* for *type* declared without the optional `new` modifier
+  is a structural type alias, i.e., *type-name* is the same type and is fully
+  interchangeable with `type`.
+- A type alias *type-name* for *type* declared with the optional `new` modifier is
+  a nominal type alias, i.e., *type-name* is a distinct type compatible with *type*
+  but neither a subtype of nor a supertype of *type* (or any other type).
+
+Any nominal type alias *type-name* for some type *type* is compatible with
+*type* in the following senses:
+- values of type *type-name* have the same representation as values of type *type*
+- values of type *type-name* can be used by primitive operations that require
+  a value of type *type*
+- values of type *type-name* can be cast explicitly to *type*, and
+- values of type *type* can be cast explicitly to type *type-name*.
+For example, within the scope of `type V3U16 = Vector<3,
+Uint<16>>`, a value of type `V3U16` can be referenced or sliced just like a vector
+of type `Vector<3, Uint<16>>`, but it cannot, for example, be passed to a function
+that expects a value of type `Vector<3, Uint<16>>` without an explicit cast.
+
+When one operand of an arithmetic operation (e.g., `+`) receives a value of some
+nominal type alias *type-name*, the other operand must also be of type *type-name*,
+and the result of performing the operation is cast to type *type-name*.
+This might cause a run-time error if the result cannot be represented by type
+*type-name*.
+
+Values of any nominal type alias *type-name* cannot be compared directly using,
+e.g., `<`, or `==`, with values of any other type, including with values of
+type *type*.
+Such comparisons require one of the operands to be cast to the type of the other.
+
+Both structural and nominal type aliases can take generic parameters, e.g.:
+```compact
+type V3<T> = Vector<3, T>;
+```
+and
+```compact
+new type VField<#N> = Vector<N, Field>;
+```
+When a generic nominal type is specialized, the specialized type is a nominal type.
 
 ### Subtyping and least upper bounds
 
-There is a *subtyping* relation on Compact types.  Informally, if a type `T` is
-a subtype of a type `S` then every value of type `T` is also a value of type `S`
-(equivalently, `S` is a supertype of `T`).  In that case, Compact allows
-implicitly using a value of type `T` where a value of type `S` is expected,
-without any programmer-supplied conversion.
+Some Compact types are related to other types via subtyping.
+Informally, if a type `T` is a *subtype* of a type `S` (equivalently, `S` is a
+*supertype* of type `T`), then every value of type `T` is also a value of type `S`,
+i.e., any value of type `T` can be used where a value of type `S` expected without
+the need for an explicit cast.
+For example, a circuit or witness can be called with argument expressions whose
+types are subtypes of the corresponding parameter type annotations, and
+a constant binding statement with a type annotation can be initialized with an
+expression whose type is a subtype of the type annotation.
 
 Subtyping is defined by the following rules:
 
 - Any type `T` is a subtype of itself (subtyping is reflexive)
 - `Uint<0..n>` is a subtype of `Uint<0..m>` if `n` is less than `m`
 - `Uint<0..n>` is a subtype of `Field` for all `n`
-- `[T, ...]` is a subtype of `[S, ...]` if the two tuple types have the length
-  and each type `T` is a subtype of the corresponding type `S`
-
-A circuit or witness can be called with argument expressions whose types are
-subtypes of the corresponding parameter type annotations.  A constant binding
-statement with a type annotation can be initialized with an expression whose
-type is a subtype of the type annotation.
+- The tuple type `[T, ...]` is a subtype of the tuple type `[S, ...]`
+  if they have the same length and each type `T` is a subtype of the
+  corresponding type `S`.
 
 The *least upper bound* (with respect to subtyping) of a non-empty set of types
 \{`T0`, ..., `Tn`} is a type `S` such that:
@@ -245,99 +645,267 @@ The *least upper bound* (with respect to subtyping) of a non-empty set of types
 - **`S` is the least upper bound:** for all upper bounds `R` of the set of types
     \{`T0`, ..., `Tn`}, `S` is a subtype of `R`.
 
-Note that least upper bounds do not necessarily exist for all sets of types.
+Note that least upper bounds do not exist for all sets of types, because
+some types (such as `Boolean` and `Field`) are not related.
 
-**Tuple and vector types:** We say that a tuple type `[T, ...]` with possibly
-distinct types `T, ...` "*has a vector type*" if the least upper bound `S` of
-the set of types \{`T`, ...} exists.  In that case, the tuple type has the
-vector type `Vector<n, S>` where `n` is the length of the tuple.  Some
-operations over tuples (such as mapping and folding) require the tuple type to
-have a vector type.
+**Tuple and vector types:** Every vector type has an equivalent tuple type:
+`Vector<n, T>` is equivalent to (in fact, the same type as) `[T1, ..., Tn]`.
+The converse is not always true.
+For example, neither `[Boolean, Field]` nor `[Uint<8>, Uint<16>]` have an
+equivalent vector type.
 
-Note that when a tuple type has a vector type, the tuple type is a subtype of
-the vector type.  Perhaps surprisingly, vector types can be subtypes of tuple
-types as well.  A vector type `Vector<n, T>` is a subtype of a tuple type
-`[S, ...]` if the tuple has length `n` and `T` is a subtype of each of the types
-`S, ...`.  The means, for instance, that a vector could be passed to a circuit
-where a tuple is expected.
+We say, however, that a tuple type `[T, ...]` with possibly distinct types `T, ...`
+"*has a vector type*" if the least upper bound `S` of the set of types \{`T`, ...}
+exists.
+In that case, the tuple type has the vector type `Vector<n, S>` where `n` is the
+length of the tuple.
+Some operations over tuples (such as mapping and folding) require the tuple type
+to have a vector type.
 
-### Default values
+When a tuple type has a vector type, the tuple type is a subtype of the vector
+type, but it might not be the same as the vector type.
+For example, `[Uint<16>, Uint<16>]` has the vector type `Vector<2, Uint<16>>`,
+and the two types are equivalent, whereas `[Uint<8>, Uint<16>]` also has the
+vector type `Vector<2, Uint<16>>`, but the types are not equivalent.
 
-Every type in Compact has a *default value* of that type.  The default values
-are as follows:
+Every vector type is a subtype of the equivalent tuple type and possibly of some
+other tuple types.
+In general, a vector type `Vector<n, T>` is a subtype of a tuple type `[S, ...]`
+if the tuple has length `n` and `T` is a subtype of each of the types `S, ...`.
+The means, for instance, that a vector can often be passed to a circuit where a
+tuple is expected.
 
-- `Boolean`: the value of the literal `false`
-- `Uint<0..n>` and `Uint<n>`: `0`
-- `Field`: `0`
-- `[T, ...]` where `T, ...` is a sequence of zero or more types: the tuple with
-  the corresponding length, each of the default value of the corresponding type
-- `Bytes<n>`: the byte array of length `n` with all zero bytes
-- `Opaque<"string">`: an empty string, i.e., `""`
-- `Opaque<"Uint8Array">`: a zero-length `Uint8Array`, i.e., `new Uint8Array(0)`
-- structure types: the struct with all fields set to the default value of their
-  type
-- enumeration types: the first value listed in the declaration
+## Patterns and destructuring
 
-### Representations in TypeScript
+The parameters of a circuit or constructor and the target of a `const` binding
+are specified via patterns:
 
-Compact's primitive types are represented in TypeScript as follows:
+<table className="lang-ref-table"><tbody><tr><td><em>pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
+<tr><td><em>pattern-struct-elt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>pattern</em></td></tr></tbody></table>
 
-- `Boolean` - `boolean`
-- `Field` - `bigint` with runtime bounds checks
-- `Uint<n>` / `Uint<0..n>` - `bigint` with runtime bounds checks
-- `[T, ...]` - the TypeScript tuple type `[S, ...]` or else the TypeScript array
-  type `S[]` with runtime length checks, where `S` is the TypeScript
-  representation of the corresponding type `T`
-- `Bytes<n>` - `Uint8Array` with runtime length checks
-- `Opaque<"string">` - `string`
-- `Opaque<"Uint8Array">` - `Uint8Array`
+In its simplest form, a pattern is just an identifier.
+For example, in the code below, the parameter of `sumTuple` is the identifier
+`x` and the targets of the two const bindings are the identifiers `a` and `b`.
 
-User-defined types are represented in TypeScript as follows:
-- `enum` instances - a `number` with runtime membership checks
-- `struct` instances with fields `a: A, b: B, ...` - an object `{ a: A, b: B, ... }`
-  where `A`, `B`, ... are the TypeScript representations of the Compact types.
+```compact
+circuit sumTuple(x: [Field, Field]): Field {
+  const a = x[0], b = x[1];
+  return a + b;
+}
+```
 
-Note that other `Opaque` types are currently not supported.
+When the parameter type is a tuple, vector, or struct, it is often convenient to use
+one of the *destructuring* forms of patterns to name individual pieces of the tuple
+or struct at the point of binding rather than extracting them at each point of use.
+For example, one could replace the above with:
 
-## Include files
+```compact
+circuit sumTuple(x: [Field, Field]): Field {
+  const [a, b] = x;
+  return a + b;
+}
+```
 
-Compact supports code separation and namespaces through separate files
-and modules.  The most basic
-of these is the statement
+or more simply with:
 
 ```compact
-include "path/to/file";
+circuit sumTuple([a, b]: [Field, Field]): Field {
+  return a + b;
+}
 ```
 
-which may appear at the top level of a source file or module. When encountered,
-the Compact compiler will search for a Compact source file at
-`path/to/file.compact` in the current directory and then
-relative to any of the directories in the
-`:`-separated environment variable `COMPACT_PATH`.
-This file *must* be found and will be included
-verbatim in place of the `include` statement.
+Here is a similar example that destructures a struct instead of a tuple:
 
-## Modules, exports, and imports
+```compact
+struct S { x: Uint<16>, y: Uint<32> }
+circuit sumStruct({x, y}: S): Field {
+  return x + y;
+}
+```
 
-A module is a collection of definitions whose namespace is hidden from
-surrounding code. A module is defined with
+Whereas the elements of a tuple pattern are necessarily given in order, the
+elements of a struct pattern need not be consistent with the order of the fields
+in the declaration.
+For example, the definition of `sumStruct` below is equivalent to the one above,
+even though the order of the pattern elements has been swapped:
 
 ```compact
-module Mod1 {
-  ...
+struct S { x: Uint<16>, y: Uint<32> }
+circuit sumStruct({y, x}: S): Field {
+  return x + y;
+}
+```
+
+By default, the names bound by the pattern are the same as the names of
+the structure elements.
+When this is not convenient, it is possible to choose different names
+for the structure elements:
+
+```compact
+struct S { x: Uint<16>, y: Uint<32> }
+circuit sumStruct({x: a, y}: S): Field {
+  return a + y;
 }
+```
 
-module Mod2<T> {
-  ...
+While `x: a` looks like an identifier with a type annotation, in this context
+it simply indicates that `a` rather than `x` is bound to the value in the
+`x` field.
+
+Patterns can be arbitrarily nested, e.g.:
+
+```compact
+struct S { x: Uint<16>, y: Uint<32> }
+circuit sumTupleStruct([{x: a1, y: b1}, {x: a2, y: b2}]: [S, S]): Field {
+  return a1 + b1 + a2 + b2;
+}
+```
+
+It is permissible and sometimes useful to not name certain parts of the tuple
+or struct.
+
+```compact
+struct S { x: Uint<16>, y: Uint<32> }
+circuit sumSomeYs([{y: b1}, , {y: b3}]: [S, S, S]): Field {
+  return b1 + b3;
+}
+```
+
+Here the input is a tuple with three elements, but the pattern skips the
+second by putting two commas between the first and third.
+Similarly, while each element of the tuple is a struct with both `x` and `y`
+fields, the pattern ignores the `x` fields simply by failing to mention them.
+
+It is a static error if a pattern implies a different shape from the
+declared or inferred type of value to be destructured.
+For example:
+
+```compact
+struct S { x: Uint<16>, y: Uint<32> }
+circuit sumStruct({x, y}: [Field, Field]): Field {
+  return x + y;
+}
+```
+
+fails because it tries to treat a tuple as a struct, while:
+
+```compact
+struct S { x: Uint<16>, y: Uint<32> }
+circuit sumSomeYs([{y: b1}, , , {y: b3}]: [S, S, S]): Field {
+  return b1 + b3;
+}
+```
+
+fails because it implies that the input tuple has four elements (including
+two skipped elements) when it actually has only three, and:
+
+```compact
+struct S { x: Uint<16>, y: Uint<32> }
+circuit sumSomeYs([{y: b1}, , {z: b3}]: [S, S, S]): Field {
+  return b1 + b3;
+}
+```
+
+fails because it tries to name a nonexistent `z` field in one of the structs.
+
+Trailing commas in a pattern imply nothing about the structure of the
+input and are ignored:
+
+```compact
+struct S { x: Uint<16>, y: Uint<32> }
+circuit sumSomeYs([{y: b1,}, , {y: b3,},]: [S, S, S]): Field {
+  return b1 + b3;
 }
 ```
 
-By default, identifiers defined within the body of a module are
-visible only within the module, i.e., they are not exported from
-the module.  Any identifier defined at or imported into the top
-level of a module can be exported from the module in one of two
-ways: (1) by prefixing the definition with the `export` keyword,
-or by listing the identifier in a separate `export` declaration.
+## Programs
+
+A compact program is a sequence of zero or more program elements.
+
+<table className="lang-ref-table"><tbody>
+<tr><td><em>program</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pelt</em> &mldr; <em>pelt</em></td></tr>
+<tr><td><em>pelt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#pragmas"><em>pragma-form</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#modules-exports-and-imports"><em>module-definition</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#exports"><em>export-form</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#imports"><em>import-form</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#include-files"><em>include-form</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#structure-types"><em>struct-declaration</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#enumeration-types"><em>enum-declaration</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#contract-types"><em>contract-declaration</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#type-aliases"><em>type-alias-declaration</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#declaring-witnesses-for-private-state-management"><em>witness-declaration</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#declaring-and-maintaining-public-state"><em>ledger-declaration</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#contract-constructor"><em>constructor-definition</em></a></td></tr>
+<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#circuits"><em>circuit-definition</em></a></td></tr>
+</tbody></table>
+
+Briefly:
+
+- A [pragma form](#pragmas) allows the program to declare the version of the compiler and/or the language that it requires
+- A [module definition](#modules-exports-and-imports) defines a Compact module, which also
+  contains a sequence of program elements in its own nested scope.
+- An [export form](#exports) exports bindings from a module or from [the program itself](#top-level-exports).
+- An [import form](#imports) imports bindings from a Compact module.
+- An [include form](#include-files) allows program elements to be included from other Compact programs
+- A [structure definition](#structure-types) defines a structure type.
+- An [enumeration definition](#enumeration-types) define an enumeration type.
+- A [contract declaration](#contract-types) declares a contract type.
+- A [type alias definition](#type-aliases) defines a type alias, possibly creating a distinct type.
+- A [witness declaration](#declaring-witnesses-for-private-state-management) declare a witness, which is a function provided by the Dapp.
+- A [ledger declaration](#declaring-and-maintaining-public-state) declares one field of the contract's public state.
+- A [constructor definition](#contract-constructor) defines the contract's constructor, if any.
+- A [circuit definition](#circuits) defines a circuit.
+
+The order of program elements in a program or module is unimportant, except that
+any module must be defined before any import of the module, and any program-defined
+types used as generic parameters by an import form must be defined before the
+import form.
+
+Detailed descriptions of struct, enum, contract, and type-alias declarations appear in
+[Compact types](#compact-types) above.
+Detailed descriptions of the remaining program elements are described in the following
+section.
+
+## Pragmas
+
+A pragma declares a constraint on either the compiler version or the language
+version. The valid identifiers for the language and compiler versions are
+`language_version` and `compiler_version`, respectively.
+
+<table className="lang-ref-table"><tbody><tr><td><em>pragma-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>pragma</tt></b>&nbsp;&nbsp;<a href="#to-be-filled-in"><em>id</em></a>&nbsp;&nbsp;<em>version-expr</em>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr>
+<tr><td><em>version-expr</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>version-expr</em>&nbsp;&nbsp;<b><tt>||</tt></b>&nbsp;&nbsp;<em>version-expr<sub>0</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>version-expr<sub>0</sub></em></td></tr>
+<tr><td><em>version-expr<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>version-expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>&&</tt></b>&nbsp;&nbsp;<em>version-term</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>version-term</em></td></tr>
+<tr><td><em>version-term</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\<=</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>>=</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>version-expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
+<tr><td><em>version-atom</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#constants"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#constants"><em>version</em></a></td></tr></tbody></table>
+
+## Modules, exports, and imports
+
+Modules in Compact are used for namespace management and also possibly to split
+programs into multiple files.
+A module is a named collection of program elements created via a `module definition`:
+
+<table className="lang-ref-table"><tbody><tr><td><em>module-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>module</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>module-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#programs"><em>pelt</em></a> &hellip; <a href="#programs"><em>pelt</em></a>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></tbody></table>
+
+A module definition makes a binding from `module-name` to the module visible in
+the program or module containing the module definition.
+Any bindings established by program elements within the module are not made
+visible, at least not until the module is imported.
+
+A module can have [generic parameters](#generic-parameters-and-arguments), in which case it is
+a *generic module* and must be specialized with generic arguments at the point of
+import.
+
+### Exports
+
+By default, identifier bindings created by the program elements within the body
+of a module are visible only within the module, i.e., they are not exported from
+the module.
+Any identifier defined at or imported into the top level of a module can be exported
+from the module in one of two ways: (1) by prefixing the definition with the
+`export` keyword, or by listing the identifier in a separate `export` declaration:
+
+<table className="lang-ref-table"><tbody><tr><td><em>export-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></tbody></table>
+
 For example, the following module exports `G` and `S` but not `F`.
 
 ```compact
@@ -353,19 +921,43 @@ module M {
 }
 ```
 
-A module can be imported into another definition scope, bringing
-all its exported entries into that scope, potentially with a prefix. For
-instance:
+Exporting a binding from a module has no effect unless the module is imported.
+
+### Imports
+
+A module can be imported into another module or into the program top level, making
+some or all of its exported bindings visible there, potentially with a prefix.
+
+<table className="lang-ref-table"><tbody><tr><td><em>import-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>import</tt></b>&nbsp;&nbsp;<em>import-selection</em><sup>opt</sup>&nbsp;&nbsp;<em>import-name</em>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gargs</em></a><sup>opt</sup>&nbsp;&nbsp;<em>import-prefix</em><sup>opt</sup>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr>
+<tr><td><em>import-selection</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>import-element</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>import-element</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>from</tt></b></td></tr>
+<tr><td><em>import-element</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr>
+<tr><td><em>import-name</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#string-literal"><em>file</em></a></td></tr>
+<tr><td><em>import-prefix</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>prefix</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></tbody></table>
+
+For example:
 
 ```compact
 module Runner {
-  export circuit run(): [] {}
+  export circuit start(): [] {}
+  export circuit stop(): [] {}
 }
-import Runner;
-// run is now in scope
-import Runner prefix SomePrefix_;
-// SomePrefix_run is now in scope
+module UseRunner1 {
+  import Runner;
+  // start and stop are now in scope
+}
+module UseRunner2 {
+  import { start } from Runner;
+  // start is now in scope, but not stop
+}
+module UseRunner3 {
+  import Runner prefix Runner$;
+  // Runner$start and Runner$stop are now in scope, but not stop or run
+}
+```
 
+and
+
+```
 module Identity<T> {
   export { id }
   circuit id(x: T): T {
@@ -373,114 +965,136 @@ module Identity<T> {
   }
 }
 import Identity<Field>;
-// id is now in scope, with Field as type T
+// id is now in scope, specialized to type Field
 ```
 
-Compact's standard library can be imported by `import CompactStandardLibrary`.
-The standard library defines a number of useful types and circuits along with
-ledger ADTs such as `Counter`, `Map`, and `MerkleTree`.
-
-When importing module `M`, if the program does not contain a visible module definition
-the compiler looks in the file system in the relative path of the current directory for `M.compact`.
-In the case where a module is defined in a different program (file), the program must only contain
-a top-level module definition. Otherwise, the compiler throws a static error stating that the program
-does not contain a single module definition. For example, the program `M.compact` below defines
-a module:
+When an import for some module *M* appears before any visible definition
+of *M*, the module is assumed to reside in the filesystem, and it is imported
+directly from there.
+If *M* is an identifier `M`, a definition for module `M` must be contained within
+the file `M.compact` in the same directory as the importing file or in one of the
+directories in the compact path.
+If *M* is a string `"{prefix/}M"`, where `{prefix/}` is either empty or is
+a pathname ending in a directory separator, a definition for a module named
+`M` must be contained within a file `M.compact` that is:
+- (a) if `{prefix/}M.compact` is an absolute pathname, then exactly at
+  `{prefix/}M.compact`, otherwise
+- (b) at `{prefix/}M.compact` relative to the directory of the importing
+  file or to one of the directories in the compact path.
+Details on the search order and the mechanism for setting the compact path are
+given in [Compiler Usage](../compilation-and-tooling/compiler-usage).
+
+In any of these cases, it is a static error if `M.compact` is not found, if it
+does not contain a definition for a module named `M`, or if it contains anything
+else other than comments and whitespace.
+
+Several examples follow.
+
+Example 1: The file `M.compact` below contains a single module definition:
 
 ```compact title=M.compact
 module M {
   export { F };
   export struct S { x: Uint<16>, y: Boolean }
   circuit F(x: S): Boolean {
-    return S.y;
+    return x.y;
   }
 }
-// circuit cant_exists() : [] {}
-// If cant_exists is uncommented, the compiler will throw an error when compiling
-// test.compact
 ```
 
-Then, `test.compact` imports `M`:
-
-```compact title=test.compact
-//module M {
-//  export { G };
-//  export struct S { x: Uint<16>, y: Boolean }
-//  circuit G(x: S): Boolean {
-//    return S.y;
-//  }
-//}
-// If M is uncommented, the compiler will import this module and not the one
-// defined in M.compact. In this case, the compiler will throw an error for
-// exporting F.
+Then, `test1.compact` import `M` from `M.compact`:
 
+```compact title=test1.compact
 import M;
 export { F };
 ```
 
-The import syntax allows the module to be identified by a string pathname. In this case, the compiler
-first looks for the imported module relative to the current directory (the path of the importing
-program) and then in the directories identified by `COMPACT_PATH`. Importing by a pathname allows
-importing multiple modules with the same name. For example, consider the program `M.compact`:
+whereas `test2.compact` uses its own definition of `M`:
+
+```compact title=test2.compact
+module M {
+  export { G };
+  export struct S { x: Uint<16>, y: Boolean }
+  circuit G(x: S): Boolean {
+    return x.y;
+  }
+}
+import M;
+export { G };
+```
+
+Importing by a pathname allows multiple modules with the same name
+to be imported into the same scope.
+For example:
+
+The file `M.compact` below contains a single module definition, as before:
 
 ```compact title=M.compact
 module M {
   export { F };
   export struct S { x: Uint<16>, y: Boolean }
   circuit F(x: S): Boolean {
-    return S.y;
+    return x.y;
   }
 }
 ```
 
-And the program `A/M.compact`:
+and `A/M.compact` contains a different module definition:
 
 ```compact title=A/M.compact
 module M {
   export { F };
   export struct S { x: Uint<16>, y: Boolean }
   circuit F(x: S): Boolean {
-    return S.y;
+    return x.y;
   }
 }
 ```
 
-And finally the program `test.compact` can export both `$F` and `A_F` but not `$G`:
+Then the program `test.compact` can define `M` and import all three of
+`M`, `"M"`, and `"A/M"`:
 
 ```compact title=test.compact
 module M {
-  export { G };
+  export { F };
   export struct S { x: Uint<16>, y: Boolean }
-  circuit G(x: S): Boolean {
-    return S.y;
+  circuit F(x: S): Boolean {
+    return x.y;
   }
 }
+import M prefix M1$;
+import "M" prefix M2$;
+import "A/M" prefix M3$;
 
-import "M" prefix $;
-// this imports M.compact and not the module M defined above
+export { M1$F, M2$F, M3$F };
+```
 
-import "A/M" prefix A_;
+### The compact standard library
 
-export { $F
-  ,A_F
-//  ,$G
-// uncommenting this will result in an error
-  };
-```
+Compact's standard library can be imported by `import CompactStandardLibrary`.
+The standard library defines a number of useful types and circuits along with
+ledger-state types such as `Counter`, `Map`, and `MerkleTree`.
 
+### Top-level exports
 
-## Top-level exports
+Certain kinds of program elements can be exported from a contract's top level,
+namely circuits, program-defined types, and ledger fields.
+Exporting them makes them visible outside of the contract, i.e., to the
+TypeScript driver for the smart contract.
 
 The circuits exported at the top level of a contract (i.e., not merely exported
-from a module) are the entry points of the contract and may not take generic arguments.
+from a module) are the entry points of the contract.
 Although multiple circuits with the same name are allowed generally to support
 [function overloading](#circuit-and-witness-calls), it is a static error if more
 than one circuit with the same name is exported from the top level.
+It is also a static error for a generic circuit, i.e., one with generic parameters,
+to be exported from the top level.
 
-User-defined types exported from the top level of the main file can be used
+Program-defined types exported from the top level of the main file can be used
 to describe the argument and return types of witnesses and exported circuits;
-these may accept generic arguments, but generic arguments not actually used as types
-are dropped in the exported type.  For example:
+these may accept generic arguments, but generic arguments marked as sizes rather
+than types are dropped in the exported type.
+For example:
 
 ```compact
 export struct S<#n, T> { v: Vector<n, T>; curidx: Uint<0..n> }
@@ -496,923 +1110,984 @@ export type S<T> = { v: T[]; curidx: bigint }
 Ledger field names exported from the top level are visible for direct inspection
 by code outside of the contract via the generated TypeScript `ledger()` function.
 
-## Notation
-
-The syntax of Compact programs is given by an EBNF grammar.  We use the following
-notational conventions in the grammar:
-
-- Terminals are in <b><tt>bold monospaced</tt></b> font
-- Non-terminals are in <em>emphasized</em> font
-- Alternation is indicated by a vertical bar (`|`)
-- Repetition of zero or more items is indicated by enclosing them in curly
-  braces (`{` and `}`)
-- Optional items are indicated by enclosing them in square brackets (`[` and
-  `]`)
-
-A Compact program is *well-typed* if it does not contain any type error.  If
-a program element such as a type declaration, expression, or statement contains
-a type error, then the Compact compiler will not compile that program.
-
-## Scope and binding
-
-In Compact, scope defines the visibility.  An identifier
-is a name that can refer to an *entity*: a variable, a constant, an expression,
-a type, a module, a parameter,
-a generic parameter, a circuit, a witness, or a ledger.
-
-Binding is the process of associating an identifier with an entity.
-The *scope* of an identifier is the region of code where the identifier
-is "bound" to its entity and can be referenced. An identifier can be
-referenced at program points that are in the scope of the identifier,
-otherwise it is a static error.
- It is a static error if an identifier is bound more than once in a
-same scope.  However, the Compact compiler accepts multiple bindings of a same
-identifier for unexported circuits.
-
-Scopes can be nested, just like nested boxes.  The outermost box is the *global
-scope* of a program.  Identifiers declared here, such as types, modules,
-top-level circuits, or ledger fields, are visible throughout the entire contract.
-Within a global scope, zero or more local scopes can be defined, which are smaller,
-nested boxes.
-
-In Compact, the primary local scopes are defined in:
-- [structure types](#structure-types): All generic parameters in a structure type declaration
-are visible only within its declaration.
-- [modules](#modules-exports-and-imports): All identifiers defined inside a module are
-visible only within it unless they are explicitly exported.
-- [circuits](#circuits): The circuit's parameters, generic parameters, and any `const` bindings
-defined inside its body are local to that circuit.
-- [blocks](#statements): All identifiers defined by a `const` binding inside a block are
-visible only within it.
-- [`for` loops](#for-loop): All identifiers introduced in a `for` loop are visible only
-inside that `for` loop.
-- [anonymous circuits](#circuit-and-witness-calls): Parameters of an anonymous circuit are
-visible only in its body.
-- [constructor](#contract-constructor): The constructor's parameters and any `const` bindings
-defined inside its body are visible only within the constructor.
-
-A key principle of scoping is *shadowing*.  Shadowing occurs when an identifier in an
-inner scope has the same name as an identifier in an outer scope.  The inner identifier
-"shadows" the outer one: within the inner scope, the name refers to the local identifier,
-not the outer one. For example:
-
-```compact
-circuit c(): Field {
-  const answer = 42;
-  { // This is a nested block creating a new scope
-    const answer = 12; // This 'answer' shadows the outer one
-    assert answer != 42 "shadowing didn't work!"; // assertion passes
-  }
-  return answer; // returns 42 (the outer 'answer')
-}
-```
+It is a static error to export any other kind of binding from the top level.
 
-### Generic parameter references
-
-Generic parameters are declared in generic [module declarations](#modules-exports-and-imports),
-generic [structure type declarations](#structure-types),
-generic [circuit definitions](#circuits),
-and generic [witness declarations](#declaring-witnesses-for-private-state).
-
-For generic modules, they are in scope within the module.
-For generic structures, they are in scope for the structure's fields.
-For generic circuits, they are in scope in the circuit's
-parameters, its return type annotation, and its body.  In
-these scopes, a reference to a generic parameter (that is not otherwise shadowed by
-some other identifier binding) is either a type or a natural-number size.
-
-## Parameters, patterns, and destructuring
-
-Each parameter of a circuit or a constructor can either be a single name (identifier) or a pattern.
-A pattern is a destruction of a tuple, a vector, or a structure value.
-Pattern parameters can appear in [circuit definitions](#circuits),
-[anonymous circuits](#circuit-and-witness-calls), and [constructors](#contract-constructor).
-Patterns can also apper in [`const` binding statements](#const-binding-statement).
-
-<table className="lang-ref-table"><tbody><tr><td><em>parg</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>p</em></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<em>p</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>type</em></td></tr><tr><td><em>p</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>id</em></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<b>[</b>&nbsp;&nbsp;<tt>[</tt>&nbsp;&nbsp;<tt>\{</tt><b>,</b><tt>}</tt>&nbsp;&nbsp;<em>p</em>&nbsp;&nbsp;<tt>\{</tt><b>,</b><tt>}</tt>&nbsp;&nbsp;<tt>\{</tt><b>,</b>&nbsp;&nbsp;<tt>\{</tt><b>,</b><tt>}</tt>&nbsp;&nbsp;<em>p</em>&nbsp;&nbsp;<tt>\{</tt><b>,</b><tt>}</tt>&nbsp;&nbsp;<tt>}</tt>&nbsp;&nbsp;<tt>]</tt>&nbsp;&nbsp;<b>]</b></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<tt>[</tt>&nbsp;&nbsp;<em>id</em>&nbsp;&nbsp;<tt>[</tt><b><tt>:</tt></b>&nbsp;&nbsp;<em>p</em>]&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>id</em>&nbsp;&nbsp;[<b><tt>:</tt></b>&nbsp;&nbsp;<em>p</em>]}&nbsp;&nbsp;<tt>]</tt>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></tbody></table>
-
-A *tuple pattern* destructures a tuple or a vector value and
-it has the form `[id, ...]` where `id, ...` is a sequence of zero or more comma-separated identifiers.
-A type annotation can be declared for a tuple pattern with the form `[id, ...] : T`
-where `T` is a Compact type or a generic type parameter in scope. It is a static type error if `T`
-is not a tuple or a vector type.  It is a static type error if the length of the sequence of identifiers (the
-number of elements in the sequence of identifiers) is larger than the
-length of the tuple or vector type.  Both the sequence of identifiers and tuple type can have a trailing comma.
-The sequence of identifiers can leave out some identifiers by dropping their identifiers to skip binding
-some indices of the tuple, for example, `[x, , , y] : [Boolean, Boolean, Boolean, Boolean]`
-binds only the first and last element of a tuple of four boolean values.  However, the tuple
-type must be fully specified.  The dropped identifiers count toward the length of the tuple pattern if there
-exists a named identifier after the dropped ones.  For example, `[x, , , y]`
-matches a tuple or vector with 4 or more elements, while
-`[x, y, , ]` matches a tuple or vector with 2 or more elements.
-
-A tuple pattern has a more general form `[p, ...]` where `p, ...` is a sequence of zero or
-more comma-separated patterns where a pattern can be an identifier, a tuple pattern, or a structure pattern.
-Where a type annotation exists for a tuple pattern it is a static type error if a pattern has
-the form of a tuple or a structure pattern but its corresponding type annotation
-does not have a tuple/vector or a structure type, respectively.  For example, `[x, [y, z]] : [Field, Boolean]`
-results in a static type error since the pattern `[y, z]` must have a tuple/vector type.
-
-A *structure pattern* desctructures a structure value and
-it has the form `{f, ...}` where `f, ...` is a sequence of zero or more comma-separated fields.
-A type annotation can be declared for a structure pattern with the form `{f, ...} : T`
-where `T` is a Compact type or a generic type parameter in scope.  It is a static type error if `T` is
-not a structure type.  It is a static type error if the sequence of fields contains fields that are not
-fields of `T`, however, the sequence of fields does not have to bind all the fields of `T`.  The sequence
-of fields can contain a trailing comma, and the order of fields in the sequence `f, ...` does not have
-to match the order of fields in the type declaration of `T`.
-
-A structure pattern can optionally bind a field to a new identifier by `{f: p, ...}` where `f: p, ...` is a
-sequence of zero or more comma-separated field `f` bound to pattern `p`.  If the pattern `p` is an identifier `x`,
-the value of the field `f` is accessible via the name `x` rather than by the name `f`.
- It is a static type error to bind the same identifier
-more than once in a scope of destructions, for example, `{a: b, b} : S` is a static type error since `b`
-is bound to both fields of the structure type, `S` is defined as
-`struct S {a: Field, b: Boolean}`.
-If the pattern `p` is a tuple or structure desctruction it is a static type error if the
-field `f` does not have a tuple or structure type, respectively.  The optional expansion to patterns can be
-mixed and matched with no expansion, for example, `const {a: x, b} = S {a = 1, b = true}` is valid given the structure definition
-`struct S {a: Field, b: Boolean}`.  This constant binding binds `x` to `1` and `b` to `true`.
+## Include files
 
-## Circuits
-The basic operational element in Compact is the `circuit`. This corresponds
-closely to a function in most languages but is compiled directly into a
-zero-knowledge circuit.
-
-<table className="lang-ref-table"><tbody><tr><td><em>prog</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;[<b><tt>export</tt></b>]&nbsp;&nbsp;[<b><tt>pure</tt></b>]&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;<em>id</em>&nbsp;&nbsp;<em>gpars</em>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;[<em>p</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>type</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>p</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>type</em>}]&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>type</em>&nbsp;&nbsp;<em>block</em>&nbsp;&nbsp;</td></tr><tr><td><em>gpars</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;[<b><tt>\<</tt></b>&nbsp;&nbsp;[<em>gpar</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>gpar</em>}]&nbsp;&nbsp;<b><tt>></tt></b>]&nbsp;&nbsp;</td></tr><tr><td><em>gpar</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>#</tt></b><em>id</em></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<em>id</em></td></tr><tr><td><em>block</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>stmt</em>&nbsp;&nbsp;<b><tt>;</tt></b>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></tbody></table>
-
-Circuits can optionally be exported.  [They can also optionally be declared as `pure`
-circuits.](#pure-and-impure-circuits) *Non-generic* circuit definitions have the form
-`circuit c(p: T, ...): R block` where `c` is the name of the circuit, `p: T, ...` is a
-sequence of zero or more comma-separated
-[parameter declarations with type annotations](#parameters-patterns-and-destructuring),
-`R` is the *return type* of the circuit:
-the circuit must return an expression of type `S` where `S` is a subtype of `R`, and
-`block` is a sequence of zero or more semicolon-delimited statements enclosed in
-curly braces (`{ }`) where
-each path through the block must end with a `return` statement, unless the return
-type is `[]`.
-
-Circuits can be generic. *Generic* circuit definitions have the form
-`circuit c<V, ...>(p: T, ...): R block` where `V, ...` is a sequence of zero or
-more generic parameters. These generic parameters are in scope in type annotations of parameter declarations `p: T, ...`,
-the return type `R`, and the circuit's `block`.
-If `V` is a generic size parameter it must be prefixed
-with `#`, however, when it is referenced in its [scope](#generic-parameter-references)
-the `#` prefix must be dropped. It is a static type error to export generic circuits.
+Compact allows programs and modules to be split into multiple files and spliced
+togther via `include` forms, which have the following syntax, where `file` is a
+string literal specifying a filesystem pathname for file to be included:
 
-### Pure and impure circuits
+<table className="lang-ref-table"><tbody><tr><td><em>include-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>include</tt></b>&nbsp;&nbsp;<a href="#constants"><em>file</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></tbody></table>
 
-A Compact circuit is considered *pure* if it computes its outputs from its
-inputs without reference to or modification of public state (via the ledger)
-or private state (via witnesses).
-In practice, the compiler considers a circuit to be impure if
-the body of the circuit contains a ledger operation, a call to any impure
-circuit, or a call to a witness.
+`file` can be an absolute pathname, one that is relative to the directory
+of the including file, or one that is relative to one of the directories in the
+compact path.
+Details on the search order and the mechanism for setting the compact path are
+given in [Compiler Usage](../compilation-and-tooling/compiler-usage).
 
-Some external circuits defined in `CompactStandardLibrary` are witnesses;
-calls to these make the caller impure.
-The remainder are considered pure, so calls to those do not make the caller impure.
+It is a static error if the file is not present or cannot be read.
+If present and readable, the file must contain a sequence of syntactically
+valid program elements, and these elements are treated as if they had
+been present in the including file in place of the `include` form.
 
-A Compact program can declare a circuit to be pure by prefixing the circuit
-definition with the `pure` modifier, which must follow the `export` modifier,
-if present, e.g.:
+## Declaring witnesses for private state management
 
-```compact
-pure circuit c(a: Field): Field {
-  ...
-}
+A user's private state should be maintained in some secure way by the
+TypeScript driver of a smart contract and never stored directly in the public
+state of the contract.
+A contract must sometimes prove something about some piece of private state,
+however, as well as cause an update to the private state.
 
-export pure circuit c(a: Field): Field {
-  ...
-}
-```
+The TypeScript driver of the smart contract can provide pieces of private state
+to the contract via the arguments of some exported circuit, and it can update
+the private state based on the return values of the exported circuit.
 
-The only effect of the `pure` modifier is that the compiler will
-flag the declaration as an error if its own analysis determines
-that the circuit is actually impure.
-The pure modifier allows an application to ensure that the circuit
-will be present in the `PureCircuits` type declaration and via the
-`pureCircuits` constant in the TypeScript module produced for a
-(correct) Compact program by the Compact compiler.
+A circuit can also access or update private state as it operates via *witnesses*.
+Witnesses are callback functions provided by the TypeScript driver.
 
-### Statements
+Witnesses must be declared to make them visible to the circuits of a contract.
+A witness declaration does not include a body, because the implementation is
+provided by the TypeScript driver.
 
-A statement may be
-- a [`for` loop](#for-loop)
-- an [`if` statement](#if-statement)
-- a [`return` statement](#return-statement)
-- a block - a sequence of zeror or more statements in a nested scope, enclosed by curly braces
-- a [`const` binding statement](#const-binding-statement)
-- an [expression](#expressions)
+<table className="lang-ref-table"><tbody>
+<tr><td><em>witness-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>witness</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<em>simple-parameter-list</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr>
+<tr><td><em>simple-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>typed-identifier</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
+<tr><td><em>typed-identifier</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr>
+</tbody></table>
 
-#### `for` loop
+Witness declarations can appear anywhere among the program elements of
+a module or the contract's top level.
 
-A `for` loop repeats for a fixed number of iterations, using one of the two
-syntaxes below:
+For instance:
 
 ```compact
-for (const i of <vector>) <statement>
-
-for (const i of <lower>..<upper>) <statement>
+witness W(x: Uint<16>): Bytes<32>;
 ```
 
-#### `if` statement
-
-An `if` statement is of one of the following forms:
+defines a witness `W`, to which the contract provides a 16-bit unsigned value
+and from which the contract receives 32 bytes of some presumably private data.
 
-```compact
-if (testexpr)
-  <statement>
+:::danger
 
-if (testexpr)
-  <statement>
-else
-  <statement>
-```
+Do not assume in your contract that the code of any `witness` function
+is the code that you wrote in your own implementation.  Any DApp may
+provide any implementation that it wants for your `witness` functions.
+Results from them should be treated as untrusted input.
 
-#### `return` statement
+:::
 
-A `return` statement can appear only in a block.
+## Declaring and maintaining public state
 
-<table className="lang-ref-table"><tbody><tr><td><em>stmt</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;[<em>expr</em>]<b><tt>;</tt></b></td></tr></tbody></table>
+A contract declares the shape of its public state through *ledger declarations*.
 
-A `return` statement takes either the form `return;` or `return e;` where `e` is a Compact expression.
-For a `return` statement of form `return e;` it is a static type error if the static type of `e` is not
-a [subtype](#subtyping-and-least-upper-bounds)
-of the declared return type `R` of a circuit (accounting for [anonymous circuits](#circuit-and-witness-calls)
-and [constructors](#contract-constructor)) if one exists.
-For a `return` statement of the form `return;`, it is a static type error if the return type `R` is
-not [].
+Each ledger declaration defines one piece of information that the contract might
+store in the public ledger.
+Multiple ledger declarations can appear in a program, or none.
+They can appear anywhere among the program elements of a module or the contract's
+top level.
 
-If the return type `R` is `[]` the `return` statement can be dropped.  However, for return types other than
-`[]` it is a static type error if there exists a path in a circuit block that does not have a `return`
-statement, for example,
-`export circuit foo(c: Boolean): Boolean { return ((x) : Boolean => { if (c) return x; })(c);}`
-causes a static type error since the `else` branch of the `if` statements has type `[]`.
-It is a static type error to have a statement after a `return` statement in a same block.
+<table className="lang-ref-table"><tbody><tr><td><em>ledger-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>sealed</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></tbody></table>
 
-#### `const` binding statement
+A ledger declaration binds a ledger field name to one of a
+set of predefined [ledger-state types](#ledger-state-types).
+For instance:
 
-The syntaxt of a Compact constant binding is the same as a constant binding in TypeScript.
+```compact
+import CompactStandardLibrary;
 
-<table className="lang-ref-table"><tbody><tr><td><em>stmt</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<tt>\{</tt>&nbsp;&nbsp;<em>parg</em>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>parg</em>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<em>expr</em>}&nbsp;&nbsp;<tt>}</tt></td></tr></tbody></table>
+ledger val: Field;
+export ledger cnt: Counter;
+sealed ledger u8list: List<Uint<8>>;
+export sealed ledger mapping: Map<Boolean, Field>;
+```
 
-A `const` binding brings a new identifier into scope and assigns it to the value of an expression.
+### Ledger-state types
 
-It can bring into scope a *single pattern* with `const p = e` where `p` is the new pattern and `e` is an expression.
-`p` can be an identifier, a tuple pattern, or a structure pattern:
-- If `p` is an identifier the static type of the identifier is the type of `e` and the identifier is bound to the value of `e`.
+The following *ledger-state types* are supported.
 
-- If `p` is a tuple pattern
-`e` must have a tuple or a vector type, otherwise it is a static type error.  It is a static type error
-if the number of identifiers are more than the length of tuple `[v, ...]` where `[v, ...]` is the result of evaluating `e`.
-However, it is not a static type error if the number of identifiers are less than the length of `[v, ...]`, in this case
-identifiers are bound from left-to-right to elements in `[v, ...]` until there is no more identifiers to bind to the next
-elements of `[v, ...]`.  The sequence of identifiers does not have to bind every element of a tuple, that is, it can drop
-some of the identifiers to skip binding them, for example, `const [a, , b] = [1, 2, 3]` binds `1` to `a` and `3` to `b`.
-These skipped identifiers are counted towards the length of the sequence of identifiers. For example, `[a, , b]`
-matches a tuple or vector with three or more elements.
-
-- If `p` is a structure pattern, `e` must have a structure type, otherwise it is a static type error.
-The fields of pattern `p` must be
-a subset of the structure type's fields, otherwise it is a static type error.  The order of fields does not matter.
+- `T`, for any regular Compact type `T`
+- `Counter`
+- `Set<T>`, for any Compact type `T`
+- `Map<K, T>`, for any Compact types `K` and `T`
+- `Map<K, V>`, for any Compact type `K` and ledger-state type `V` (see the following section)
+- `List<T>`, for any Compact type `T`
+- `MerkleTree<n, T>`, for a compile time integer `1 < n <= 32`, and any Compact
+  type `T`
+- `HistoricMerkleTree<n, T>`, for a compile time integer `1 < n <= 32`, and any
+  Compact type `T`
 
-A `const` binding can bring into scope *multiple patterns* with `const p = e, ...` where `p = e` is a
-sequencce of one or more comma-separated single
-pattern constant bindings.  It is a static type error if the The static typing of rules described for a single pattern binding must hold
-of each identifier is the type of its assigned expression.
-Constant bindings are evaluate from left-to-right.  This means that an identifier can only be referenced after it is
-bound.  It is a static type error to bind an identifier more than once. It is a static type error to reference an
-identifier before binding it.
+Each ledger type supports a set of operations, which can be invoked with
 
-A `const` binding can optionally declare the type for each binding with `const p: T = e`. It is a static type error if `e`
-does not have type `T`.  In `const` statements with multiple pattern/expression pairs,
-it is permissible to for some of the pairs to include types and some not to include types, that is,
-a binding such as `const x: Field = 2, y = true` is valid.
+```compact
+<field name>.<operation>(<arguments ...>)
+```
 
-Any identifier bound by `const` may not be reused within a block, and identifiers cannot be reassigned, although they can be [shadowed in
-a nested block](#scope-and-binding).  Constant initializer expressions are evaluated when the binding statement is executed.
+A ledger field that is declared with a Compact type `T` implicitly has the type
+`Cell<T>`, which supports several operations, including `read`, `write`, and
+`reset_to_default`.
+For example:
 
-### Expressions
+```compact
+ledger F: Uint<16>;
+export circuit putF(x: Uint<16>): [] {
+  F.write(disclose(x));
+}
+export circuit getF(): Uint<16> {
+  return F.read();
+}
+```
 
-This section describes the syntax of Compact expressions and provides their
-static typing rules and their evaluation rules.
+The `read` operation of the `Cell` ledger-state type can be abbreviated to,
+simply, a reference to the field name, and the `write` operation can be abbreviated
+to an assignment of the form `<field name> = expr`.
+So the above can be written more simply as:
 
-A Compact expression either has a static type, or else it contains a type error.
-The static type of an expression, if it has one, is either a Compact type or
-else a ledger state type.  If an expression in a program contains a type error,
-it means that the Compact compiler will not compile that program.
-Subexpressions of Compact expressions are always required to be well-typed
-(free from type errors).
+```compact
+ledger F: Uint<16>;
+export circuit putF(x: Uint<16>): [] {
+  F = disclose(x);
+}
+export circuit getF(): Uint<16> {
+  return F;
+}
+```
 
-Every Compact expression either evaluates to a value, or else it raises an
-exception.  The evaluation of an expression is defined in terms of the
-evaluation of its subexpressions.  If the evaluation of a subexpression raises
-an exception, then the evaluation of the containing expression will stop and
-raise the same exception.
+The `read` operation of the `Counter` type can be abbreviated in the same way,
+and its `increment` and `decrement` operations can be abbreviated to assignments
+of the form `<field name> += expr` and `<field name> -= expr`.
+For example:
 
-#### Literals
+```compact
+import CompactStandardLibrary;
+ledger F: Counter;
+export circuit incrF(): [] {
+  F += 1;
+}
+export circuit decrF(): [] {
+  F -= 1;
+}
+export circuit getF(): Uint<64> {
+  return F;
+}
+```
 
-Compact has syntax for boolean, numeric, and string literal expressions.
+The ledger-state types are designed in to minimize the extent to which a circuit
+proof depends upon the exact value of a ledger-state field as of when a transaction
+is created to minimize the chance of the transaction being rejected when the
+proof is checked on chain.
+For example, `Counter` increment and decrement do not commit to the current value
+of the counter.
+While the preceding example could be written a Cell instead:
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>true</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>false</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>nat</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>str</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>pad</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>nat</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>str</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></tbody></table>
+```compact
+ledger F: Uint<64>;
+export circuit incrF(): [] {
+  F = F + 1 as Uint<64>;
+}
+export circuit decrF(): [] {
+  F = F - 1;
+}
+export circuit getF(): Uint<64> {
+  return F;
+}
+```
 
-__Boolean literals__ are the reserved words `true` and `false`.
-The static type of a boolean literal is `Boolean`.
-It evaluates to one of the two boolean values.
+A call to `incrF` or `decrF` involves an explicit read of `F`, and if `F` does
+not have the same value when the proof is checked as when the transaction is
+created, the proof fails and the transaction is rejected.
 
-__Numeric literals__ are non-negative decimal integers.  They are either the
-number `0` or a sequence of digits starting with a non-zero digit.  The static
-type of a natural number literal `n` is `Uint<0..n>`.
+A comprehensive description of ledger-state types and operations can be found in
+the Compact [ledger data type documentation](ledger-adt).
 
-There is an implementation-defined maximum unsigned integer value.  A numeric
-literal larger than this value will have an invalid static type `Uint<0..n>` for
-some `n` larger than the maximum unsigned integer.  This expression will be a
-static type error unless the literal is smaller than the maximum `Field` value
-and is used in a type cast expression of the form `e as Field`.
+### Nested state types in the `Map` type
 
-A natural number literal evaluates to the unsigned integer value that it
-denotes.
+The only ledger-state type in which values of other state types may be held is
+`Map`.
+The key values in a `Map` must be regular Compact types, but the mapped values
+may be counters, sets, lists, other maps, and so on.
 
-__String literals__ use TypeScript string literal syntax.  Note that they can
-therefore be enclosed in either single (`'`) or double (`"`) quotes, and they
-can contain escaped characters.  Strings are represented by their UTF-8
-encoding.  The **length** of a string is the length of its UTF-8 encoding.
-The static type of a string literal is `Bytes<n>` where `n` is the length of
-the string.
-It evaluates to a byte array containing its UTF-8 encoding.
+Here is a small example:
 
-In addition, the expression `pad(n, s)` is a string literal, where
-`pad` is a reserved word, `n` is a natural number literal and `s` is a string
-literal whose length must be less than or equal to `n`.
-The static type of a padded string literal `pad(n, s)` is `Bytes<n>`.
-It evaluates to a byte array containing the UTF-8 encoding of `s`, followed by
-`0` bytes up to the padded length `n`.
+```compact
+import CompactStandardLibrary;
 
-#### Variable references
+ledger fld: Map<Boolean, Map<Field, Counter>>;
 
-The syntax of Compact identifiers is the same as the syntax of TypeScript
-identifiers.  A variable is an identifier that is bound as a parameter in a
-circuit declaration or else as a constant in a `const` binding statement.
+export circuit initNestedMap(b: Boolean): [] {
+  fld.insert(disclose(b), default<Map<Field, Counter>>);
+}
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>id</em></td></tr></tbody></table>
+export circuit initNestedCounter(b: Boolean, n: Field): [] {
+  fld.lookup(b).insert(disclose(n), default<Counter>);
+}
 
-__Circuit parameters__ are bound by circuit declarations.
-The static type of a circuit parameter reference is the declared static type
-given by the parameter declaration's type annotation.
-It evaluates to the value of the corresponding argument expression that was
-passed to the circuit call.
+export circuit incrementNestedCounter(b: Boolean, n: Field, k: Uint<16>): [] {
+  fld.lookup(b).lookup(n).increment(disclose(k));
+}
 
-__Constants__ are bound by `const` binding statements.  If the binding statement
-has a type annotation, then the constant reference's static type is the declared
-static type given by the type annotation, and the type of the right-hand side
-initializer expression must be a subtype of the declared type.  If the binding
-statement does not have a type annotation, then the constant reference's static
-type is the inferred static type (that is, the type of the binding statement's
-initializer expression).  A constant reference evaluates to the value of the
-binding statement's initializer expression.
+export circuit readNestedCounter1(b: Boolean, n: Field): Uint<64> {
+  return fld.lookup(b).lookup(n).read();
+}
 
-Note that constant references can have ledger state types because they can be
-initialized with a ledger state type's default value.
+export circuit readNestedCounter2(b: Boolean, n: Field): Uint<64> {
+  return fld.lookup(b).lookup(n);
+}
+```
 
-#### Default values of a type
+In this example,
+- `fld` is bound to a `Map` from `Boolean` values to `Map`s from `Field` values to `Counter`s
+- `initNestedMap` can be used to create the inner `Map` for a particular outer-`Map` key
+- `initNestedCounter` can be used to create a `Counter` for a given outer-`Map` key and a given inner-`Map` key
+- `incrementNestedCounter` can be used to increment an existing `Counter` for a given outer-`Map` key and a given inner-`Map` key
+- either `readNestedCounter1` or `readNestedCounter2` can be used to read the value of an existing `Counter`
+  for a given outer-`Map` key and a given inner-`Map` key.
 
-Every Compact type and ledger state type has a default value.
+Notes:
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>default</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>type</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>default</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>ledger-adt</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr></tbody></table>
+1. Nesting is permitted only within `Map` values.  That is, nesting is not permitted in
+   `Map` keys or within any ledger-state type other than `Map`.
+2. Nested values must be initialized before first use.  The syntax `default<T>`
+   is used to create default ledger-state type values, just as it can be used to
+   create default Compact type values.
+3. Ledger state type values are not first-class objects, so when
+   accessing a nested value, the entire indirection chain must be
+   used.  For example, the following results in a compiler error:
 
-The expression `default<T>`, where `T` is a Compact type or a ledger state type,
-has static type `T`.
-It evaluates to the default value of that type.
+   ```compact
+   export circuit incrementNestedCounter(b: Boolean, n: Field, k: Uint<16>): [] {
+     fld.lookup(b); // ERROR: incomplete chain of indirects
+   }
+   ```
+4. When the last lookup is a read of a base type one can omit the
+   explicit `read()` indirect, as illustrated by the definitions of
+   `readNestedCounter1` and `readNestedCounter2` above, which have the
+   same behavior.
+5. For convenience, local variables can hold default values of ledger-state types,
+   so the following definition of `initNestedMap` is equivalent to the one
+   above.
+   ```compact
+   export circuit initNestedMap(b: Boolean): [] {
+     const t = default<Map<Field, Counter>>;
+     fld.insert(disclose(b), t);
+   }
+   ```
 
-Note that default value expressions can have ledger state types.
+### Sealed and unsealed ledger fields
 
-#### Circuit and witness calls
+Any ledger field can be marked *sealed* by prefixing the ledger field declaration
+with the optional modifier `sealed`.
+A sealed field cannot be set except during contract initialization.  That is, its
+value can be modified only by the contract constructor (if any),
+either directly within the body of the constructor or via helper
+circuits called by the constructor.
+The `sealed` keyword must come after the `export` keyword (if present) and before
+the `ledger` keyword, as in the following example:
 
-Circuits and witnesses, collectively referred to as functions, are called via an
-expression of the form `f(e, ...)`, where `f` is a function and `e, ...` is a
-sequence of zero or more comma-separated argument expressions.
+```compact
+sealed ledger field1: Uint<32>;
+export sealed ledger field2: Uint<32>;
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>fun</em>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;[<em>expr</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>}]&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td><em>fun</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>id</em>&nbsp;&nbsp;[<em>targs</em>]</td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;[<em>parg</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>parg</em>}]&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;[<em>type</em>]&nbsp;&nbsp;<b><tt>=></tt></b>&nbsp;&nbsp;<em>body</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>fun</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td><em>body</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>block</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr</em></td></tr></tbody></table>
+circuit init(x: Uint<32>): [] {
+  field2 = disclose(x);
+}
 
-The function expression can take several different forms:
+constructor(x: Uint<16>) {
+  field1 = 2 * disclose(x);
+  init(x);
+}
+```
 
-A **function name** is the name of a circuit or witness from a circuit or
-witness declaration in scope.
+It is a static error if a sealed ledger field is updated by any code that is
+reachable from an exported circuit.
 
-An **anonymous circuit** is an inline circuit definition having the form `(P,
-...) => body` or `(P, ...): R => body`, where `P, ...` are zero or more
-comma-separated parameter declarations, `R` is an optional return type
-annotation, and `body` is the circuit's body.  Each parameter consists of either an
-identifier `x` (the parameter's name) or a
-[destructured pattern](#destructuring-tuples-and-structures) `[x, y]` or `{x, y}`
-for parameters that have a tuple or a structure type, respectively,
-and an optional type annotation `: T`
-where `T` is a Compact type.  The optional return type `R` is a Compact type.
-The body is either a block (a sequence of zero or more semicolon-delimited
-statements enclosed in curly braces (`{ }`)), or an expression.
+## Contract constructor
 
-There is no syntax for generic anonymous circuits.  This is because circuits are
-not first-class values: they cannot be passed around or stored in data
-structures, they *must* be called.  And generic circuits must be specialized to
-call them, so anonymous generic circuits would have to be immediately
-specialized.  In that case, the programmer can just write the non-generic
-version themselves.
+A contract can be initialized via a contract constructor defined at the
+program's top level.
 
-A **parenthesized function** has the form `(f)` where `f` is a function
-expression, that is either a function name, an anonymous circuit, or a
-parenthesized function.
+<table className="lang-ref-table"><tbody><tr><td><em>constructor-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>constructor</tt></b>&nbsp;&nbsp;<em>pattern-parameter-list</em>&nbsp;&nbsp;<a href="#statements"><em>block</em></a></td></tr><tr><td><em>pattern-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-pattern</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
+<tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
 
-Because functions are not first class, parameter names and constant names are
-not allowed as the function part of a call.  Nor are arbitrary expressions
-allowed, for the same reason.
+The constructor, if any, is typically used to initialize public state
+and can also be used to initialize private state through witness
+calls.
+At most one contract constructor can be defined for a contract, and it
+must appear only at the program top level, i.e., it cannot be defined in
+a module.
+To initialize ledger fields that are visible only within a module, the
+constructor can call a circuit that is exported from the module.
+For example:
 
-Because circuits and witnesses are not first class, parameter names and constant
-names are not allowed as the circuit or witness part of a call.  Nor are
-arbitrary expressions allowed, for the same reason.
+```compact
+module PublicState {
+  enum STATE { unset, set }
+  ledger state: STATE;
+  ledger value: Field;
+  export circuit init(v: Field): [] {
+    value = disclose(v);
+    state = STATE.set;
+  }
+}
 
-Generic functions cannot be called without explicitly specializing them with
-generic arguments enclosed in angle brackets.  Calls to generic functions must
-be fully specialized: the number of generic arguments must match the number of
-generic parameters.
+import PublicState;
 
-The *underlying function* of a function expression is a non-parenthesized
-function expression.  For a function name it is the function name, for an
-anonymous circuit it is the anonymous circuit, and for a parenthesized function
-it is the underlying function of the parenthesized function expression.
+constructor(v: Field) {
+  init(v);
+}
+```
 
-Type checking a function call depends on the form of the underlying function.
+Each constructor parameter must be explicitly typed.
+The type of each variable binding arising from the binding of identifiers in
+each parameter pattern to the corresponding pieces of the input is the type of
+the corresonding part of the declared type's structure.
 
-* **For a named function:** Function names may be *overloaded*: more than one
-  function of the same name may be present in the scope of a call to that
-  function.  A call whose underlying function is a name can thus have zero or
-  more candidate functions, i.e., all of those that have the given name and are
-  present in the scope of the call.
+The return type of the constructor is always `[]`.
+Any attempt to return another type of value using `return expression;` where the
+type of `expression` is something other than `[]`, is a static error.
 
-  A candidate function is not necessarily compatible with the number and kinds
-  of the generic parameter values, nor with the number and types of the argument
-  expressions provided at the call site.  It is compatible if and only if the
-  number of generic parameters is the same as the number of generic arguments,
-  each generic argument is of the required kind (a size or a type), the number
-  of declared parameters is the same as the number of argument expressions, and
-  if the declared type of each parameter is a supertype of the corresponding
-  argument expression.  If exactly one candidate is compatible, the call is made
-  to that candidate.  It is a static type error otherwise (if there is not
-  exactly one compatible candidate).
+## Circuits
 
-  The static type of a call to a named function is the return type of the called
-  function.
+The basic operational element in Compact is the `circuit`.
+This corresponds closely to a function in most languages but is designed
+to be compilable into a zero-knowledge circuit.
+The key limitation of circuits relative to functions in most languages is
+that circuits cannot be recursive, either directly or indirectly.
+
+Compact supports two kinds of circuits: named circuits and anonymous circuits.
+Named circuits are described here, and anonymous circuits are described
+in [Circuits and witness calls](#circuits-and-witness-calls).
+
+Named circuit definitions have the following syntax:
+
+<table className="lang-ref-table"><tbody><tr><td><em>circuit-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>function-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<em>pattern-parameter-list</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<a href="#statements"><em>block</em></a></td></tr>
+<tr><td><em>pattern-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-pattern</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
+<tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
+
+A circuit definition binds `function-name` to a circuit with the given parameters,
+type, and body.
+The optional `export` modifier indicates that the circuit binding should
+be exported from the enclosing module or the program itself, if the circuit
+is defined outside of any module.
+The optional `pure` modifier indicates that the
+[circuit is pure](#pure-and-impure-circuits).
+
+If any generic parameters are present (`gparams` is present and is nonempty),
+the circuit is [generic][#generic-parameters-and-arguments] and must be specialized
+(provided with generic arguments) at the point of call.
+
+Circuits can take zero or more parameters.
+The parameters are all [patterns](#patterns-and-destructuring) containing identifiers
+to be bound to selected pieces of the argument values.
+In the simplest case, a pattern is just an identifier and is bound to the argument
+value as a whole.
+The bindings established by the parameters are visible within (and only within)
+the `block` that constitutes the body of the circuit.
+Each parameter must be explicitly typed, and at the point of every call to the
+circuit, the type of the corresponding argument expression must be a subtype of
+that type.
+The type of each variable binding arising from the binding of identifiers in
+each parameter pattern to the corresponding pieces of the input is the type of
+the corresonding part of the declared type's structure.
+For example, in the body of `sumStruct` below:
 
-* **For an anonymous circuit:** Parameters that have type annotations will be
-  type checked, and parameters that do not have type annotations will have types
-  inferred.  The argument subexpressions are type checked and then:
+```compact
+struct S { x: Uint<16>, y: Uint<32> }
+circuit sumStruct({x, y}: S): Field {
+  return x + y;
+}
+```
 
-  - If there is a type annotation for a parameter, it is a static type error if
-    the type of the corresponding argument expression is not a subtype of the
-    type annotation.
+The variable binding established for `x` by the pattern `{x, y}` has type
+`Uint<16>`, and the variable binding for `y` has type `Uint<32>`.
 
-  - If there is no type annotation for a parameter, the parameter's type is
-    inferred as the type of the corresponding argument expression.
+Every named circuit's return type must be explicitly declared, and it is a
+static error if the circuit can return a value that is not a subtype of that
+type.
 
-  If there is a return type annotation, then the circuit's body is type checked
-  under the assumption that the parameters have their declared or inferred
-  types.  It is a static type error if there is a returned subexpression whose
-  static type is not a subtype of the return type annotation.  A return
-  statement of the form `return;` is type checked as if it returned a value of
-  type `[]`.  Every control flow path through a body that does not explicitly
-  end with a return statement implicitly ends with one of the form `return;`.
+The body is evaluated each time the circuit it is called.
 
-  If there is no return type annotation, then a return type is inferred from the
-  body.  The body is type checked under the assumption that the parameters have
-  their declared or inferred types.  The inferred return type is the least upper
-  bound of the types of all the returned subexpressions, with the same treatment
-  of `return;` and control-flow paths that do not end in an explicit return as
-  described above.
+### Pure and impure circuits
 
-  The static type of a call to an anonymous circuit is the declared or inferred
-  return type.
+A Compact circuit is considered *pure* if it computes its outputs from its
+inputs without reference to or modification of public state (via the ledger) or
+private state (via witnesses). In practice, the compiler considers a circuit to
+be impure if the body of the circuit contains a ledger operation, a call to any
+impure circuit, or a call to a witness.
 
-Calls are evaluated by evaluating the argument expressions in order from left to
-right.  Then, if a circuit is being called, the statements in the body of the
-circuit are executed with the parameter names bound to the corresponding
-argument values.  The value of a circuit call is the value returned from the
-execution of the body.  If a witness is being called, the contract will invoke
-the TypeScript or JavaScript witness function with the argument values.  The
-value of a witness call is the value returned by the witness function.
+Some external circuits defined in `CompactStandardLibrary` are witnesses; calls
+to these make the caller impure. The remainder are considered pure, so calls to
+those do not make the caller impure.
 
-#### Structure creation
+A Compact program can declare a circuit to be pure by prefixing the circuit
+definition with the `pure` modifier, which must follow the `export` modifier,
+if present, e.g.:
 
-Structure values are created with structure creation expressions.  The
-expression `S {f, ...}` is a structure creation expression, where `S` is a
-structure type and `f, ...` is a sequence of zero or more comma-separated field
-value specifiers.
+```compact
+pure circuit c(a: Field): Field {
+  ...
+}
 
-A field value specifier can be one of three things:
+export pure circuit c(a: Field): Field {
+  ...
+}
+```
 
-* A **positional** field value is an expression.  Evaluating the expression
-  gives the value for the field.  Positional field values must be given in the
-  order that fields are declared in the corresponding structure declaration.
-* A **named** field value is of the form `id: e` where `id` is a field name and
-  `e` is an expression.  Evaluating the expression gives the value for the
-  corresponding named field.  Named fields can appear in any order.  If named
-  and positional fields are mixed, all the named fields must appear after all
-  the positional fields.
-* A **spread** expression is of the form `...e` where `...` is the literal three
-  dots (ellipsis) token and `e` is an expression.  Evaluating the expression
-  must give a value of the same structure type as the one being created.  The
-  fields of the created structure are given values from the spread structure as
-  described below.  If there is a spread expression, it must occur as the first
-  field value specifier and all other specifiers must be named field values.
+The only effect of the `pure` modifier is that the compiler flags the
+declaration as an error if its own analysis determines that the circuit is
+actually impure. The pure modifier allows an application to ensure that the
+circuit is present in the `PureCircuits` type declaration and via the
+`pureCircuits` constant in the TypeScript module produced for a (correct)
+Compact program by the Compact compiler.
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>tref</em>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;[<em>new-field</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>new-field</em>}]&nbsp;&nbsp;<b><tt>}</tt></b></td></tr><tr><td><em>new-field</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>id</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td><em>tref</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>id</em>&nbsp;&nbsp;[<em>targs</em>]</td></tr></tbody></table>
+## Blocks
 
-The examples below demonstrate the use of positional and spread field values:
+A `block` is a group of statements enclosed in braces:
+
+<table className="lang-ref-table"><tbody><tr><td><em>block</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>stmt</em> &mldr; <em>stmt</em>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></tbody></table>
+
+A block can be used in place of a single statement anywhere a single statement
+is allowed, which is useful for allowing multiple statements to be evaluated by the
+`then` and `else` parts of an `if` statement or the body of a `for`.
+
+The body of every circuit definition and the body of the constructor, if any,
+is always a block.
+The right-hand side of the arrow in an anonymous circuit can be either a block
+or an expression.
+
+The statements within a block occupy a nested scope: `const` bindings created by
+`const` statements within the block are not visible outside the block, and they can
+shadow identifier bindings with the same names that exist outside the block.
+
+A block is well-typed if the statements within it are well-typed.
+
+A block is evaluated by evaluating the statements in sequence.
+
+## Statements
+
+The syntax of Compact statements is summarized by the following grammar snippet:
+
+<table className="lang-ref-table"><tbody><tr><td><em>stmt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>stmt<sub>0</sub></em></td></tr>
+<tr><td><em>stmt<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#const-binding-statement"><em>cbinding</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#const-binding-statement"><em>cbinding</em></a> &nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt<sub>0</sub></em>&nbsp;&nbsp;<b><tt>else</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>block</em></td></tr></tbody></table>
+
+The snippet shows that a statement (`stmt`) is either a one-armed `if` expression
+or some other kinf of statement (`stmt0`).
+This structure is used to enforce the restriction that the *then* part of a
+two-armed cannot be a one-armed `if` expression.
+This is often left ambiguous in the grammar, with a separate note to say
+that the ambiguity is resolved by assocating an *else* part with the closest
+enclosing `if` expression, but we prefer to make the constraint explicit in
+the grammar and avoid any ambiguity.
+
+The first kind of `stmt0` is `expr-seq`.
+An `expr-seq`, or *expression sequence*, is a comma separated sequence of one
+or more expressions to be evaluated in sequence.
+This simply means that any expression or comma-separated sequence also qualifies
+as a statement.
+Expression sequences are described more fully in
+(their own section)[expression-sequences].
+
+The remaining subsections of this section describe each of the other kinds of
+statement.
+
+Statements either do not have a value or (in the case of expression sequences
+serving as statements) their value is ignored.
+Thus it is not necessary to talk about the type of a statement.
+Nevertheless, each statement has typing rules that must be followed, such as that
+the type of the test expression of an `if` expression must be `Boolean`.
+
+### `const` statements
+
+`const` statements create local variable bindings.
+Every `const` statement takes the following form:
 
 ```compact
-struct S { a: Uint<32>, b: Boolean, c: Bytes<8> }
-circuit f(x: Uint<32>, y: Boolean, z: Bytes<8>): S {
-  const s1 = S { c: z, a: x, b: y };
-  // Alternatively, s1 can be created with the positional syntax S { x, y, z }
-  // or a mix of positional and named field values S { x, c: z, b: y }.
+const cbindings
+```
 
-  const s2 = S { ...s1, b: true };
-  // s2 is created using the spread syntax.  So, s2 has the same field values
-  // as s1 except that b is true.
+where `cbindings` is a comma-separated sequence of one or more `cbinding` subforms
+in the syntax specified by the following grammar snippet:
+
+<table className="lang-ref-table"><tbody>
+<tr><td><em>cbinding</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>optionally-typed-pattern</em>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<a href="#expressions"><em>expr</em></a></td></tr>
+<tr><td><em>optionally-typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>typed-pattern</em></td></tr>
+<tr><td><a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
+<tr><td><a href="#patterns-and-destructuring"><em>pattern-struct-elt</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>pattern</em></td></tr>
+<tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr>
+</tbody></table>
+
+A `const` statement is typed by typing each of its `cbinding` subforms.
+A `cbinding` subform is typed by typing the expression on the right-hand side
+of the `=`.
+If a type `T` is included on the left-hand side, the type of the expression
+must be a subtype of `T`, otherwise it is a static error.
+It is also a static error if the pattern implies a different structure from
+the type of the expression.
+For example, it is a static error if the pattern implies that the expression's
+value is a tuple when the type is actually, say, `Field`.
+
+The type of each variable binding arising from the binding of identifiers in each
+pattern to the corresponding pieces of the input is the type of the corresonding
+part of the structure of the declared type, if present, otherwise of the inferred
+type.
+For example, in the following code, the binding for `x` has type `Boolean`, and
+the binding for `y` has type `[Uint<64>, Uint<64>]`:
+
+!!!!!!!! TBD test this
 
-  const s3 = S { ...s2, c: 'abcdefgh' };
-  // s3 is also created using the spread syntax.  s3 has the same field values
-  // as s2 except that c is 'abcdefgh'.
+```compact
+witness w(): [Boolean, [Uint<16>, Uint<32>]];
+circuit foo(): [Uint<64>, Uint<64>] {
+  const [x, y]: [Boolean, [Uint<64>, Uint<64>]] = w();
+  return x ? y : [0, 0];
+}
+```
 
-  return s3;
+while in the following, `x` still has type `Boolean` but `y` has (the inferred)
+type `[Uint<16>, Uint<64>]`.
+
+!!!!!!!! TBD test this
+
+```compact
+witness w(): [Boolean, [Uint<16>, Uint<32>]];
+circuit foo(): [Uint<64>, Uint<64>] {
+  const [x, y] = w();
+  return x ? y : [0, 0];
 }
 ```
 
-The structure type must come from a structure declaration in scope.  If the
-structure is generic, then it must be explicitly specialized with generic
-arguments enclosed in angle brackets.  Generic structures must be fully
-specialized: the number of generic arguments must match the number of generic
-parameters.
+Except where shadowed, the scope of each variable bound by a `const` statement
+is the entirety of the innermost block containing the `const` statement.
+It must not be referenced, however, before it is given a binding.
+Any attempt to do so is a static error.
+For example, the reference to `x` on the first line of the body in the
+definition of `foo` below is a static error:
 
-The static type of a non-generic structure creation expression is the named
-structure type.
+```compact
+circuit foo(x: Uint<16>): Field {
+  return x;
+  const x = 7;
+}
+```
 
-The generic arguments to a generic structure can be types, natural number
-literals, or the names of generic parameters in scope.  A generic structure
-creation expression is type checked by substituting the generic arguments for
-the generic parameters in the structure's definition.  The static type of a
-generic structure creation expression is a structure with the same name as the
-generic type and field types obtained by substituting the generic arguments for
-the generic parameters in the structure's declaration.
-
-**If there is no spread field specifier:** It is a static error if the number of
-field specifiers does not match the number of fields in the corresponding
-structure declaration (a value must be given for every field).  It is a static
-error if a named field specifier occurs before a positional field specifier.  It
-is a static error if a field name occurs more than once, and it is a static
-error if a field name occurs that is not the name of a field in the
-corresponding structure declaration.  It is a static type error if the type of a
-positional field subexpression is not a subtype of the declared type of the
-(positionally) corresponding field in the structure declaration.  It is a static
-type error if the type of a named field subexpression is not a subtype of the
-declared type of the corresponding (named) field in the structure declaration.
+Similarly, the reference to `x` in the first `cbinding` of the `const`
+statement below is also a static error.
 
-**If there is a spread field specifier:** It is a static error if the spread
-field specifier does not come first in the sequence.  It is a static type error
-if the type of the spread subexpression is not the same type as structure to be
-created.  It is a static error if there are any positional field specifiers.  It
-is a static error if a field name occurs that is not the name of a field in the
-corresponding structure declaration.  It is a static type error if the type of a
-named field subexpression is not a subtype of the declared type of the
-corresponding (named) field in the structure declaration.
+```compact
+const y = x, x = 7;
+}
+```
 
-A structure creation expression is evaluated by evaluating the field specifier
-subexpressions in order from left to right.  The result is a structure value
-whose fields have values based on the corresponding field specifier: if there is
-a positional or named field specifier for the field, the field value is the
-value of the subexpression, otherwise there must be a spread expression and the
-field value is the value of the corresponding field in the (structure) value of
-the spread subexpression.
+A `const` statement is evaluated by evaluating the `cbinding` subforms in order
+so that the variables given values by each `cbinding` is available to the
+cbindings that follow.
+
+The evaluation of each `cbinding` involves evaluating the expression
+on the right-hand side of the `=` and then giving values to identifiers
+in the pattern `p` on the left-hand side to the value `v` of the
+expression as described earlier in
+(Patterns and destructuring)[patterns-and-destructuring].
 
-#### Tuple creation
+Any variable bound by `const` may not be reused within a block, although a
+`const` binding in a nested block might [shadow it](#scope-and-binding).
+Variables are immutable, although the same variable might take on different values
+at different times if is contined within a block of code that is evaluated more
+than once, such as would be the case for the body of a `circuit` that is called
+more than once.
 
-Tuple values are created with expressions of the form `[e, ...]` where `e, ...`
-is a sequence of zero or more comma-separated argument expressions.  A non-empty
-sequence can have an optional trailing comma.  The *length* of a tuple is the
-number of subexpressions in the tuple creation expression.
+### `if` statements
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;[<em>expr</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>}]&nbsp;&nbsp;[<b><tt>,</tt></b>]&nbsp;&nbsp;<b><tt>]</tt></b></td></tr></tbody></table>
+An `if` statement is used to determine the flow of control through the
+statements of a circuit or constructor body.
+A *one-armed* `if` expression has a *test part* (an `expr-seq` enclosed
+in parentheses) and a *then part* (`then-statement`):
 
-The static type of a tuple creation expression is `[T, ...]` with the number of
-types matches length of the tuple and each type `T` is the type of the
-corresponding expression.
+```compact
+if (expr-seq) then-statement
+```
 
-It is evaluated by evaluating the subexpressions from left to right.  Its value
-is a tuple whose length is the number of subexpressions and whose elements are
-the subexpression values.
+A *two-armed* `if` expression has a *test part* (an `expr-seq` enclosed
+in parentheses), a *then part* (`then-statement`), and an *else part*
+(`else-statement`):
 
-#### Parenthesized expressions
+```compact
+if (expr-seq)
+  then-statement
+else
+  else-statement
+```
+
+The typing of an `if` expression requires only that the type of `expr-seq` must be
+`Boolean`.
+
+Evaluating an `if` expression involves first evaluating the `expr-seq`.
+If it evaluates to `true`, `then-statement` is evaluated.
+Otherwise, it must evaluate to `false`, in which case `else-statement`
+(if present), is evaluated.
+
+### `for` statements
+
+`for` statements are used to iterate over a sequence of values.
+In Compact, in constrast to most languages, the number of iterations can
+always be determined at compile time.
+That is, the number of iterations is bounded either by constant numeric
+bounds or by size of an object of constant size.
+This restriction is motivated by the need for the compiler to generate
+finite proving circuits.
+
+Compact supports two kinds of `for` statements.
+The first iterates over vectors, tuples, and byte-vectors and takes the
+following form:
+
+```compact
+for (const x of expression) statement
+```
+
+This kind of `for` statement is typed by typing `expression` and verifying that
+it is a `Vector` type, a tuple type that (has a vector type)[Subtyping and least
+upper bounds], or a `Bytes` type.
+
+Evaluating this kind of `for` requires evaluating `expression` then evaluating
+`statement` once for each element with `x` bound to the value of each element
+in turn.
+
+The second form iterates over a range of unsigned integer values and takes the
+following form:
+
+```compact
+for (const i of start..end) statement
+```
+
+In this form, each of `start` and `end` must be a literal unsigned integer
+or a generic natural-number parameter, and `end` must be greater than or
+equal to `start`.
+Otherwise, it is a static error.
+
+This form is always well-typed.
+
+Evaluating this kind of `for` requires evaluating statement with `i` bound
+to *k* for each *k* in the range `start` (inclusive) to `end` (exclusive).
+
+`return` statements cannot be used to return from within `for` statements.
+It is therefore a static error for `statement` to be a `return` statement
+or for a `return` statement to appear within `statement` (except where it
+appears nested within an anoymous circuit).
+
+Iteration can also be accomplished via
+(`map` and `fold` expressions)[map-and-fold-expressions].
+
+### `return` statements
+
+A `return` statement can be used to exit from the closest enclosing
+[anonymous circuit](#circuit-and-witness-calls) circuit, if any, or otherwise from
+the enclosing constructor or named circuit, and to return to the caller either
+an explicit return value, i.e., the value of (`expr-seq`)[expression-sequences]
+in this form of `return`:
+
+```compact
+return expr-seq;
+```
+
+or the default value `[]` in this form of `return`:
+
+```compact
+return;
+```
+
+A circuit or constructor body can also exit without an explicit `return` statement:
+any path through the body that does not end in an explicit `return` statement is
+treated as if ended with `return;`.
+
+A `return` statement is always well-typed if it exits from an anonymous circuit
+without a declared return type.
+Otherwise, a `return` statement is well-typed if the type of `expr-seq`, or
+`[]` if no `expr-seq` is present, is a subtype the expected return type.
+If the `return` form exits from a named circuit or an anonymous circuit
+with a declared return type, the expected type is the declared return type,
+while if it exits from the constructor, the expected return type is `[]`.
+
+An implication of these rules is that it is a static error to exit without an
+explicit return value from a circuit with a declared return type other than `[]`.
+
+When a `return` statement is evaluated, the `expr-seq`, if present, is evaluated,
+the circuit or constructor exits immediately without evaluating any
+subsequent statements, and it returns to the caller the value of `expr-seq` or
+`[]` if no `expr-seq` is present.
+
+## Expressions
+
+The syntax of Compact expressions is summarized by the following grammar snippet:
+
+<table className="lang-ref-table"><tbody><tr><td><em>expr-seq</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> &nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr>
+<tr><td><em>expr</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>?</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>+=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>-=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em></td></tr>
+<tr><td><em>expr<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>||</tt></b>&nbsp;&nbsp;<em>expr<sub>1</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>1</sub></em></td></tr>
+<tr><td><em>expr<sub>1</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>1</sub></em>&nbsp;&nbsp;<b><tt>&&</tt></b>&nbsp;&nbsp;<em>expr<sub>2</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>2</sub></em></td></tr>
+<tr><td><em>expr<sub>2</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>2</sub></em>&nbsp;&nbsp;<b><tt>==</tt></b>&nbsp;&nbsp;<em>expr<sub>3</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>2</sub></em>&nbsp;&nbsp;<b><tt>!=</tt></b>&nbsp;&nbsp;<em>expr<sub>3</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>3</sub></em></td></tr>
+<tr><td><em>expr<sub>3</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>expr<sub>4</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em>&nbsp;&nbsp;<b><tt>\<=</tt></b>&nbsp;&nbsp;<em>expr<sub>4</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em>&nbsp;&nbsp;<b><tt>>=</tt></b>&nbsp;&nbsp;<em>expr<sub>4</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<em>expr<sub>4</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em></td></tr>
+<tr><td><em>expr<sub>4</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em>&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>5</sub></em></td></tr>
+<tr><td><em>expr<sub>5</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>5</sub></em>&nbsp;&nbsp;<b><tt>+</tt></b>&nbsp;&nbsp;<em>expr<sub>6</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>5</sub></em>&nbsp;&nbsp;<b><tt>-</tt></b>&nbsp;&nbsp;<em>expr<sub>6</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>6</sub></em></td></tr>
+<tr><td><em>expr<sub>6</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>6</sub></em>&nbsp;&nbsp;<b><tt>*</tt></b>&nbsp;&nbsp;<em>expr<sub>7</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>7</sub></em></td></tr>
+<tr><td><em>expr<sub>7</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<em>expr<sub>7</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em></td></tr>
+<tr><td><em>expr<sub>8</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>9</sub></em></td></tr>
+<tr><td><em>expr<sub>9</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>map</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>fold</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>slice</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>tuple-arg</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>tuple-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>bytes-arg</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>bytes-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#primitive-types"><em>tref</em></a>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>struct-arg</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>struct-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>assert</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>disclose</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>term</em></td></tr>
+<tr><td><em>tuple-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td><em>bytes-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>tuple-arg</em></td></tr>
+<tr><td><em>struct-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr>
+<tr><td><em>term</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>true</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>false</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>pad</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>default</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr-seq</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></tbody></table>
+
+Every Compact expression must be well-typed (free from static type errors).
+If any expression within a program contains a static type error, it is a static
+error: the Compact compiler reports the error and does not produce any target code
+(TypeScript or Zkir) for the program.
+The static type of a well-typed expression is either a Compact type or a
+ledger-state type.
+
+Every Compact expression either evaluates to a value or raises an exception,
+and it might have have an effect.
+The evaluation of an expression is defined in terms of the evaluation of its
+subexpressions.
+If the evaluation of a subexpression raises an exception, then the evaluation of
+the containing expression halts and raises the same exception.
+
+The first section below discusses how the grammar reflects the rules
+for precedence and associativity of operators, and the remaining sections
+describe the typing and evaluation rules for each kind of expression.
+
+
+### Precedence and associativity
+
+The structure of the expression grammar unambiguously reflects the precedence
+and associativity of operators.
+
+Each subscripted nonterminal `expr_n` represents a precedence level, with higher
+subscripts representing higher levels of precedence.
+For example, `expr_6` (multiplication) binds more tightly than `expr_5` (addition)
+because the grammar permits the operands of an addition expression to be
+multiplication expressions, but not vice versa.
+For example, `x * y + z` is parsed as the addition of `x * y` and `z`
+rather than the multiplication of `x` and `y + z`, because the `expr_5` production
+for addition is not reachable from the `expr_6` production for multiplication.
+One can still write `x * (y + z)` because an `expr_6` can be a `term` (via the
+"fall through" productions `expr_6 → expr_7`, `expr_7 → expr_8`, and so on),
+and a term can be a parenthesized `expr-seq`.
+
+The grammar enforces associativity by allowing either the left or right
+operand of an operator to be at the same precedence level while requiring
+the other to be at a higher level.
+Specifically, left-associativity is expressed by allowing the left operand to be
+at the same level while requring the right operand to be at a higher level.
+For instance, `expr_5 → expr_5 + expr_6` enforces the left-associativity of
+addition, since the left operand can be at the same level while the right
+operand is at a higher level.
+This means that `x + y - z` can be treated only as the subtraction of `z`
+from `x + y` rather than as the addition of `x` and `y - z`.
+Right-associativity is expressed in the opposite manner, e.g., 
+`expr_0 ? expr : expr` enforces the right-associativity of the
+ternary `?:` operator.
+Non-associative operators such as the relational operators `<`, `<=`, `>=`, `>` have
+both operands at a strictly higher level (`expr_4` on both sides of `expr_3`),
+preventing chaining like `a < b < c`.
+
+The middle operand of the ternary `?:` operator plays no roll in determining
+precedence and associativity and can be any kind of expression.
+(The grammar could even have allowed it to be an expression sequence, but Compact
+follows TypeScript and JavaScript in restricting it to be a single expression.)
+In fact, the grammar has many examples where a lower precedence expression is
+embedded in a higher-precedence expression; this does not result in any
+ambiguity because the operand is not exposed on the left or right side of the
+expression where it can be confused as an operand of some other operator.
+
+### Parenthesized expressions
 
 Compact allows parenthesized expressions of the form `(e)`, where `e` is an
-expression.  They can be used to control the order of evaluation.
+expression.
+They can be used to control the order of operations or simply to make the default
+order of operations to be explicit.
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></tbody></table>
+For example, `x + y * z` computes the product of `y` and `z` and adds `x` to the
+result, because `*` has higher precedence than `+`.
+`x + (y * z)` computes the same thing but more makes the order of operations more
+clear, while `(x + y) * z` computes the sum of `x` and `y` and multiplies it by `z`.
 
-The type of the parenthesized expression is the type of the subexpression.
+The type of a parenthesized expression is the type of the embedded expression,
+and its value is the value of the subexpression.
 
-Its value is the value of the subexpression.
+### Expression sequences
 
-#### Sequence expressions
+An expression sequence (`expr-seq` in the grammar above) is a comma-separated
+sequence of one or more expressions.
 
-Expressions can be sequenced for their side effects.  An expression of the form
-`(e0, e1, e2, ...)` or `e0, e1, e2, ...` where `e0, e1, e2, ...` is a sequence of two or more
-comma-separated expressions is a sequence expression. The latter form where parentheses can
-be omitted is only allowed in some context which can be viewed in
-[the formal grammar of Compact](./compact-grammar).
+```compact
+expression, ..., expression
+```
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>}&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>}&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;</td></tr></tbody></table>
+Expression sequences can appear only in a few contexts.
+When an expression sequence is required in a context where only a single expression
+is permitted, the expression sequence can be wrapped in parentheses:
 
-The static type of a sequence expression is the static type of the last
-subexpression.
+```compact
+(expression, ..., expression)
+```
 
-It is evaluated by evaluating the subexpressions from left to right.  Its value
-is the value of the last subexpression.
+The type of an expression sequence is the type of its last subexpression.
 
-#### Asserts
+An expression sequence is evaluated by evaluating the subexpressions from
+left to right, and its value is the value of the last subexpression.
+The values of the other subexpressions are ignored; these other subexpressions
+are evaluated solely for their effects.
 
-An assertion has the form `assert(e, "msg")` where `e` is an expression and `msg` is a string message.
-`e` must have a Boolean type, otherwise it is a static type error.  If `e` evaluates to `true`, the assertion
-succeeds. If `e` evaluates to `false`, the assertion fails with the message `msg`.
+### Literals
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>assert</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em></td><td><b><tt>,</tt></b>&nbsp;&nbsp;<b><tt>"</tt></b><em>msg</em>&nbsp;<b><tt>"</tt></b>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></tbody></table>
+Compact has syntax for Boolean, numeric, and string literal expressions.
 
-Each assertion is checked at runtime and constrained in-circuit.
+A __Boolean literal__ is one of the reserved words `true` or `false`.
+The static type of a boolean literal is `Boolean` and its value is the
+corresponding boolean value.
 
-#### Ledger expressions
+A __numeric literal__ is a non-negative integer written in decimal, binary,
+octal, or hexadecimal notation as follows:
 
-A Compact program interacts with its public state by invoking operations upon
-the ledger or ledger state types.  There are two different forms of ledger
-calls.
+- decimal: either the single digit `0` or a sequence of one or more decimal
+  digits (`0-9`) starting with a non-zero digit, e.g., `0` or `7091`;
+- binary: the prefix `0b` or `0B` followed by one or more binary digits
+  (`0` or `1`), e.g., `0b1101001`;
+- octal: the prefix `0o` or `0O` followed by one or more octal digits (`0-7`),
+  e.g., `0o5073`;
+  or
+- hexadecimal: the prefix `0x` or `0X` followed by one or more hexadecimal
+  digits (`0-9`, `a-f`, `A-F`), e.g., `0x8f0a`.
 
-__Kernel operations__ are operations that do not depend on specific ledger
-state.  They can be invoked by expressions of the form `k.op(e, ...)`, where
-`k` is the name of a ledger field declared to have the special ADT type `Kernel`,
-`op` is the name of a builtin kernel operation and
-`e, ...` is a comma separated sequence of zero or more argument expressions.
-The `CompactStandardLibrary` predefines the ledger field name `kernel` to have
-ledger type `Kernel`, so for example, the built-in `self` operation can be called
-from a circuit as follows:
+An occurrence of a numeric literal can arise via specialization of a
+generic module or circuit in which a reference to a generic natural-number parameter
+occurs in an expression context.
+For example, if `foo` is defined as follows:
+
+!!!!!!!! TBD test this
 
 ```compact
-import CompactStandardLibrary;
-circuit f(): ContractAddress {
-  return kernel.self();
+circuit foo<#N>(): Unsigned<16> {
+  return N;
 }
 ```
 
-__Ledger ADT operations__ are operations on the program's public ledger state.
-They are invoked by expressions of the form `member.op(e, ...)....`,
-where `member` is a ledger field name ([declared via a `ledger` field declaration](#declaring-and-maintaining-public-state))
-and `.op(e, ...)....` are a sequence of zero or more ledger
-ADT operation invocations, where each `op` is the name of a ledger ADT
-operation and each `e, ...` is a sequence of zero or more comma-separated
-argument expressions.
+the call `foo<17>()`, at least in effect, gives rise to a copy of `foo` in
+which `N` has been replaced by `17`.
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;<em>ledger-accessor</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<em>id</em>&nbsp;&nbsp;\{<em>ledger-accessor</em>}</td></tr><tr><td><em>ledger-accessor</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<em>id</em>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;[<em>expr</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>}]&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></tbody></table>
+!!!!!!!! TBD test this
 
-Note that ledger ADT operations can be chained, because the result of a ledger
-ADT operation might itself have a ledger state type.  Kernel operations cannot
-be chained, because the kernel is not a ledger state type and is not returned
-by any operation.
+```compact
+circuit foo(): Unsigned<16> {
+  return 17;
+}
+```
 
-The static type of a kernel operation expression is the return type of the
-corresponding kernel operation according to the ledger data types reference.
+This is treated exactly as if the numeric literal appeared in place of the
+reference to `N` in the source code of the program.
 
-The static type of a ledger ADT operation expression is the return type of the
-corresponding ADT operation according to the ledger data types reference.  Note
-that this might be a Compact type or it might be a ledger ADT type.  Values of
-ledger ADT types can have ADT operations invoked (immediately) on them, but
-any other use would be a static type error.
+It is a static error if the number `n` denoted by a numeric literal exceeds the
+maximum unsigned value and the maximum field value.
 
-Kernel operations are evaluated by evaluating the argument subexpressions in
-order from left to right and then invoking the corresponding kernel operation
-with the argument values.
+If `n` does not exceed the maximum representable unsigned value, the literal's
+type is `Uint<0..k>`, `k = n + 1`, and its value is the unsigned integer `n`.
 
-A ledger ADT operation `member` (that is not followed by a ledger
-accessor) is implicitly an invocation of the `read` operation.  It is evaluated
-as if it were `member.read()`.
+If `n` exceeds the maximum representable unsigned value but not the
+maximum representable field value, the literal must be directly cast to
+`Field`, i.e., `<numeric literal> as Field`.
+Otherwise it is a static error.
+The type of `<numeric literal> as Field` is `Field`, and its value is the
+field value `n`.
 
-A ledger ADT operation `member.op(e, ...)` is evaluated by evaluating the
-argument subexpressions from left to right, and then invoking the operation
-`op` on the public ledger member `member` with the argument values.
+__String literals__ can be either simple string literals or `pad` expressions.
+String literals produce byte vectors; Compact has no dedicated String type.
 
-A ledger ADT operation `adt.op(e, ...)` where `adt` is itself a ledger ADT
-operation is evaluated by first evaluating `adt`, then evaluating the argument
-subexpressions from left to right, and then invoking the operation `op` on the
-ledger ADT value of `adt` with the argument values.
+Simple string literals use TypeScript string literal syntax.
+They can be enclosed in either single (`'`) or double (`"`) quotes, and they can
+contain escaped characters.
+The length `n` of a simple string literal is the length of its UTF-8 encoding.
+The static type of a string literal is `Bytes<n>`, and its value is a
+byte vector containing its UTF-8 encoding.
 
-#### Element and member access expressions
+A `pad` expression `pad(n, s)` is also a string literal, where `pad` is a reserved
+word, `n` is a natural number literal, and `s` is a simple string literal whose
+length must be less than or equal to `n`.
+The static type of a padded string literal `pad(n, s)` is `Bytes<n>`, and its
+value is a byte vector containing the UTF-8 encoding of `s` followed by `0`
+bytes up to the padded length `n`.
 
-Compact has expressions for accessing the elements of tuple values and the
-members of structure values.  An expression of the form `e[n]` where `e` is an
-expression and `n` is a numeric literal is a tuple element access.  An
-expression of the form `e.id` where `e` is an expression and `id` is the name of
-a structure member is a structure member access.
+### Default values of a type
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>nat</em>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<em>id</em></td></tr></tbody></table>
+Every Compact type and ledger-state type has a default value.
 
-Tuple element accesses are type checked by checking the type of the
-subexpression.  It is a type error if this type is not a tuple type `[T, ...]`.
-It is a type error if the length of the tuple is less than or equal to the
-numeric literal in the expression.  The type of the expression is the
-corresponding element type `T` at position `n` in the tuple type.
+The expression `default<T>`, where `T` is a Compact type or a ledger-state type,
+has static type `T`. It evaluates to the default value of that type.
 
-Tuple element accesses are evaluated by evaluating the subexpression.  The
-value of the expression will be the element value at the given zero-based
-index.  The subexpression will have a tuple value and the element access will
-not be out of bounds, because the expression is well-typed.
+Note that default value expressions can have ledger-state types.
 
-Member access expressions are type checked by checking the type of the
-subexpression.  It is a type error if this type is not a structure type.  It is
-a type error if the structure type does not contain a member with the same name
-as the name in the expression.  The type of the expression is the type of the
-corresponding named member of the subexpression's structure type.
+Every type in Compact has a *default value* of that type.  The default values
+are as follows:
 
-Member access expressions are evaluated by evaluating the subexpression.  The
-value of the expression will be the member value with the given name.  The
-subexpression will have a structure value and the name will exist, because the
-expression is well-typed.
+- `Boolean`: the value of the literal `false`
+- `Uint<0..n>` and `Uint<n>`: `0`
+- `Field`: `0`
+- `[T, ...]` where `T, ...` is a sequence of zero or more types: the tuple with
+  the corresponding length, each of the default value of the corresponding type
+- `Bytes<n>`: the byte vector of length `n` with all zero bytes
+- `Opaque<"string">`: an empty string, i.e., `""`
+- `Opaque<"Uint8Array">`: a zero-length `Uint8Array`, i.e., `new Uint8Array(0)`
+- structure types: the struct with all fields set to the default value of their
+  type
+- enumeration types: the first value listed in the declaration
+- alias types: the default value of the underlying type
+- `Counter`: `0`
+- `Set<T>`, for any Compact type `T`: an empty set
+- `Map<K, T>`, for any Compact types `K` and `T`: an empty map
+- `Map<K, V>`, for any Compact type `K` and ledger-state type `V`: an empty map
+- `List<T>`, for any Compact type `T`: an empty list
+- `MerkleTree<n, T>`, for a compile time integer `1 < n <= 32`, and any Compact
+  type `T`: an empty Merkle tree
+- `HistoricMerkleTree<n, T>`, for a compile time integer `1 < n <= 32`, and any
+  Compact type `T`: an empty Merkle tree
 
-#### Boolean negation expressions
+Default is not ddefined for contract types and `Kernel` type (which is defined
+in `CompactStandardLibrary`).
 
-Compact has unary boolean negation expressions of the form `!e` where `e` is an
-expression.
+### Variable references
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr></tbody></table>
+A variable reference is an identifier reference to a variable binding in scope.
 
-A boolean negation expression is type checked by checking the type of the
-subexpression.  It is a type error if this type is not `Boolean`.  The type of
-the expression will be `Boolean`.
+The type of a variable reference is the type of the binding to which it refers.
 
-Negation expressions are evaluated by evaluating the subexpression.  The value
-of the expression will be `true` if the value of the subexpression is `false`
-and vice versa.  The subexpression will have a boolean value because the
-expression is well-typed.
+Each call to a circuit (or constructor) associates a new set of values with each
+variable bound by the circuit's (or constructor's) parameters, and each block
+in the circuit (or constructor) associates a new set of values with each of the
+`const` bindings created within the block.
+The value of each variable reference is the value associated with the variable
+by the current activation.
 
-#### Binary arithmetic expressions
+### Conditional expressions
 
-Binary arithmetic expressions are of the form `e0 op e1` where `e0` and `e1`
-are expressions and `op` is one of Compact's binary arithmetic operators.  The
-binary arithmetic operators are **add** (`+`), **subtract** (`-`) and
-**multiply** (`*`).
+Compact supports conditional expressions of the form `e0 ? e1 : e2` where `e0`,
+`e1`, and `e2` are expressions.
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>+</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>-</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>*</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr></tbody></table>
+Conditional expressions require the type of `e0` to be `Boolean`.  The types of
+`e1` and `e2` must be in the subtype relation.  That is, the type of
+`e1` is a subtype of the type of `e2` or the type of `e2` is a subtype of
+the type of `e1`.
 
-Arithmetic expressions require the type of both subexpressions to be numeric
-types, that is, either a `Field` or a `Uint`.  The type of the result will
-depend on the types of the subexpressions as follows:
-
-- If either subexpression has type `Field`, the result will have type `Field`
-- Otherwise the left subexpression will have type `Uint<0..m>` and the right
-  subexpression will have type `Uint<0..n>` for some bounds `m` and `n`. The
-  type of the result depends on the operation as follows:
-  - For add, the result will have type `Uint<0..m+n>`
-  - For subtract, the result will have type `Uint<0..m>`
-  - For multiply, the result will have type `Uint<0..m*n>`
-
-For arithmetic operations with `Uint` result types, it is a static type error if
-the result's bound would be greater than the maximum unsigned integer.
+The type of the entire expression is the type of `e2` if `e1` is a subtype of
+`e2` and the type of `e1` if `e2` is a subtype of `e1`.
 
-Arithmetic expressions are evaluated by first evaluating the subexpressions in
-order from left to right.  Integer addition, subtraction, or multiplication is
-then used on the subexpression values.  The overflow and underflow behavior
-differs for `Field` and `Uint` operations:
+Conditional expressions are evaluated by first evaluating `e0`.  Then, the
+value of that expression determines which of the other subexpressions is
+evaluated:
 
-- `Field` arithmetic overflow and underflow wraps around 0; that is, the result
-  of an arithmetic operation whose result is a `Field` is the actual arithmetic
-  value modulo `k`, where `k` is one more than the maximum field value.
-- `Uint` addition and multiplication cannot overflow: the static type of the
-  result will always be large enough to hold the result value
-- `Uint` subtraction checks if the value of the right subexpression is greater
-  than the value of the left subexpression.  If so, it is a runtime error (the
-  result would be negative).  Otherwise the unsigned subtraction is performed.
+- if the value of `e0` is `true`, then `e1` is evaluated and its value is the
+  value of the entire expression
+- if the value of `e0` is `false`, then `e2` is evaluated and its value is the
+  value of the entire expression
 
-The static typing rules imply that if `Field` arithmetic semantics is desired,
-then at least one of the operands must have static type `Field`.
+The evaluation rules ensure that only one of `e1` and `e2` is evaluated.
 
-#### Type cast expressions
-
-Type cast expressions in Compact are of the form `e as T` where `e` is an
-expression, `as` is a reserved words, and `T` is a Compact type.
-
-TypeScript-style casts of the form `<T>e` are not supported in Compact.
-
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;<em>type</em></td></tr></tbody></table>
-
-Type cast expressions are type checked by checking the type of the
-subexpression.  If the cast from the subexpression's type to the
-type `T` named in the type cast is allowed, then the static type
-of the expression will be `T`.  Otherwise, it is a static type
-error.
-
-Upcasts, i.e., casts from a type to a supertype, are allowed but
-never required and never result in a static or run-time error.
-
-The table below describes the allowed type casts.  Casting between
-types not shown in the table is not allowed.  The entries in the
-table can be one of:
-
-- **static:** the type cast only changes the static type and does
-  not have any effect at runtime
-- **conversion:** the type cast always succeeds but has the runtime
-  effect of converting between different source and target
-  representations, which normally has a low cost
-- **checked:** the type cast is checked at runtime and can fail
-- **no:** the type cast is not allowed
-- a number: see the corresponding note below the table
-
-<table>
-  <thead>
-    <tr>
-      <th colspan="2"></th>
-      <th colspan="4">TO</th>
-    </tr>
-    <tr>
-      <th colspan="2"></th>
-      <th><tt>Field</tt></th>
-      <th><tt>Uint\<0..n></tt></th>
-      <th><tt>Boolean</tt></th>
-      <th><tt>Bytes\<n></tt></th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <th rowspan="5">FROM</th>
-      <th><tt>Field</tt></th>
-      <td>static</td>
-      <td>checked</td>
-      <td>1</td>
-      <td>2</td>
-    </tr>
-    <tr>
-      <th><tt>Uint\<0..m></tt></th>
-      <td>static</td>
-      <td>3</td>
-      <td>conversion</td>
-      <td>no</td>
-    </tr>
-    <tr>
-      <th>enum type</th>
-      <td>conversion</td>
-      <td>no</td>
-      <td>no</td>
-      <td>no</td>
-    </tr>
-    <tr>
-      <th><tt>Boolean</tt></th>
-      <td>conversion</td>
-      <td>4</td>
-      <td>no</td>
-      <td>no</td>
-    </tr>
-    <tr>
-      <th><tt>Bytes\<m></tt></th>
-      <td>5</td>
-      <td>no</td>
-      <td>no</td>
-      <td>6</td>
-    </tr>
-  </tbody>
-</table>
-
-1. `Field` to `Boolean`: the value `0` is converted to `false` and all other
-   values are converted to `true`.
-2. `Field` to `Bytes<n>`: the value of the field is converted into `Bytes` of
-   the given length, with the least-significant byte of the field occurring
-   first in the `Bytes`. The `Bytes` will be padded to the length with trailing
-   zeros.  It is a runtime error if the field value does not fit in the length.
-3. `Uint<0..m>` to `Uint<0..n>`: if `m` is less than or equal to `n` this is a
-   static cast.  Otherwise it is checked and will fail at runtime if the value
-   is greater than `n`.
-4. `Boolean` to `Uint<0..n>`: If `n` is not 0 then this is a conversion of
-   `false` to 0 and `true` to 1. Otherwise, it is checked and will fail at
-   runtime if the value is `true` (and convert `false` to 0).
-5. `Bytes<m>` to `Field`: the bytes are converted into a field with the
-   least-significant byte of the field occurring first in the `Bytes`.  It is a
-   runtime error if the result would exceed the maximum `Field` value.
-6. `Bytes<m>` to `Bytes<n>`: the cast is a static cast if `m` equals `n`, and is
-   not allowed otherwise.
-
-Allowed type casts are evaluated by first evaluating the subexpression.
-Then, if the cast is static, the result is the subexpression's value
-interpreted as the type `T` mentioned in the cast expression.  If the
-cast is a conversion, the JavaScript representation of the subexpression's
-value is converted into the representation of a value of type `T`. If the
-cast is checked, the check is performed before conversion and the cast
-fails (at runtime) if the check fails.  The exceptions noted in the table
-are evaluated as described above after evaluating the subexpression.
-
-#### Relational comparison expressions
+### Relational comparison expressions
 
 Relational comparison expressions are of the form `e0 op e1` where `e0`
 and `e1` are expressions and `op` is one of Compact's relational operators.
@@ -1420,427 +2095,900 @@ The relational operators are **equals** (`==`), **not equals** (`!=`), **less
 than** (`<`), **greater than** (`>`), **less than or equals** (`<=`), and
 **greater than or equals** (`>=`).
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>==</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>!=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>&gt;</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>&lt;=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>&gt;=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr></tbody></table>
-
 Equals and not equals require the types of the subexpressions to be in the
-subtype relation.  That is, the type of the first subexpression must be a
-subtype of the type of the second subexpression, or else the type of the second
-subexpression must be a subtype of the type of the first subexpression.
+subtype relation.
+That is, the type of the first subexpression must be a subtype of the type of
+the second subexpression, or the type of the second subexpression must be
+a subtype of the type of the first subexpression.
 
 Less than, greater than, less than or equals, and greater than or equals require
-the type of both subexpressions to be unsigned integer types (note that `Field`
-cannot be compared with these operators).
+the type of both subexpressions to be unsigned integer types.  (Values of type
+`Field` cannot be compared with these operators.)
 
 The type of the result is `Boolean`.
 
 Relational comparison expressions are evaluated by evaluating the subexpressions
-in order from left to right.  Then the comparison is performed as described
-below.
-
-**Equals**
-
-The comparison that is performed depends on the type of the operands:
-
-- **`Boolean`:** if the operands have type `Boolean`, then the values must be
-  the same boolean value.  Both operands will have type `Boolean` due to the static typing rules.
-- **`Uint`:** if the operands have unsigned integer types, then the integer
-  values must be equal.  Both operands will have unsigned integer types due to
-  the static typing rules.
-- **`Field`:** if either operand has type `Field`, then the integer values of
-  the operands must be equal.  Both operands will have numeric (`Field` or
-  unsigned integer) types due to the static typing rules.
-- **`Bytes:`** if the operands have bytes types, then the corresponding bytes
-  at each index must be equal.  Both operands will have bytes types and their
-  lengths will be equal due to the static typing rules.
-- **`Tuple:`** if the operands have tuple types, then the corresponding
-  element values at each index must be equal according to these rules, based on
-  the static element types.  Both operands will have tuple types, they will
-  have the the same length, and their element types will be in the subtype
-  relation due to the static typing rules.
-- **`Opaque:`** if the operands have opaque types, then the runtime values
-  must be equal according to JavaScript's strict equality (`===`) operator.
-  Both operands will have the same opaque type due to the static typing rules.
-- **structure type:** if the operands have structure types, then the
-  corresponding values of each field must be equal according to these rules,
-  based on the field types.  Both operands will have the same structure type due
-  to the static typing rules.
-- **enum type:** if the operands have enum types, then they must be the same
-  enum value.  Both operands will have the same enum type due to the static
-  typing rules.
-
-**Not equals**
-
-The operands are compared according to the rules for equals above, and then the
-boolean result is negated.
+in order from left to right.
+Then the comparison is performed as described below.
+
+**Equals and not equals**
+
+Equality depends on the types of the operands according to the following rules.
+The rules implicitly do not and need not cover cases where one operand is not a
+subtype of the other.
+For example, if one operand has type `Boolean`, so does the other; if one
+operand has a `Bytes` type of length `n`, so does the other; and if one
+has a specific structure type, so does the other.
+
+- **`Boolean` == `Boolean`:**
+  The values are equal if both are `true` or both are `false`.
+- **`Uint` or `Field` == `Uint` or `Field`:**
+  The values are equal if the integer values are equal.
+- **`Bytes`**
+  The values are equal if the corresponding bytes at each index are equal.
+- **`Tuple` and `Vector`:**
+  The values are equal if the corresponding values at each index are equal.
+- **Structure types:**
+  The values are equal if the corresponding members are equal.
+- **Enumeration types:**
+  The values are equal if they are the same enumeration member.
+- **`Opaque types:`** 
+  The values are equal if the runtime values are equal according to JavaScript's
+  strict equalty (`===`) operator.
+
+Otherwise the operands are not equal.
 
 **Less than, greater than, less than or equals, and greater than or equals**
 
-The integer values of the operands are compared according to the relational
-operation.  Both operands will have unsigned integer types due to the static
-typing rules.
+The unsigned integer values of the operands are compared according to the
+corredponding relational operation.
 
-#### Short-circuit logical expressions
+### Short-circuit logical expressions
 
 Compact supports short-circuit logical expressions of the form `e0 op e1`
 where `e0` and `e1` are expressions and `op` is one of the logical operators
 **or** (`||`) or **and** (`&&`).
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>||</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>&amp;&amp;</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr></tbody></table>
-
-Logical expressions require the type of the left subexpression to be `Boolean`.
-The type of the right subexpression must be a supertype of `Boolean`.  The only
-supertype of `Boolean` is `Boolean` itself.  The entire expression will have the
-same type as the type of the right subexpression.
+Logical expressions require the types of both subexpressions to be `Boolean`.
+Otherwise it is a static error.
+The logical expression itself also has type `Boolean`.
 
 Logical expressions are evaluated by first evaluating the left subexpression.
 Then, the value of that expression determines the value of the entire
 expression as follows:
 
-- For or, if the value of the left subexpression is `false` then the right
-  subexpression is evaluated and its value is the value of the entire
-  expression.  Otherwise, the right subexpression is **not** evaluated and the
-  value of the left subexpression, implicitly cast to the type of the entire
-  expression, is the value of the entire expression.
-- For and, if the left subexpression is `true` then the right subexpression is
-  evaluated and its value is the value of the entire expression.  Otherwise,
-  the right subexpression is **not** evaluated and the value of the left
-  subexpression, implicitly cast to the type of the entire expression, is the
+- For `||`, if the value of the left subexpression is `true` the right
+  subexpression is *not* evaluated, i.e., short-circuited, and the value
+  of the entire expression is `true`.  
+  Otherwise, the right subexpression *is* evaluated, and its value is the
+  value of the entire expression.
+- For `&&`, if the value of the left subexpression is `false` the right
+  subexpression is *not* evaluated, i.e., short-circuited, and the value
+  of the entire expression is `false`.  
+  Otherwise, the right subexpression *is* evaluated, and its value is the
   value of the entire expression.
 
-#### Conditional expressions
+These are short circuiting operators because they do not evaluate the second
+operand if the final value is determined from the first.
 
-Compact supports conditional expressions of the form `e0 ? e1 : e2` where `e0`,
-`e1`, and `e2` are expressions.
+### Boolean negation expressions
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>?</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr></tbody></table>
+Compact supports unary boolean negation expressions of the form `!e` where`e`
+is an expression.
 
-Conditional expressions require the type of `e0` to be `Boolean`.  The types of
-`e1` and `e2` must be in the subtype relation.  That is, either the type of
-`e1` is a subtype of the type of `e2` or else the type of `e2` is a subtype of
-the type of `e1`.
+The type of the subexpression must be of type `Boolean`, otherwise it is a
+static error.
+The Boolean-negation expression itself also has type `Boolean`.
+
+Negation expressions are evaluated by first evaluating the subexpression and
+checking its value.
+If the subexpression's value is `true`, the value of the Boolean negation expression is `false`.
+If the subexpression's value is `false`, the value of the Boolean negation expression is `true`.
+
+### Binary arithmetic expressions
+
+Binary arithmetic expressions have the form `e0 op e1`, where `e0` and `e1`
+are expressions and `op` is one of Compact's binary arithmetic operators.  The
+binary arithmetic operators are **add** (`+`), **subtract** (`-`) and
+**multiply** (`*`).
+
+Arithmetic expressions require the type of both subexpressions to be numeric
+types, that is, either a `Field`, a `Uint`, or a type alias for a `Field` or
+a `Uint`.
+Putting aside type aliases for now, the type of the result depends on the
+types of the subexpressions as follows:
+
+- If either subexpression has type `Field`, the result has type `Field`.
+- Otherwise the left subexpression has type `Uint<0..m>`,
+  and the right subexpression has type `Uint<0..n>`
+  for some bounds `m` and `n`.
+  The type of the result depends on the operation as follows:
+  - for add, the result has type `Uint<0..m+n>`,
+  - for subtract, the result has type `Uint<0..m>`, and
+  - for multiply, the result has type `Uint<0..m*n>`.
+
+For arithmetic operations with `Uint` result types, it is a static error if
+the result's bound would be greater than the maximum unsigned integer.
+
+Evaluating an arithmetic expression involves first evaluating the subexpressions in
+order from left to right.  Integer addition, subtraction, or multiplication is
+then used on the subexpression values.  The overflow and underflow behavior
+differs for `Field` and `Uint` operations:
+
+- `Field` arithmetic overflow and underflow wraps around 0; that is, the result
+  of an arithmetic operation whose result is a `Field` is the actual arithmetic
+  value modulo `k`, where `k` is one more than the maximum field value.
+- `Uint` addition and multiplication cannot overflow: the static type of the
+  result is always large enough to hold the result value.
+- `Uint` subtraction checks if the value of the right subexpression is greater
+  than the value of the left subexpression.  If so, it is a runtime error, since
+  the result would be negative.  Otherwise the unsigned subtraction is performed.
+
+The static typing rules imply that if `Field` arithmetic semantics is desired,
+then at least one of the operands must have static type `Field`.
+
+If the type of either subexpression is a structural type alias for a `Field` or
+`Uint` it is treated identically to that `Field` or `Uint`, both in type checking
+and evaluation.
+
+On the other hand, if the type of either subexpression is a nominal type alias
+`T` for a `Field` or a `Uint`, the type of the other subexpression must also have
+type `T`, and the type of the result also has type `T`.
+Evaluation proceeds as if the two operands had the underlying `Field` or `Uint`
+type with the value cast back to `T`, which can result in a run-time error if
+`T` is a nominal alias for a type `Uint<0..n>` and the value is not less than `n`.
+For example:
+
+!!!!!!!! TBD test this
+
+```compact
+new type Feet = Uint<32>;
+circuit foo(x: Feet, y: Feet, scale: Uint<32>): Feet {
+  return (x + y) * (scale as Feet);
+}
+```
+
+computes the sum of `x` and `y` multipled by `scale`.
+If the value of this computation fits in 32 bits, `foo` returns the value.
+Otherwise, the enclosing top-level circuit or constructor halts with a
+message indicating that the cast of the value to `Feet` failed.
+
+### Tuple creation
+
+New tuple values are created with expressions of the form `[tuple-arg, ...]` where
+`tuple-arg, ...` is a sequence of zero or more comma-separated tuple
+arguments.
+A non-empty sequence can have an optional trailing comma.
+Each tuple argument is either an expression or a *spread*.
+
+If a tuple argument is an expression `expr` of type `T`, it contributes a single
+element of type `T` to the new tuple: the value of `expr`.
+
+If a tuple argument is a spread `... expr`, the type `T` of `expr` must be
+a tuple type, a Vector type, or a Bytes type.
+Otherwise, it is a static error.
+
+If `expr` has a tuple type `[U, ...]` of length *n*, the spread contributes
+`n` new elements of type `U, ...` to to the new tuple, i.e., the elements
+of the tuple value of `expr`.
+If `expr` has a Vector type `Vector<n, U>`, the spread contributes
+`n` new elements of type `U` to to the new tuple, i.e., the elements
+of the Vector value of `expr`.
+If `expr` has a Bytes type `Bytes<n>`, the spread contributes `n` new elements of
+type `Uint<8>` to to the new tuple, i.e., the elements of the byte-vector value
+of `expr`.
+
+The type of a tuple-creation expression is the tuple type whose elements are
+the types contributed by each of the tuple arguments in order.
+
+A tuple-creation expression is evaluated by evaluating the tuple arguments from
+left to right and creating a new tuple whose elements are the values contributed
+by each of the tuple arguments in order.
+The length of the new tuple is the total number of contributed elements,
+which can be less than or greater than number of tuple arguments.
+
+### Byte-vector creation
+
+New byte vectors are created with expressions of the form
+`Bytes [tuple-arg, ...]`.
+Bytes creation is essentially the same as [tuple creation](#tuple-creation)
+except that the types of the contributed elements must all be subtypes of `Uint<8>`
+(if not, it is static error), and the result is a new byte vector of type
+`Bytes<n>` where `n` is the number of contributed elements.
+
+### Tuple, vector, and byte-vector references
+
+Compact allows references to individual elements of sequence values (tuples,
+vectors, and byte vectors) via the syntax `expr[index]` where `expr` is
+an expression and `index` is a numeric literal, generic natural-number parameter reference,
+or an expression that can be reduced to a numeric constant at compile time as
+described below.
+
+The type of `expr` must be a sequence type, i.e., a tuple type, a vector type,
+or a Bytes type.
+The type of `index` must be `Uint<n>` for any `n`.
+The eventual constant value of `index` must be less than the length of the
+sequence value as determined by its type.
+Violating any of these constraints is a static error.
+
+The unsigned integer value of `index` must be computable at compile time
+via the following rules, or it is a static error.
+
+- Any `index` can be a constant, i.e., a numeric literal or a generic natural-number
+  parameter reference.
+
+- If the type of `expr` is a tuple type that has a vector type, the rule for
+  vector types below applies, with `expr` treated as having the vector type.
+  If the type of `expr` is a tuple type that does not have a vector type,
+  however, `index` must be a constant.
+  This restriction allows the compiler to compute a type for tuple reference
+  expressions without first attempting to reduce `index` to a numeric value.
+
+- If the type of `expr` a vector or byte-vector type, `index` must be a
+  *constant-valued* expression, where a constant-valued expression is:
+  - a constant,
+  - a reference to a generic natural-number parameter,
+  - a reference to a variable bound to a constant-valued expression,
+  - a reference to a variable bound in the header of a `for` loop, or
+  - the result of adding, subtracting, or multiplying two constant-valued
+    expressions.
+
+The type of a byte-vector reference is `Uint<8>`.
+The type of a vector reference where the vector has type `Vector<n, T>` is `T`.
+The type of a tuple reference where the tuple has type `[T1, ..., Tn]` is
+`Ti` if `index` is the constant `i` or the value `i` of a generic natural-number
+parameter.
+Otherwise, `[T1, ..., Tn]` must have a vector type `Vector<n, T>` and the
+type of the tuple reference is `T`.
+
+The value of a sequence reference is element `i` (zero-based) of the result
+of evaluating `expr`, where `i` is the (eventually) compile-time constant
+value of `index`.
+
+### Tuple, vector, and byte-vector slices
+
+*Slicing* a sequence value such as a tuple, vector or byte vector produces a
+subsequence of the original value.
+It is similar to a sequence reference but extracts a sequence of values rather
+than a single value from the sequence value.
+
+Slice expressions take the form `slice<size>(expr, index)`, where `slice`
+is a keyword, `size` is a constant or numeric generic parameter reference, `expr` is
+an expression, and `index` is a numeric literal, a generic natural-number
+parameter reference, or an expression that can be reduced to a numeric constant at
+compile time as described above in the section on [Tuple, vector, and byte-vector
+references](#tuple-vector-and-byte-vector-references).
+
+The type of a byte-vector slice is `Bytes<k>` where `k` is the constant value of `size`.
+The type of a vector slice where the vector has type `Vector<n, T>` is `Vector<k, T>`.
+The type of a tuple slice where the tuple has type `[T1, ..., Tn]` is the subsequence
+`[Ti, ..., Tj]` starting with element `i` (zero-based) and ending with element
+`j = i + k - 1` of `[T1, ..., Tn]`.
+Otherwise, `[T1, ..., Tn]` must have a vector type `Vector<n, T>` and the
+type of the tuple reference is `Vector<k, T>`.
+
+The value of a `slice` expression is subsequence of the original tuple, vector,
+or byte vector from `i` (zero-based, inclusive) through `i + k` (zero-based,
+exclusive) of the resulting of evaluating `expr`, where `i` is the (eventually)
+compile-time constant value of `index` and `k` is the constant value of `size`.
+
+For example, if `getMiddle` is defined as follows:
+
+!!!!!!!! TBD test this
+
+```compact
+export circuit foo(x: Bytes<5>): Bytes<3> {
+  return slice<3>(x, 1);
+}
+```
+
+The call
+
+```compact
+getMiddle(Bytes[17, 18, 19, 20, 21])
+```
+
+evaluates to the equivalent of
+
+```compact
+Bytes[18, 19, 20]
+```
+
+### Structure creation
+
+Structure values are created with structure creation expressions.  The
+expression `T {f, ...}` is a structure creation expression, where `T` is a
+structure type name `S` or specialized generic structure type name `S<garg, ...>`,
+and `f, ...` is a sequence of zero or more comma-separated field-value specifiers.
+
+A field-value specifier can be one of three things:
+
+* A **positional** field-value specifier is an expression.  Evaluating the expression
+  gives the value for the field.  Positional field values must be given in the
+  order that fields are declared in the corresponding structure declaration.
+* A **named** field-value specifier is of the form `id: e` where `id` is a field name and
+  `e` is an expression.  Evaluating the expression gives the value for the
+  corresponding named field.  Named fields can appear in any order.  If named
+  and positional fields are mixed, all the named fields must appear after all
+  the positional fields.
+* A **spread** field-value specifier is of the form `...e` where `...` is the
+  literal three dots (ellipsis) token and `e` is an expression.
+  Evaluating the expression must give a value of the same structure type as the
+  one being created.
+  Each field of the created structure is given the value of the corresponding
+  field from the spread structure, if not overridden by a named field value,
+  as described below.
+  If a spread expression is present, it must occur as the first field-value
+  specifier, and all other specifiers must be named field values.
+
+The examples below demonstrate the use of positional and spread field values:
+
+```compact
+struct S { a: Uint<32>, b: Boolean, c: Bytes<8> }
+circuit f(x: Uint<32>, y: Boolean, z: Bytes<8>): S {
+  const s1 = S { c: z, a: x, b: y };
+  // Alternatively, s1 can be created with the positional syntax S { x, y, z }
+  // or a mix of positional and named field values S { x, c: z, b: y }.
+
+  const s2 = S { ...s1, b: true };
+  // s2 is created using the spread syntax.  So, s2 has the same field values
+  // as s1 except that b is true.
+
+  const s3 = S { ...s2, c: 'abcdefgh' };
+  // s3 is also created using the spread syntax.  s3 has the same field values
+  // as s2 except that c is 'abcdefgh'.
+
+  return s3;
+}
+```
+
+The structure type name must be bound to a structure type in scope.  If the
+structure is generic, then it must be explicitly specialized with generic
+arguments enclosed in angle brackets.  Generic structures must be fully
+specialized: the number of generic arguments must match the number of generic
+parameters.
+
+The static type of a non-generic structure creation expression is the named
+structure type.
+
+The generic arguments to a generic structure can be types, natural number
+literals, or the names of generic parameters in scope.
+The static type of a generic structure-creation expression is a structure with
+the same name as the generic type and field types obtained by substituting the
+generic arguments for the generic parameters in the structure's declaration.
+
+**If a spread field specifier is not present:** It is a static error if the number of
+field specifiers does not match the number of fields in the corresponding
+structure declaration: a value must be given for every field.  It is a static
+error if a named field specifier occurs before a positional field specifier.  It
+is a static error if a field name occurs more than once, and it is a static
+error if a field name occurs that is not the name of a field in the
+corresponding structure declaration.  It is a static error if the type of a
+positional field subexpression is not a subtype of the declared type of the
+(positionally) corresponding field in the structure declaration.  It is a static
+error if the type of a named field subexpression is not a subtype of the
+declared type of the corresponding (named) field in the structure declaration.
 
-The type of the entire expression is the type of `e2` if `e1` is a subtype of
-`e2` and the type of `e1` if `e2` is a subtype of `e1`.
+**If a spread field specifier is present:** It is a static error if the spread
+field specifier does not come first in the sequence.  It is a static error
+if the type of the spread subexpression is not the same type as the structure to be
+created.  It is a static error if there are any positional field specifiers.  It
+is a static error if a field name occurs that is not the name of a field in the
+corresponding structure declaration.  It is a static error if the type of a
+named field subexpression is not a subtype of the declared type of the
+corresponding (named) field in the structure declaration.
 
-Conditional expressions are evaluated by first evaluating `e0`.  Then, the
-value of that expression determines which of the other subexpressions is
-evaluated:
+A structure creation expression is evaluated by evaluating the field specifier
+subexpressions in order from left to right, and its value is a structure value
+whose fields have values based on the corresponding field specifier: if there is
+a positional or named field specifier for the field, the field value is the
+value of the subexpression, otherwise there must be a spread expression and the
+field value is the value of the corresponding field in the (structure) value of
+the spread subexpression.
 
-- if the value of `e0` is `true`, then `e1` is evaluated and its value is the
-  value of the entire expression
-- if the value of `e0` is `false`, then `e2` is evaluated and its value is the
-  value of the entire expression
+### Structure member access
 
-The evaluation rules ensure that only one of `e1` and `e2` is evaluated.
+An expression of the form `e.id` where `e` is an expression with a structure
+type `S` and `id` is an identifier is a structure member access.
+It is a static error if `S` does not have a member named `id`.
 
-#### Map and fold expressions
+The type of any structure member access `e.id` where `e` has type `S`
+is the type of the corresponding named member of `S`.
 
-Compact supports expressions that perform the higher-order operations _map_ and
-(left) _fold_ over tuples that have a vector type (not arbitrary tuples).
+The value of any structure member access `e.id` is the result of evaluating the
+subexpression `e` and extracting the value of the resulting structure's
+`id` member.
 
-Map expressions have the form `map(f, e, e, ...)` where `map` is a keyword, `f`
-is a circuit or witness taking at least one argument, and the `e`s are
-expressions.  A circuit or witness taking _n_ arguments can be mapped over _n_
-argument vectors by providing _n_ vector subexpressions to the `map`.
+Some expressions of the form `e.id` can also be 
+[enumeration member accesses](#enumeration-member-access) or
+[ledger `read` operations](#ledger-state-operations).
+`e.id` is recognized as a structure member access only when the
+type of `e` is a structure type.
 
-Fold expressions have the form `fold(f, init, e, e, ...)` where `fold` is a
-keyword, `f` is a circuit or witness, and `init` and the `e`s are expressions.
-A circuit or witness taking _n_+1 arguments can be folded over an initial value
-`init` and _n_ vectors by providing _n_ vector subexpressions to the `fold`.
-
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>map</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>fun</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>}&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td></td><td>|</td><td>&nbsp;&nbsp;<b><tt>fold</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>fun</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>}&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></tbody></table>
-
-The syntax of the circuit or witness is given by the grammar production for
-_fun_ in the section **Circuit and witness calls** above.
-
-A map expression is type checked by checking the type of the witness or circuit
-`f` to find its parameter types and its return type `R`.  `f` must have at least
-one parameter.  The map expression must have the same number of vector subexpressions
-as the number of parameters of `f`.  Each of the vector subexpressions
-must have a vector type and all these vector types must have the same length
-`n`.  If the type of the *i*th parameter to `f` is `T`, then the type of the
-*i*th vector subexpression must be `Vector<n, S>` where `S` is a subtype of
-`T`.  The type of entire expression is `Vector<n, R>`.
-
-A fold expression is type checked by checking the type of the witness or circuit
-`f` to find its parameter types and its return type `R`.  `f` must have at least
-two parameters, and the type of the first parameter must be the same type as the
-return type `R`.  The fold expression must have one fewer vector subexpression
-than the number of parameters of `f`.  The subexpression `e` gives the initial
-value for the fold.  It must have a type which is a subtype `R`.  Each of the
-vector subexpressions must have a vector type and all these vector types must
-have the same length `n`.  If the type of the *i*+1th parameter of `f` is `T`
-then the type of the *i*th vector subexpression must be `Vector<n, S>` where `S`
-is a subtype of `T`.  The type of the entire expression is `R`.
-
-Map expressions are evaluated by evaluating the vector subexpressions from left
-to right.  These values are the input vector values.  The witness or circuit `f`
-is then applied in turn, from index 0 up to index `n`-1, to arguments taken from
-the input vector values.  The result is a vector of length `n` where each *i*th
-element is the result of applying `f` to the *i*th element of the corresponding
-input vector values.
-
-Fold expressions are evaluated by evaluating the initial value expression `e`
-and then evaluating the vector subexpressions from left to right.  The values of
-the vector expressions are the input vector values.  The witness or circuit `f`
-is then applied in turn, from index 0 up to index `n`-1, to an accumulator value
-argument and arguments taken from the input vector values.  The 0th (initial)
-accumulator value is the value of the expression `e`, and each subsequent
-*i*+1th accumulator value is the result of applying `f` to the *i*th accumulator
-value and to the *i*th element of the corresponding input vector values.  The
-result is the `n`th (final) accumulator value where `n` is the length of the
-input vectors.
+### Enumeration member access
 
-#### Ledger assignment expressions
+An expression of the form `E.id` where `E` is the name of an enumeration
+type and `id` is an identifier is an enumeration member access.
+It is a static error if `E` does not have a member named `id`.
 
-Compact has ledger assignment statements.  They have the form `lhs op e` where
-`lhs` is a ledger expression as defined in the section **Ledger expressions**
-above, `op` is one of the assignment operators `=` (assignment), `+=` (addition
-assignment), or `-=` (subtraction assignment), and `e` is an expression.
+The type of any enumeration member access `E.id` is `E`.
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<em>id</em>&nbsp;&nbsp;{<em>ledger-accessor</em>}&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<em>id</em>&nbsp;&nbsp;{<em>ledger-accessor</em>}&nbsp;&nbsp;<b><tt>+=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<em>id</em>&nbsp;&nbsp;{<em>ledger-accessor</em>}&nbsp;&nbsp;<b><tt>-=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr></tbody></table>
+`E.id` is a constant.
+That is, the value of any enumeration member access `E.id` is `E.id`.
 
-`lhs = e` is shorthand for `lhs.write(e)`.  `lhs += e` is shorthand for
-`lhs.increment(e)`.  `lhs -= e` is shorthand for `lhs.decrement(e)`.
+Some expressions of the form `e.id` can also be 
+[structure member accesses](#enumeration-member-access) or
+[ledger `read` operations](#ledger-state-operations).
+`e.id` is recognized as an enumeration member access only when the
+type of `e` is an enumeration type.
 
-Ledger assignment statements are type checked exactly as if they were their
-longer equivalent invoking a ledger ADT operation.
+### Circuit and witness calls
 
-They are evaluated exactly as if their longer equivalent were evaluated as a
-ledger expression.
+<table className="lang-ref-table"><tbody><tr><td><em>fun</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gargs</em></a><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>arrow-parameter-list</em>&nbsp;&nbsp;<em>return-type</em><sup>opt</sup>&nbsp;&nbsp;<b><tt>=></tt></b>&nbsp;&nbsp;<a href="#statements"><em>block</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>arrow-parameter-list</em>&nbsp;&nbsp;<em>return-type</em><sup>opt</sup>&nbsp;&nbsp;<b><tt>=></tt></b>&nbsp;&nbsp;<a href="#expressions"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>fun</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
+<tr><td><em>arrow-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>optionally-typed-pattern</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>optionally-typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
+<tr><td><em>optionally-typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>typed-pattern</em></td></tr>
+<tr><td><a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
+<tr><td><a href="#patterns-and-destructuring"><em>pattern-struct-elt</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>pattern</em></td></tr>
+<tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr>
+<tr><td><em>return-type</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
 
-## Declaring witnesses for private state
+Circuits and witnesses, collectively referred to as functions, are called via an
+expression of the form `f(e, ...)`, where `f` is a function and `e, ...` is a
+sequence of zero or more comma-separated argument expressions.
 
-Compact code can call code external to the zero-knowledge circuits to read
-and update private state via `witness` functions.
+The function expression can take several different forms:
 
-A `witness` function declaration can appear anywhere a `circuit`
-definition can appear, including within modules.  A witness function does not
-have a body, and its implementation is instead an input to
-the contract in the TypeScript target. For instance:
+A **function name** is the name of a circuit or witness from a circuit or
+witness declaration in scope.
 
-```compact
-witness something(x: Boolean): Field;
-```
+An **anonymous circuit** is an inline circuit definition having the form `(P,
+...) => body` or `(P, ...): R => body`, where `P, ...` are zero or more
+comma-separated parameter declarations, `R` is an optional return type
+annotation, and `body` is the circuit's body.
+Each parameter is a [pattern](#patterns-and-destructuring) with an optional type
+annotation `: T` where `T` is a Compact type.
+The optional return type `R` is a Compact type.
+The body is either a [block](#blocks) or an expression.
 
-A `witness` function can be called in the same way as a `circuit`.
+There is no syntax for generic anonymous circuits.  This is because circuits are
+not first-class values: they cannot be passed around or stored in data
+structures, they *must* be called.  And generic circuits must be specialized to
+call them, so anonymous generic circuits would have to be immediately
+specialized.  In that case, the programmer can just write the non-generic
+version themselves.
 
-:::danger
+A **parenthesized function** has the form `(f)` where `f` is a function expression,
+i.e., a function name, anonymous circuit, or parenthesized function.
 
-Do not assume in your contract that the code of any `witness` function
-is the code that you wrote in your own implementation.  Any DApp may
-provide any implementation that it wants for your `witness` functions.
-Results from them should be treated as untrusted input.
+Because circuits and witnesses are not first class, parameter names and constant
+names are not allowed as the circuit or witness part of a call.  Nor are
+arbitrary expressions allowed, for the same reason.
 
-:::
+Generic functions cannot be called without explicitly specializing them with
+generic arguments enclosed in angle brackets.  Calls to generic functions must
+be fully specialized: the number of generic arguments must match the number of
+generic parameters.
 
-## Declaring and maintaining public state
+The *underlying function* of a function expression is a non-parenthesized
+function expression.  For a function name it is the function name, for an
+anonymous circuit it is the anonymous circuit, and for a parenthesized function
+it is the underlying function of the parenthesized function expression.
 
-Compact code can declare public state through `ledger` declarations.
+Type checking a function call depends on the form of the underlying function.
 
-A ledger declaration defines one piece of information the contract
-stores in Midnight's public ledger.
-Multiple ledger declarations can appear in a program, or none.
-They can appear anywhere circuit definitions can appear,
-including within modules.
+* **For a named function:** Function names may be *overloaded*: more than one
+  function of the same name may be present in the scope of a call to that
+  function.  A call whose underlying function is a name can thus have zero or
+  more candidate functions, i.e., all of those that have the given name and are
+  present in the scope of the call.
 
-A ledger declaration associates a ledger field name with one of a
-set of predefined [ledger ADT types](#ledger-state-types)
-For instance:
+  A candidate function is not necessarily compatible with the number and kinds
+  of the generic parameter values, nor with the number and types of the argument
+  expressions provided at the call site.  It is compatible if and only if the
+  number of generic parameters is the same as the number of generic arguments,
+  each generic argument is of the required kind (numeric or type), the number
+  of declared parameters is the same as the number of argument expressions, and
+  the type of each argument is a subtype of the declared type of the
+  corresponding parameter. If exactly one candidate is compatible, the call is made
+  to that candidate.  It is a static error if there is not
+  exactly one compatible candidate.
 
-```compact
-ledger val: Field;
-export ledger cnt: Counter;
-sealed ledger u8list: List<Uint<8>>;
-export sealed ledger mapping: Map<Boolean, Field>;
-```
+  The static type of a call to a named function is the declared return type of
+  the called function.
 
-### Ledger state types
+* **For an anonymous circuit:** Parameters are type-checked or inferred as follows:
 
-In a `ledger` declaration, the following types are valid:
+  - If there is a type annotation for a parameter, it is a static error if
+    the type of the corresponding argument expression is not a subtype of the
+    type annotation.
 
-- `T`, for any Compact type `T`
-- `Counter`
-- `Set<T>`, for any Compact type `T`
-- `Map<K, T>`, for any Compact types `K` and `T`
-- `Map<K, V>`, for any Compact type `K` and ledger state type `V` (see the following section)
-- `List<T>`, for any Compact type `T`
-- `MerkleTree<n, T>`, for a compile time integer `1 < n <= 32`, and any Compact
-  type `T`
-- `HistoricMerkleTree<n, T>`, for a compile time integer `1 < n <= 32`, and any
-  Compact type `T`
+  - If there is no type annotation for a parameter, the parameter's type is
+    inferred as the type of the corresponding argument expression.
 
-Each ledger type supports a set of operations, which can be invoked with
+  Within the body of the anoymous circuit, the type of each variable binding arising
+  from the binding of identifiers in each parameter pattern to the corresponding
+  pieces of the corresponding argument is the type of the corresonding part of
+  the structure of the declared or inferred parameter type.
 
-```compact
-<field name>.<operation>(<arguments ...>)
-```
+  If there is a return type annotation, it is a static error if the body can
+  return a type of value that is not a subtype of the return type annotation.
+  A return statement of the form `return;` implicitly returns a value of type
+  `[]`, as does every control flow path through a body that does not explicitly
+  end with a return statement.
 
-A ledger field that is declared with a Compact type `T` implicitly has the type
-`Cell<T>`. `Cell` has operations such as `read`, `write`, and `reset_to_default`.
+  If there is no return type annotation, then a return type is inferred from the
+  body as the least upper bound of the types of the values that can be returned
+  from the body (explicitly or implicitly).
+  It is a static error if these types do not have a least upper bound.
 
-The `read` and `write` operations for the `Cell` type of any Compact type `T` have syntactic
-sugar. If `x` is a field in the ledger of any Compact type, then you may write
+  The static type of a call to an anonymous circuit is the declared or inferred
+  return type.
 
-```compact
-x       // expression equivalent to x.read()
-x = val // statement equivalent to x.write(val)
-```
+Calls are evaluated by evaluating the argument expressions in order from left to
+right.  Then, if a circuit is being called, the statements in the body of the
+circuit are executed with the parameter names bound to the corresponding
+argument values.  The value of a circuit call is the value returned from the
+execution of the body.  If a witness is being called, the contract invokes
+the externally provided witness function with the argument values.  The
+value of a witness call is the value returned by the witness function.
 
-The `read`, `increment`, and `decrement` operations of type `Counter` type also
-have syntactic sugar.  If `c` is a `Counter` field in the ledger, then you may write
+### Map and fold expressions
 
-```compact
-c        // expression equivalent to c.read()
-c += val // statement equivalent to c.increment(val)
-c -= val // statement equivalent to c.decrement(val)
-```
+Compact supports expressions that perform the higher-order operations _map_ and
+(left) _fold_ over vectors, tuples that have vector types (not arbitrary tuples),
+and byte vectors.
 
-A comprehensive list of operations can be found in
-the Compact [ledger data type documentation](./ledger-adt).
+Map expressions have the form `map(f, e, e, ...)` where `map` is a keyword, `f`
+is a circuit or witness taking at least one argument, and each `e` is an expression.
+A circuit or witness taking _n_ arguments can be mapped over _n_ sequence values
+(vectors, tuples that have vector types, or byte-vectors) by providing _n_
+sequence-value subexpressions to the `map`.
 
+Fold expressions have the form `fold(f, init, e, e, ...)` where `fold` is a
+keyword, `f` is a circuit or witness taking at least two arguments, `init`
+is an expression, and each `e` is an expression.
+A circuit or witness taking _n_+1 arguments can be folded over an initial value
+`init` and _n_ sequence values by providing _n_ sequence-value subexpressions to
+the `fold`.
+
+A detailed description of the circuit or witness `f` is given in
+[Circuit and witness calls](#circuit-and-witness-calls) above.
+
+A map expression is type-checked by checking the type of the witness or circuit
+`f` to find its declared or inferred parameter types and its declared or
+inferred return type `R`.
+`f` must have at least one parameter, and the map expression must have the same
+number of sequence-value subexpressions as the number of parameters of `f`.
+Each of the sequence-value subexpressions must have a vector or byte-vector type,
+and all these types must have the same length `n`.
+If the type of the *i*th parameter to `f` is `T`, then the *i*th sequence-value
+subexpression must have the vector type `Vector<n, S>` where `S` is a subtype of
+`T`, or it must be the byte-vector type `Bytes<n>` and `Uint<8>` must be a subtype
+of `T`.
+The type of `map` expression is `Vector<n, R>`, regardless of whether the input
+sequence-value subexpressions are vectors, tuples, or byte-vectors.
+
+A fold expression is type-checked by checking the type of the witness or circuit
+`f` to find its parameter types and its return type `R`.
+`f` must have at least two parameters, and the type of the first parameter must
+be the same type as the return type `R`.
+The `fold` expression must have one fewer sequence-value subexpression than the
+number of parameters of `f`.
+The first subexpression `init` gives the initial value for the fold.
+It must have a type which is a subtype `R`.
+Each of the sequence-value subexpressions must have a vector or byte-vector type
+and all these types must have the same length `n`.
+If the type of the *i*+1th parameter of `f` is `T`, then the type of the *i*th
+sequence-value subexpression must have the vector type `Vector<n, S>` where `S`
+is a subtype of `T`, or it must be the byte-vector type `Bytes<n>` and `Uint<8>`
+must be a subtype of `T`.
+The type of the entire expression is `R`.
+
+Map expressions are evaluated by evaluating the sequence-value subexpressions
+from left to right.
+These values are the input sequence values.
+The witness or circuit `f` is then applied in turn, from index 0 up to index
+`n`-1, to arguments taken from the input sequence values.
+The result is a vector of length `n` where each *i*th element is the result of
+applying `f` to the *i*th elements of the corresponding input sequence values.
+
+Fold expressions are evaluated by evaluating the initial value expression `init` and
+then evaluating the sequence-value subexpressions from left to right.
+The values of the sequence-value expressions are the input sequence values.
+The witness or circuit `f` is then applied in turn, from index 0 up to index `n`-1,
+to an accumulator value argument and arguments taken from the input sequence values.
+The 0th (initial) accumulator value is the value of the expression `init`, and
+each subsequent *i*+1th accumulator value is the result of applying `f` to the
+*i*th accumulator value and to the *i*th elements of the corresponding input
+sequence values.
+The result is the `n`th (final) accumulator value where `n` is the length of the
+input vectors.
 
-### Nested state types in the `Map` type
+### Type cast expressions
+
+Values of one type can be cast to another, when allowed, via a *cast*, which
+takes the following form:
+
+The effects of casting an expression `e` of type `T` to another type `U` depend
+on the specific types involved.
+For some types `T` and `U`, the cast is not allowed, which is a static error.
+Even if the cast is allowed, some values of type `T` might not be representable
+as values of type `U`.
+In such cases, a run-time check of the value of `e` is required and can result
+in a run-time error.
+In cases where the run-time representation of `T` is different from the run-time
+representation of `U`, the value of `e` must be converted at run time from the
+one representation to the other.
+
+The type of any (allowed) cast `e as T` is, naturally, `T`.
+
+Evaluation of a cast proceeds by evaluation of its subexpression, followed by
+any checks and conversions required by the cast.
+If a check fails, a run-time error is reported.
+
+TypeScript casts of the form `<T>e` are not supported in Compact.
+
+The following rules govern when casts are allowed, when casts might cause run-time
+errors, and casts might require run-time conversions.
+Any cast not covered by one of the rules is not allowed.
+
+!!!!!!!! TBD verify all of these claims -- Parisa
+
+In meeting convo: Do we have all the cases for downcast? check the code in analysis pass to see if it does
+what the claims say. the downcast isn't correct, even the example isn't correct.
+
+#### Upcasts
+
+- Upcasts, i.e., casts from a type to a (supertype)[subtyping-and-least-upper-bounds]
+  (e.g., from `Vector<3, Uint<8>>` to `Vector<3, Uint<16>>`), are always allowed
+  (but never required), never result in run-time errors, and, except in the case
+  where the type and the supertype are the same, might require run-time conversions.
+
+!!!!!!!! TBD Might want to mention other impliciations of this rule, such as rules for casting tuples to vectors and back
+
+#### Downcasts of `Field` and `Uint` types
+
+- `Uint` downcasts, i.e., casts from `Uint<m>` to `Uint<n>`, `m > n`, are always
+   allowed, always require run-time checks, and might require run-time conversions.
+   The same applies to `Field` to `Uint` casts where the maximum value of the
+   `Uint` type exceeds the maximum `Field` value, as well as `Uint` to `Field` casts
+   where the maximum value of the `Uint` type is less than or equal to the maximum
+   `Field` value.
+
+#### Casts of `Boolean` to and from `Field` and `Uint`:
+
+- Casts from `Boolean` to `Field` or `Uint<0..m>` are always allowed, sometimes
+  require run-time checks, and require a run-time conversion (of `false` to `0`
+  and `true` to `1`).
+  A run-time check is required for `Uint<0..1>`.
+- Casts from `Field` or `Uint<0..m>` to `Boolean` are always allowed, cannot
+  result in run-time errors, and require a simple run-time conversion (of `0` to
+  `false` and any other value to `true`).
+
+#### Casts of Enum types to and from `Field` and `Uint`:
+
+- Casts from enum types with `n` elements to `Field` or `Uint<0..m>` are
+  always allowed, sometimes require run-time checks, and might require a run-time
+  conversion.
+  A run-time check is required for `Uint<0..m>`, `m <= n`.
+- Casts from `Field` or `Uint<0..m>` to an enum type with `n` elements are
+  always allowed, sometimes requires a run-time checks, and might require a run-time
+  conversion.
+  A run-time check is required for `Field` and `Uint<0..m>`, `m > n + 1`.
+
+#### Casts of `Bytes` to and from `Field` and `Uint`:
+
+- Casts from `Bytes<m>`, `m != 0`, to `Field` or `Uint<0..k>` are always allowed,
+  require a run-time check, and require a run-time conversion.
+  That is, the byte-vector value of the expression is converted into a `Field` or
+  `Uint<0..m>` with the least-significant byte of the result corresponding to the
+  first byte in the byte vector.
+  A run-time error occurs if the result exceeds the maximum value of `Field`
+  or `Uint<0..m>`.
+- Casts from `Field` or `Uint<0..k>` to `Bytes<m>`, `m != 0`, are always allowed,
+  require a run-time check, and require a run-time conversion.
+  That is, the integer value of the expression is converted into a byte vector
+  with the first byte of the byte vector corresponding to the least-significant
+  byte of the integer.
+  A run-time error occurs if the result does not fit in `m` bytes.
+
+#### Casts of `Bytes` to and from `Vector` and tuple types:
+
+- Casts from `Bytes<m>` to `Vector<m, Field>` or `Vector<m, Uint<0..k>>`,
+  `k >= 256`, or `[U1, ..., Um]`, where each `Ui = Uint<0..j>` for some j >= are allowed, cannot cause a run-time error, but do require a
+  run-time conversion.
+- Casts from `Bytes<m>` to tuple type `[U1, ..., Um]`, where each `Ui` is
+  `Uint<0..j>` for some `j >= 256` are allowed, cannot cause a run-time error,
+  but do require a run-time conversion.
+- Casts from tuple type `[U1, ..., Um]` to `Bytes<m>`, where each `Ui` is
+  `Uint<0..j>` for some `j < 256` are allowed, cannot cause a run-time error,
+  but do require a run-time conversion.
+- Casts from `Vector<m, Uint<0..k>>`, `k < 256`, to `Bytes<m>` are allowed,
+  cannot cause a run-time error, but do require a run-time conversion.
+
+### Ledger state operations
 
-The only ledger state type in which values of other state types may be
-held is `Map`.  The key values in a `Map` must be non-state types
-(simple Compact types), but the mapped values may be counters, sets,
-lists, other maps, and so on.
+A Compact program interacts with its public state by invoking operations upon
+the ledger.
+There are two different forms of ledger operations.
 
-Here is a small example:
+__Kernel operations__ are operations that do not depend on specific ledger
+state.  They can be invoked by expressions of the form `k.op(e, ...)`, where
+`k` is the name of a ledger field declared to have the special ledger-state type `Kernel`,
+`op` is the name of a builtin kernel operation, and
+`e, ...` is a comma separated sequence of zero or more argument expressions.
+The `CompactStandardLibrary` predefines the ledger field name `kernel` to have
+ledger type `Kernel`, so for example, the built-in `self` operation can be called
+from a circuit as follows:
 
 ```compact
 import CompactStandardLibrary;
-
-ledger fld: Map<Boolean, Map<Field, Counter>>;
-
-export circuit initNestedMap(b: Boolean): [] {
-  fld.insert(b, default<Map<Field, Counter>>);
+circuit f(): ContractAddress {
+  return kernel.self();
 }
+```
 
-export circuit initNestedCounter(b: Boolean, n: Field): [] {
-  fld.lookup(b).insert(n, default<Counter>);
-}
+The static type of a kernel operation expression is the return type of the
+corresponding kernel operation according to the
+the Compact [ledger data type documentation](ledger-adt).
 
-export circuit incrementNestedCounter(b: Boolean, n: Field, k: Uint<16>): [] {
-  fld.lookup(b).lookup(n).increment(k);
-}
+Kernel operations are evaluated by evaluating the argument subexpressions in
+order from left to right and then invoking the corresponding kernel operation
+with the argument values.
 
-export circuit readNestedCounter1(b: Boolean, n: Field): Uint<64> {
-  return fld.lookup(b).lookup(n).read();
-}
+__Ledger-state operations__ are operations on the contract's declared public ledger-state.
+In its simplest form, a ledger-state operation is an expression `F.op(e, ...)`, where `F`
+is a ledger field name
+([declared via a `ledger` field declaration](#declaring-and-maintaining-public-state)),
+`op` is the name of a ledger-state operator,
+and each `e` is an expression.
+`F` can also be another ledger-state operation, allowing ledger-state operations
+to be chained when the result of a ledger-state operation might itself have a
+ledger-state type.
+(Kernel operations cannot be chained, because the kernel is not a ledger-state
+type and is not returned by any operation.)
+Compact also supports shorthands for certain ledger-state operations; these are
+described below in [Ledger-state-operation shorthands](#ledger-state-operation-shorthands).
+
+The static type of a ledger-state operation is the return type of the
+corresponding ledger-state operation according to the
+the Compact [ledger data type documentation](ledger-adt).
+This might be a Compact type or it might be a ledger-state type.
+A ledger-state operation whose return type is a ledger-state type *must* be
+chained, i.e., immediately subject to another ledger-state operation.
+It is a static error if this is not the case.
+
+A ledger-state operation `F.op(e, ...)` is evaluated by evaluating `F` if `F`
+is itself a ledger-state operation, then evaluating the argument subexpressions
+from left to right, and then invoking the operation `op` with the argument
+values on the portion of the public ledger state identified by `F`.
+
+### Ledger-state-operation shorthands
+
+Compact supports several shorthands for common ledger-state operations.
+
+The simplest of these is a shorthand for the ledger-state operation
+`F.read()` where `F` is a ledger-state field name or itself a another
+ledger-state operation.
+If the type of `F` is a ledger-state type that supports the `read`
+operation, `F.read()` can be abbreviated, simply, to `F`.
+
+The other shorthands all take the form of assignment statements and
+abbreviate the ledger operations `F.write(e)`, `F.increment(e), and
+`F.decrement(e)`, where `e` is an expression.
+
+If the type of `F` is a ledger-state type that supports the `write`
+operation, `F.write(e)` can be abbreviated `F = e`.
+Similarly, if the type of `F` is a ledger-state type that supports the
+`increment` operation, `F.increment(e)` can be abbreviated `F += e`,
+and if the type of `F` is a ledger-state type that supports the
+`decrement` operation, `F.decrement(e)` can be abbreviated `F -= e`.
+
+The typing and evaluation rules for the abbreviations are identical
+to expressions they abbreviate.
+
+### Asserts
+
+An assertion has the form `assert(e, "msg")` where `e` is an expression and `msg`
+is a string message.
+`e` must have a Boolean type, otherwise it is a static error.
+
+The type of every `assert` form is `[]`.
+
+Evaluation form proceeds by evaluating `e`.
+If the value of `e` is true (the assertion succeeds), the `assert` form produces
+the value `[]`.
+If, however, the value of `e` is false (the assertion fails), the `assert` form
+halts computation of the enclosing top-level circuit or constructor with the
+message `msg`.
 
-export circuit readNestedCounter2(b: Boolean, n: Field): Uint<64> {
-  return fld.lookup(b).lookup(n);
-}
-```
+Each assertion is checked at runtime and constrained in-circuit.
 
-In this example,
-- `fld` is bound to a `Map` from `Boolean` values to `Map`s from `Field` values to `Counter`s
-- `initNestedMap` can be used to create the inner `Map` for a particular outer-`Map` key
-- `initNestedCounter` can be used to create a `Counter` for a given outer-`Map` key and a given inner-`Map` key
-- `incrementNestedCounter` can be used to increment an existing `Counter` for a given outer-`Map` key and a given inner-`Map` key
-- either `readNestedCounter1` or `readNestedCounter2` can be used to read the value of an existing `Counter`
-  for a given outer-`Map` key and a given inner-`Map` key.
+### Explicit disclosure
 
-Notes:
+Private data can enter a Compact contract via the arguments to exported circuits
+and via the return values of witnesses.
+Compact supports *selective disclosure*, in which the contract decides which
+private data, if any, should be disclosed in the transcripts and public state
+of the contract, and how that private data should be encoded.
 
-1. Nesting is permitted only within `Map` values.  That is, nesting is not permitted in
-   `Map` keys or within any ledger state type other than `Map`.
-2. Nested values must be initialized before first use.  The syntax `default<T>`
-   is used to create default ledger state type values, just as it can be used to
-   create default Compact type values.
-3. Ledger state type values are not first-class objects, so when
-   accessing a nested value, the entire indirection chain must be
-   used.  For example, the following will result in a compiler error:
-   ```compact
-   export circuit incrementNestedCounter(b: Boolean, n: Field, k: Uint<16>): [] {
-     fld.lookup(b); // ERROR: incomplete chain of indirects
-   }
-   ```
-4. When the last lookup is a read of a base type one can omit the
-   explicit `read()` indirect, as illustrated by the definitions of
-   `readNestedCounter1` and `readNestedCounter2` above, which have the
-   same behavior.
-5. For convenience, local variables can hold default ledger state type values,
-   so the following definition of `initNestedMap` is equivalent to the one
-   above.
-   ```compact
-   export circuit initNestedMap(b: Boolean): [] {
-     const t = default<Map<Field, Counter>>;
-     fld.insert(b, t);
-   }
-   ```
+Compact itself has no information about the nature of any private data and whether
+and how it is necessary to disclose it, the decision to to so rests with the
+contract developer.
+Compact does, however, require that such disclosure be explicitly declared to
+prevent unintentional disclosure, so that privacy is the default and disclosure
+is the exception.
 
-### Sealed and unsealed ledger fields
+The mechanism for explicitly declaring disclosure is simple: disclosure of private
+data (exported circuit arguments, witness return values, and anything derived from
+private data) must be acknowledged by wrapping an expression whose value contains
+private data in a `disclose()` wrapper before storing it in the public state, returing
+it from an exported circuit, or using it in conditional expressions that might
+affect what is stored in the public state or or returned from an exported circuit.
 
-Any ledger field can be optionally marked *sealed* by prefixing the
-ledger field declaration with the keyword `sealed`.  A sealed field
-cannot be set except during contract initialization.  That is, its
-value can be modified only by the contract constructor (if any),
-either directly within the body of the constructor or via helper
-circuits called by the constructor. The `sealed` keyword must come after
-the `export` keyword (if present) and before the `ledger` keyword, as
-in the following example:
+For example, the following contract attempts to disclose privata data without
+explictly declaring the disclosure when it stores the value of the exported
+parameter `x` into the ledger field `F`:
 
 ```compact
-sealed ledger field1: Uint<32>;
-export sealed ledger field2: Uint<32>;
-
-circuit init(x: Uint<32>): [] {
-  field2 = x;
-}
-
-constructor(x: Uint<16>) {
-  field1 = 2 * x;
-  init(x);
+ledger F: Uint<16>;
+export circuit setf(x: Uint<16>): [] {
+  F = x;
 }
 ```
 
-It is a static error if a sealed ledger field can be set by any
-code that is reachable from an exported circuit.
-
-## Contract constructor
-
-A contract can be initialized via a contract constructor defined at the
-program's top level.
-The constructor, if any, is typically used to initialize public state
-and can also be used to initialize private state through witness
-calls.
-
-<table className="lang-ref-table"><tbody><tr><td><em>prog</em>&nbsp;&nbsp;</td><td>→</td><td>&nbsp;&nbsp;<b><tt>constructor</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;[<em>p</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>type</em>&nbsp;&nbsp;\{<b><tt>,</tt></b>&nbsp;&nbsp;<em>p</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>type</em>}]&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>block</em>&nbsp;&nbsp;</td></tr></tbody></table>
-
-A constructor has the form `constructor (p: T, ...) block` where `p: T, ...` is a sequence of zero or more comma-separated
-[parameter declarations with type annotations](#parameters-patterns-and-destructuring)
-and `block` is a sequence of zero or more semicolon-delimited statements
-enclosed in curly braces (`{ }`). The return type of a constructor is `[]`.
-
-At most one contract constructor can be defined for a contract, and it
-must appear only at the program top level, i.e., it cannot be defined in
-a module.
-To initialize ledger fields that are visible only within a module, the
-constructor can call a circuit that is exported from the module.
-For example:
+Compiling this program produces the following error message in Version 1.0 of
+the Compact compiler:
 
 ```compact
-module PublicState {
-  enum STATE { unset, set }
-  ledger state: STATE;
-  ledger value: Field;
-  export circuit init(v: Field): [] {
-    value = disclose(v);
-    state = STATE.set;
-  }
-}
+Exception: testfile.compact line 3 char 5:
+  potential witness-value disclosure must be declared but is not:
+    witness value potentially disclosed:
+      the value of parameter x of exported circuit setf at line 2 char 21
+    nature of the disclosure:
+      ledger operation might disclose the witness value
+    via this path through the program:
+      the right-hand side of = at line 3 char 5
+```
 
-import PublicState;
+The remedy in this case is simple: wrap the reference to `x` in a `disclose()`
+wrapper.
 
-constructor(v: Field) {
-  init(v);
+```compact
+ledger F: Uint<16>;
+export circuit setf(x: Uint<16>): [] {
+  F = disclose(x);
 }
 ```
 
-### Runtime representations and type/bounds checks
+The `disclose()` wrapper does not cause disclosure in itself; in fact, it has no
+effect other than telling the compiler that it is okay to disclose the value of
+the wrapped expression.
+Equivalently, it tells the compiler to pretend that the value of the wrapped
+expression does not contain witness data whether it actually does or not.
+
+The compiler works hard to ensure there are no false alarms and also to provide
+precise and accurate information about the nature of the disclosure and how it
+occurs.
+
+Often, the same value is disclosed along different paths, and the nature of the
+disclosure might be more obscure, particularly if it involves indirect disclosure
+via conditional expressions.
+Detailed advice about how to understand and remedy disclosures is beyond the
+scope of this document, but a few things are worth noting:
+- It is often sufficient to correct first disclosure issue reported at a given
+  disclosure if multiple disclosures are listed.
+- Whenever feasible, the `disclose()` wrapper should be placed as close to
+  the actual disclosure site as possible.
+- When disclosing a hashed or otherwise obfuscated variant of witness data,
+  place the disclosure somewhere on the path between input and disclosure
+  *after* the obfuscation to help prevent disclosure of the unobfuscated 
+  input.
+
+More details are given in
+[Explicit Disclosure in Compact: The Midnight "Witness Protection Program"](explicit-disclosure).
+
+## Run-time data representation
 
 The TypeScript type representing a Compact type is defined in [Representations
 in TypeScript](#representations-in-typescript).
@@ -1890,7 +3038,7 @@ for a primitive type:
 - `Opaque<"String">` - `new CompactTypeString()`
 - `Opaque<"Uint8Array">` - `new CompactTypeUint8Array()`.
 
-For user-defined types, structures are not currently easily
+For program-defined types, structures are not currently easily
 constructed at runtime and require implementing `CompactType<T>`
 manually or using compiler internals.  Enumerations are exposed
 through `new CompactTypeEnum(maxValue, length)`, where `maxValue` is
@@ -1899,6 +3047,8 @@ representation length in bytes (almost always 1).
 
 ## TypeScript target
 
+!!!!!!!! TBD Parisa should check this section to verify it matches reality
+ 
 When compiled, a contract generates several artifacts. Key to these
 are the exported circuits from the contract's top level. These are
 divided into two categories: [pure circuits and impure circuits](#pure-and-impure-circuits).
@@ -1921,7 +3071,7 @@ contracts depend upon and which implements key built-in behaviors.
 
 A contract exports the following in the TypeScript module:
 
-- The TypeScript type corresponding to each user-defined type exported from the
+- The TypeScript type corresponding to each program-defined type exported from the
   contract's top level
 - A `Witnesses<T>` type, which describes the format external witnesses must
   satisfy to instantiate the contract
@@ -1948,10 +3098,79 @@ local/private state. For the most part, `circuit` and `witness` functions are
 translated simply by translating their Compact types into corresponding
 TypeScript types for parameters and return values. For `PureCircuits`, this is
 all that happens, for the other `_Circuits` instances, they receive an
-additional first parameter of type `runtime.CircuitContext<T>`, and their
-result type `R` is wrapped in `runtime.CircuitResults<T, R>`. For `Witnesses`,
-they receive an additional first parameter of type
-`runtime.WitnessContext<Ledger, T>`, and their result type `R` is wrapped in
-`[T, R]`. See the [runtime API docs](/docs/develop/reference/midnight-api/compact-runtime/README.md) for the details of
-these types. This wrapping makes the entirety of the contract code
+additional first parameter of type `runtime.CircuitContext<T>`, and their result
+type `R` is wrapped in `runtime.CircuitResults<T, R>`. For `Witnesses`, they
+receive an additional first parameter of type `runtime.WitnessContext<Ledger,
+T>`, and their result type `R` is wrapped in `[T, R]`. See the [runtime API
+docs](/api-reference/compact-runtime) for the
+details of these types. This wrapping makes the entirety of the contract code
 *functional*, ensuring calls have no hidden side effects.
+
+### Representations in TypeScript
+
+Compact's primitive types are represented in TypeScript as follows:
+
+- `Boolean` - `boolean`
+- `Field` - `bigint` with runtime bounds checks
+- `Uint<n>` / `Uint<0..n>` - `bigint` with runtime bounds checks
+- `[T, ...]` - the TypeScript tuple type `[S, ...]` or else the TypeScript array
+  type `S[]` with runtime length checks, where `S` is the TypeScript
+  representation of the corresponding type `T`
+- `Bytes<n>` - `Uint8Array` with runtime length checks
+- `Opaque<"string">` - `string`
+- `Opaque<"Uint8Array">` - `Uint8Array`
+
+Program-defined types are represented in TypeScript as follows:
+- `enum` instances - a `number` with runtime membership checks
+- `struct` instances with fields `a: A, b: B, ...` - an object `{ a: A, b: B, ... }`
+  where `A`, `B`, ... are the TypeScript representations of the Compact types.
+
+Note that other `Opaque` types are currently not supported.
+
+## Implementation-specific limits
+
+Compact compiler version 1.0 limits certain datatype values and sizes:
+
+- The maximum value of a `Field` value is 
+52435875175126190479447740508185965837690552500527637822603658699938581184512.
+This value is dictated by the scalar field size of the ZK proving system.
+- The maximum value of a `Uint` value is
+452312848583266388373324160190187140051835877600158453279131187530910662655.
+This value is `(256^k)-1` where `k` is the number of bytes that fits in
+a scalar field value of the ZK proving system.
+- The maximum length of a vector or byte-vector is `2^24 = 16777216`.
+This value is chosen as a reasonable upper bound that helps prevent the compiler
+from looping indefinitely on programs that operate on excessively large vector
+and byte-vector types.
+
+These limits may change in future versions of the compiler.
+
+## External resources
+
+### Compact formal grammar
+
+See [here](compact-grammar).
+
+### Compact keywords and reserved words
+
+See [here](compact-keywords).
+
+### Compact ledger-state types and operations
+
+See [here](ledger-adt).
+
+### Runtime API
+
+See [here](/api-reference/compact-runtime)
+
+### Compiler usage
+
+See [here](../compilation-and-tooling/compiler-usage).
+
+### Explicit disclosure in Compact
+
+See [here](explicit-disclosure).
+
+### Writing a contract in Compact
+
+See [here](../writing).
diff --git a/static/language/ledger-adt.mdx b/docs/compact/reference/ledger-adt.mdx
similarity index 98%
rename from static/language/ledger-adt.mdx
rename to docs/compact/reference/ledger-adt.mdx
index 05438c8a..ff524757 100644
--- a/static/language/ledger-adt.mdx
+++ b/docs/compact/reference/ledger-adt.mdx
@@ -1,6 +1,6 @@
 # Ledger data types
 
-Compact language version 0.21.0, compiler version 0.29.0.
+Compact language version 0.21.0, compiler version 0.29.101.
 
 ## Kernel
 
@@ -474,7 +474,7 @@ Iterates over the entries in this List.
 
 ## MerkleTree\<nat, value_type>
 
-This ADT is a bounded Merkle tree of depth nat where 2 <= nat <= 32 containing values of type value_type.
+This ADT is a bounded Merkle tree of depth nat where 2 `<=` nat `<= 32` containing values of type value_type.
 
 ### checkRoot
 
@@ -586,7 +586,7 @@ Retrieves the root of the Merkle tree. MerkleTreeDigest is defined in compact-ru
 
 ## HistoricMerkleTree\<nat, value_type>
 
-This ADT is a bounded Merkle tree of depth nat where 2 <= nat <= 32 containing values of type value_type, with history.
+This ADT is a bounded Merkle tree of depth nat where 2 `<=` nat `<=` 32 containing values of type value_type, with history.
 
 ### checkRoot
 
diff --git a/sidebars.compact.js b/sidebars.compact.js
index ae5cd48d..76ce89c8 100644
--- a/sidebars.compact.js
+++ b/sidebars.compact.js
@@ -10,7 +10,7 @@ const sidebars = {
         "writing",               // docs/develop/reference/compact/writing.md(x)
         "lang-ref",              // docs/develop/reference/compact/lang-ref.md(x)
         "compact-grammar",       // docs/develop/reference/compact/compact-grammar.md(x)
-        "all-keywords",          // docs/develop/reference/compact/all-keywords.md(x)
+        "compact-keywords",      // docs/develop/reference/compact/compact-keywords.md(x)
         "ledger-adt",            // docs/develop/reference/compact/ledger-adt.md(x)
         "opaque_data",           // docs/develop/reference/compact/opaque_data.md(x)
         "explicit-disclosure",   // docs/develop/reference/compact/explicit-disclosure.md(x)
diff --git a/src/css/custom.css b/src/css/custom.css
index 35a5a5f0..fbc9ee72 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -484,7 +484,6 @@ a:hover {
 code {
   font-family: var(--ifm-font-family-monospace);
   font-variant-ligatures: none;
-  word-break: break-all;
   overflow-wrap: break-word;
   white-space: pre-wrap;
   vertical-align: baseline !important;
diff --git a/static/language/all-keywords.html b/static/language/all-keywords.html
deleted file mode 100644
index d648abd7..00000000
--- a/static/language/all-keywords.html
+++ /dev/null
@@ -1,104 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <meta charset="UTF-8">
-  <title>Keywords</title>
-</head>
-<body>
-  <h1>Keywords</h1>
-    <h2>keywordBoolean</h2>
-    <p>Boolean literal values.</p>
-    <ul>
-        <li>false</li>
-        <li>true</li>
-    </ul>
-    <h2>keywordImport</h2>
-    <p>Keywords related to the module system.</p>
-    <ul>
-        <li>export</li>
-        <li>from</li>
-        <li>import</li>
-        <li>module</li>
-    </ul>
-    <h2>keywordControl</h2>
-    <p>Keywords used in control flow and declarations.</p>
-    <ul>
-        <li>as</li>
-        <li>assert</li>
-        <li>circuit</li>
-        <li>const</li>
-        <li>constructor</li>
-        <li>contract</li>
-        <li>default</li>
-        <li>disclose</li>
-        <li>else</li>
-        <li>enum</li>
-        <li>fold</li>
-        <li>for</li>
-        <li>if</li>
-        <li>include</li>
-        <li>ledger</li>
-        <li>map</li>
-        <li>new</li>
-        <li>of</li>
-        <li>pad</li>
-        <li>pragma</li>
-        <li>prefix</li>
-        <li>pure</li>
-        <li>return</li>
-        <li>sealed</li>
-        <li>slice</li>
-        <li>struct</li>
-        <li>type</li>
-        <li>witness</li>
-    </ul>
-    <h2>keywordDataTypes</h2>
-    <p>Built-in data type keywords.</p>
-    <ul>
-        <li>Boolean</li>
-        <li>Bytes</li>
-        <li>Field</li>
-        <li>Opaque</li>
-        <li>Uint</li>
-        <li>Vector</li>
-    </ul>
-    <h2>keywordReservedForFutureUse</h2>
-    <p>Reserved keywords that may be used in future versions of the language. Using these as identifiers is not allowed.</p>
-    <ul>
-        <li>await</li>
-        <li>break</li>
-        <li>case</li>
-        <li>catch</li>
-        <li>class</li>
-        <li>continue</li>
-        <li>debugger</li>
-        <li>delete</li>
-        <li>do</li>
-        <li>extends</li>
-        <li>finally</li>
-        <li>function</li>
-        <li>implements</li>
-        <li>in</li>
-        <li>instanceof</li>
-        <li>interface</li>
-        <li>let</li>
-        <li>null</li>
-        <li>package</li>
-        <li>private</li>
-        <li>protected</li>
-        <li>public</li>
-        <li>static</li>
-        <li>super</li>
-        <li>switch</li>
-        <li>this</li>
-        <li>throw</li>
-        <li>try</li>
-        <li>typeof</li>
-        <li>var</li>
-        <li>void</li>
-        <li>while</li>
-        <li>with</li>
-        <li>yield</li>
-    </ul>
-</body>
-</html>
diff --git a/static/language/compact.html b/static/language/compact.html
index 8b038236..c243b726 100644
--- a/static/language/compact.html
+++ b/static/language/compact.html
@@ -6,7 +6,7 @@
 </head>
 <h1>Compact Grammar</h1>
 <p>Compact language version 0.21.0.
-</p><p>Notational note: In the grammar productions below, ellipses are used to specify repetition. The notation <em>X</em> ... <em>X</em>, where <em>X</em> is a grammar symbol, represents zero or more occurrences of <em>X</em>. The notation <em>X</em> <em>s</em> ... <em>s</em> <em>X</em>, where <em>X</em> is a grammar symbol and <em>s</em> is a separator such as a comma or or semicolon, represents zero or more occurrences of <em>X</em> separated by <em>s</em>. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one <em>X</em>. When such a sequence is followed by <em>s</em><sup>opt</sup>, an optional trailing separator is allowed, but only if there is at least one <em>X</em>. For example, id &mldr; id represents zero or more ids, and expr , &mldr;&sup1; , expr ,<sup>opt</sup> represents one or more comma-separated exprs possibly followed by an extra comma.
+</p><p>Notational note: In the grammar productions below, ellipses are used to specify repetition. The notation <em>X</em> ... <em>X</em>, where <em>X</em> is a grammar symbol, represents zero or more occurrences of <em>X</em>. The notation <em>X</em> <b><tt>,</tt></b> ... <b><tt>,</tt></b> <em>X</em>, where <em>X</em> is a grammar symbol and <b><tt>,</tt></b> is a separator, represents zero or more occurrences of <em>X</em> separated by <b><tt>,</tt></b>. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one <em>X</em>. When such a sequence is followed by <em>,</em><sup>opt</sup>, an optional trailing separator is allowed, but only if there is at least one <em>X</em>. For example, <em>id</em> &mldr; <em>id</em> represents zero or more <em>id</em>s, and <em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup> represents one or more comma-separated <em>expr</em>s possibly followed by an extra comma. There are two separators: comma and semicolon.
 </p><h4><a name=end-of-file>end-of-file <span style="font-weight: normal">(<em>eof</em>)</span></a></h4>
 <p>end of file
 </p><h4><a name=identifier>identifier <span style="font-weight: normal">(<em>id</em>, <em>module-name</em>, <em>function-name</em>, <em>struct-name</em>, <em>enum-name</em>, <em>contract-name</em>, <em>tvar-name</em>, <em>type-name</em>)</span></a></h4>
@@ -19,33 +19,33 @@ <h1>Compact Grammar</h1>
 <p>a version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2.3, representing major, minor, and bugfix versions
 </p><h4><a name=Compact>Compact <span style="font-weight: normal">(<em>program</em>)</span></a></h4>
 <table><tr><td><em>program</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Program-element"><em>pelt</em></a> &mldr; <a href="#Program-element"><em>pelt</em></a>&nbsp;&nbsp;<a href="#end-of-file"><em>eof</em></a></td></tr></table><h4><a name=Program-element>Program-element <span style="font-weight: normal">(<em>pelt</em>)</span></a></h4>
-<table><tr><td><em>pelt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Pragma"><em>pragma</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Include"><em>incld</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Module-definition"><em>mdefn</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Import-declaration"><em>idecl</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Export-declaration"><em>xdecl</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Ledger-declaration"><em>ldecl</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Constructor"><em>lconstructor</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Circuit-definition"><em>cdefn</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Witness-declaration"><em>wdecl</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#External-contract-declaration"><em>ecdecl</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Structure-definition"><em>struct</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Enum-definition"><em>enumdef</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Type-definition"><em>tdefn</em></a></td></tr></table><h4><a name=Pragma>Pragma <span style="font-weight: normal">(<em>pragma</em>)</span></a></h4>
-<table><tr><td><em>pragma</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>pragma</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Version-expression"><em>version-expr</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Version-expression>Version-expression <span style="font-weight: normal">(<em>version-expr</em>)</span></a></h4>
+<table><tr><td><em>pelt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Pragma"><em>pragma-form</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Module-definition"><em>module-definition</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Import-declaration"><em>import-form</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Export-declaration"><em>export-form</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Include"><em>include-form</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Structure-declaration"><em>struct-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Enum-declaration"><em>enum-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#External-contract-declaration"><em>contract-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Type-declaration"><em>type-alias-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Ledger-declaration"><em>ledger-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Witness-declaration"><em>witness-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Constructor"><em>constructor-definition</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Circuit-definition"><em>circuit-definition</em></a></td></tr></table><h4><a name=Pragma>Pragma <span style="font-weight: normal">(<em>pragma-form</em>)</span></a></h4>
+<table><tr><td><em>pragma-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>pragma</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Version-expression"><em>version-expr</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Version-expression>Version-expression <span style="font-weight: normal">(<em>version-expr</em>)</span></a></h4>
 <table><tr><td><em>version-expr</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Version-expression"><em>version-expr</em></a>&nbsp;&nbsp;<b><tt>||</tt></b>&nbsp;&nbsp;<a href="#Version-expression0"><em>version-expr<sub>0</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Version-expression0"><em>version-expr<sub>0</sub></em></a></td></tr></table><h4><a name=Version-expression0>Version-expression<sub>0</sub> <span style="font-weight: normal">(<em>version-expr<sub>0</sub></em>)</span></a></h4>
 <table><tr><td><em>version-expr<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Version-expression0"><em>version-expr<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>&&</tt></b>&nbsp;&nbsp;<a href="#Version-Term"><em>version-term</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Version-Term"><em>version-term</em></a></td></tr></table><h4><a name=Version-Term>Version-Term <span style="font-weight: normal">(<em>version-term</em>)</span></a></h4>
 <table><tr><td><em>version-term</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt><=</tt></b>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>>=</tt></b>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Version-expression"><em>version-expr</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></table><h4><a name=Version-atom>Version-atom <span style="font-weight: normal">(<em>version-atom</em>)</span></a></h4>
-<table><tr><td><em>version-atom</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#version-literal"><em>version</em></a></td></tr></table><h4><a name=Include>Include <span style="font-weight: normal">(<em>incld</em>)</span></a></h4>
-<table><tr><td><em>incld</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>include</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>file</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Module-definition>Module-definition <span style="font-weight: normal">(<em>mdefn</em>)</span></a></h4>
-<table><tr><td><em>mdefn</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>module</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>module-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Program-element"><em>pelt</em></a> &mldr; <a href="#Program-element"><em>pelt</em></a>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></table><h4><a name=Generic-parameter-list>Generic-parameter-list <span style="font-weight: normal">(<em>gparams</em>)</span></a></h4>
+<table><tr><td><em>version-atom</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#version-literal"><em>version</em></a></td></tr></table><h4><a name=Include>Include <span style="font-weight: normal">(<em>include-form</em>)</span></a></h4>
+<table><tr><td><em>include-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>include</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>file</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Module-definition>Module-definition <span style="font-weight: normal">(<em>module-definition</em>)</span></a></h4>
+<table><tr><td><em>module-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>module</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>module-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Program-element"><em>pelt</em></a> &mldr; <a href="#Program-element"><em>pelt</em></a>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></table><h4><a name=Generic-parameter-list>Generic-parameter-list <span style="font-weight: normal">(<em>gparams</em>)</span></a></h4>
 <table><tr><td><em>gparams</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Generic-parameter"><em>generic-param</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Generic-parameter"><em>generic-param</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr></table><h4><a name=Generic-parameter>Generic-parameter <span style="font-weight: normal">(<em>generic-param</em>)</span></a></h4>
-<table><tr><td><em>generic-param</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>#</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr></table><h4><a name=Import-declaration>Import-declaration <span style="font-weight: normal">(<em>idecl</em>)</span></a></h4>
-<table><tr><td><em>idecl</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>import</tt></b>&nbsp;&nbsp;<a href="#Import-selection"><em>import-selection</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Import-name"><em>import-name</em></a>&nbsp;&nbsp;<a href="#Generic-argument-list"><em>gargs</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Import-prefix"><em>import-prefix</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Import-selection>Import-selection <span style="font-weight: normal">(<em>import-selection</em>)</span></a></h4>
+<table><tr><td><em>generic-param</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>#</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr></table><h4><a name=Import-declaration>Import-declaration <span style="font-weight: normal">(<em>import-form</em>)</span></a></h4>
+<table><tr><td><em>import-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>import</tt></b>&nbsp;&nbsp;<a href="#Import-selection"><em>import-selection</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Import-name"><em>import-name</em></a>&nbsp;&nbsp;<a href="#Generic-argument-list"><em>gargs</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Import-prefix"><em>import-prefix</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Import-selection>Import-selection <span style="font-weight: normal">(<em>import-selection</em>)</span></a></h4>
 <table><tr><td><em>import-selection</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Import-element"><em>import-element</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Import-element"><em>import-element</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>from</tt></b></td></tr></table><h4><a name=Import-element>Import-element <span style="font-weight: normal">(<em>import-element</em>)</span></a></h4>
 <table><tr><td><em>import-element</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></table><h4><a name=Import-name>Import-name <span style="font-weight: normal">(<em>import-name</em>)</span></a></h4>
 <table><tr><td><em>import-name</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#string-literal"><em>file</em></a></td></tr></table><h4><a name=Import-prefix>Import-prefix <span style="font-weight: normal">(<em>import-prefix</em>)</span></a></h4>
 <table><tr><td><em>import-prefix</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>prefix</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></table><h4><a name=Generic-argument-list>Generic-argument-list <span style="font-weight: normal">(<em>gargs</em>)</span></a></h4>
 <table><tr><td><em>gargs</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Generic-argument"><em>garg</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Generic-argument"><em>garg</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr></table><h4><a name=Generic-argument>Generic-argument <span style="font-weight: normal">(<em>garg</em>)</span></a></h4>
-<table><tr><td><em>garg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Export-declaration>Export-declaration <span style="font-weight: normal">(<em>xdecl</em>)</span></a></h4>
-<table><tr><td><em>xdecl</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=Ledger-declaration>Ledger-declaration <span style="font-weight: normal">(<em>ldecl</em>)</span></a></h4>
-<table><tr><td><em>ldecl</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>sealed</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Constructor>Constructor <span style="font-weight: normal">(<em>lconstructor</em>)</span></a></h4>
-<table><tr><td><em>lconstructor</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>constructor</tt></b>&nbsp;&nbsp;<a href="#Pattern-parameter-list"><em>pattern-parameter-list</em></a>&nbsp;&nbsp;<a href="#Block"><em>block</em></a></td></tr></table><h4><a name=Circuit-definition>Circuit-definition <span style="font-weight: normal">(<em>cdefn</em>)</span></a></h4>
-<table><tr><td><em>cdefn</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>function-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Pattern-parameter-list"><em>pattern-parameter-list</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<a href="#Block"><em>block</em></a></td></tr></table><h4><a name=Witness-declaration>Witness-declaration <span style="font-weight: normal">(<em>wdecl</em>)</span></a></h4>
-<table><tr><td><em>wdecl</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>witness</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Simple-parameter-list"><em>simple-parameter-list</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=External-contract-declaration>External-contract-declaration <span style="font-weight: normal">(<em>ecdecl</em>)</span></a></h4>
-<table><tr><td><em>ecdecl</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>contract</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>contract-name</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#External-contract-circuit"><em>ecdecl-circuit</em></a> <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> <a href="#External-contract-circuit"><em>ecdecl-circuit</em></a> <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>contract</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>contract-name</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#External-contract-circuit"><em>ecdecl-circuit</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#External-contract-circuit"><em>ecdecl-circuit</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=External-contract-circuit>External-contract-circuit <span style="font-weight: normal">(<em>ecdecl-circuit</em>)</span></a></h4>
-<table><tr><td><em>ecdecl-circuit</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Simple-parameter-list"><em>simple-parameter-list</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Structure-definition>Structure-definition <span style="font-weight: normal">(<em>struct</em>)</span></a></h4>
-<table><tr><td><em>struct</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> <a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=Enum-definition>Enum-definition <span style="font-weight: normal">(<em>enumdef</em>)</span></a></h4>
-<table><tr><td><em>enumdef</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>enum</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>enum-name</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=Type-definition>Type-definition <span style="font-weight: normal">(<em>tdefn</em>)</span></a></h4>
-<table><tr><td><em>tdefn</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>new</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>type</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>type-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Typed-identifier>Typed-identifier <span style="font-weight: normal">(<em>typed-identifier</em>)</span></a></h4>
+<table><tr><td><em>garg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Export-declaration>Export-declaration <span style="font-weight: normal">(<em>export-form</em>)</span></a></h4>
+<table><tr><td><em>export-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=Ledger-declaration>Ledger-declaration <span style="font-weight: normal">(<em>ledger-declaration</em>)</span></a></h4>
+<table><tr><td><em>ledger-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>sealed</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Witness-declaration>Witness-declaration <span style="font-weight: normal">(<em>witness-declaration</em>)</span></a></h4>
+<table><tr><td><em>witness-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>witness</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Simple-parameter-list"><em>simple-parameter-list</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Constructor>Constructor <span style="font-weight: normal">(<em>constructor-definition</em>)</span></a></h4>
+<table><tr><td><em>constructor-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>constructor</tt></b>&nbsp;&nbsp;<a href="#Pattern-parameter-list"><em>pattern-parameter-list</em></a>&nbsp;&nbsp;<a href="#Block"><em>block</em></a></td></tr></table><h4><a name=Circuit-definition>Circuit-definition <span style="font-weight: normal">(<em>circuit-definition</em>)</span></a></h4>
+<table><tr><td><em>circuit-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>function-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Pattern-parameter-list"><em>pattern-parameter-list</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<a href="#Block"><em>block</em></a></td></tr></table><h4><a name=Structure-declaration>Structure-declaration <span style="font-weight: normal">(<em>struct-declaration</em>)</span></a></h4>
+<table><tr><td><em>struct-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> <a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=Enum-declaration>Enum-declaration <span style="font-weight: normal">(<em>enum-declaration</em>)</span></a></h4>
+<table><tr><td><em>enum-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>enum</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>enum-name</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=External-contract-declaration>External-contract-declaration <span style="font-weight: normal">(<em>contract-declaration</em>)</span></a></h4>
+<table><tr><td><em>contract-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>contract</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>contract-name</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#External-contract-circuit"><em>circuit-declaration</em></a> <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> <a href="#External-contract-circuit"><em>circuit-declaration</em></a> <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>contract</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>contract-name</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#External-contract-circuit"><em>circuit-declaration</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#External-contract-circuit"><em>circuit-declaration</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=External-contract-circuit>External-contract-circuit <span style="font-weight: normal">(<em>circuit-declaration</em>)</span></a></h4>
+<table><tr><td><em>circuit-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Simple-parameter-list"><em>simple-parameter-list</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Type-declaration>Type-declaration <span style="font-weight: normal">(<em>type-alias-declaration</em>)</span></a></h4>
+<table><tr><td><em>type-alias-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>new</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>type</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>type-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Typed-identifier>Typed-identifier <span style="font-weight: normal">(<em>typed-identifier</em>)</span></a></h4>
 <table><tr><td><em>typed-identifier</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Simple-parameter-list>Simple-parameter-list <span style="font-weight: normal">(<em>simple-parameter-list</em>)</span></a></h4>
 <table><tr><td><em>simple-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></table><h4><a name=Typed-pattern>Typed-pattern <span style="font-weight: normal">(<em>typed-pattern</em>)</span></a></h4>
 <table><tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Pattern"><em>pattern</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Pattern-parameter-list>Pattern-parameter-list <span style="font-weight: normal">(<em>pattern-parameter-list</em>)</span></a></h4>
@@ -55,9 +55,8 @@ <h1>Compact Grammar</h1>
 <table><tr><td><em>tsize</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></table><h4><a name=Block>Block <span style="font-weight: normal">(<em>block</em>)</span></a></h4>
 <table><tr><td><em>block</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a> &mldr; <a href="#Statement"><em>stmt</em></a>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></table><h4><a name=Statement>Statement <span style="font-weight: normal">(<em>stmt</em>)</span></a></h4>
 <table><tr><td><em>stmt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Statement0"><em>stmt<sub>0</sub></em></a></td></tr></table><h4><a name=Statement0>Statement<sub>0</sub> <span style="font-weight: normal">(<em>stmt<sub>0</sub></em>)</span></a></h4>
-<table><tr><td><em>stmt<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement0"><em>stmt<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>else</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#Const-Binding"><em>cbinding</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#Const-Binding"><em>cbinding</em></a> &nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Block"><em>block</em></a></td></tr></table><h4><a name=Pattern>Pattern <span style="font-weight: normal">(<em>pattern</em>)</span></a></h4>
-<table><tr><td><em>pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Pattern"><em>pattern</em></a><sup>opt</sup> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Pattern"><em>pattern</em></a><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Pattern-struct-element"><em>pattern-struct-elt</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Pattern-struct-element"><em>pattern-struct-elt</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></table><h4><a name=Pattern-tuple-element>Pattern-tuple-element <span style="font-weight: normal">(<em>pattern-tuple-elt</em>)</span></a></h4>
-<table><tr><td><em>pattern-tuple-elt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;(<em>empty</em>)</td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Pattern"><em>pattern</em></a></td></tr></table><h4><a name=Pattern-struct-element>Pattern-struct-element <span style="font-weight: normal">(<em>pattern-struct-elt</em>)</span></a></h4>
+<table><tr><td><em>stmt<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#Const-Binding"><em>cbinding</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#Const-Binding"><em>cbinding</em></a> &nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement0"><em>stmt<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>else</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Block"><em>block</em></a></td></tr></table><h4><a name=Pattern>Pattern <span style="font-weight: normal">(<em>pattern</em>)</span></a></h4>
+<table><tr><td><em>pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Pattern"><em>pattern</em></a><sup>opt</sup> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Pattern"><em>pattern</em></a><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Pattern-struct-element"><em>pattern-struct-elt</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Pattern-struct-element"><em>pattern-struct-elt</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></table><h4><a name=Pattern-struct-element>Pattern-struct-element <span style="font-weight: normal">(<em>pattern-struct-elt</em>)</span></a></h4>
 <table><tr><td><em>pattern-struct-elt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Pattern"><em>pattern</em></a></td></tr></table><h4><a name=Expression-sequence>Expression-sequence <span style="font-weight: normal">(<em>expr-seq</em>)</span></a></h4>
 <table><tr><td><em>expr-seq</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> &nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr></table><h4><a name=Expression>Expression <span style="font-weight: normal">(<em>expr</em>)</span></a></h4>
 <table><tr><td><em>expr</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression0"><em>expr<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>?</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression0"><em>expr<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression0"><em>expr<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>+=</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression0"><em>expr<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>-=</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression0"><em>expr<sub>0</sub></em></a></td></tr></table><h4><a name=Expression0>Expression<sub>0</sub> <span style="font-weight: normal">(<em>expr<sub>0</sub></em>)</span></a></h4>
@@ -70,9 +69,9 @@ <h1>Compact Grammar</h1>
 <table><tr><td><em>expr<sub>6</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression6"><em>expr<sub>6</sub></em></a>&nbsp;&nbsp;<b><tt>*</tt></b>&nbsp;&nbsp;<a href="#Expression7"><em>expr<sub>7</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression7"><em>expr<sub>7</sub></em></a></td></tr></table><h4><a name=Expression7>Expression<sub>7</sub> <span style="font-weight: normal">(<em>expr<sub>7</sub></em>)</span></a></h4>
 <table><tr><td><em>expr<sub>7</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<a href="#Expression7"><em>expr<sub>7</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression8"><em>expr<sub>8</sub></em></a></td></tr></table><h4><a name=Expression8>Expression<sub>8</sub> <span style="font-weight: normal">(<em>expr<sub>8</sub></em>)</span></a></h4>
 <table><tr><td><em>expr<sub>8</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression8"><em>expr<sub>8</sub></em></a>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression8"><em>expr<sub>8</sub></em></a>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression8"><em>expr<sub>8</sub></em></a>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression9"><em>expr<sub>9</sub></em></a></td></tr></table><h4><a name=Expression9>Expression<sub>9</sub> <span style="font-weight: normal">(<em>expr<sub>9</sub></em>)</span></a></h4>
-<table><tr><td><em>expr<sub>9</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Function"><em>fun</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>map</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Function"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>fold</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Function"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>slice</tt></b>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Type-size"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Tuple-argument"><em>tuple-arg</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Tuple-argument"><em>tuple-arg</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Tuple-argument"><em>bytes-arg</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Tuple-argument"><em>bytes-arg</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Type-reference"><em>tref</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Structure-argument"><em>struct-arg</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Structure-argument"><em>struct-arg</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>assert</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>disclose</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Term"><em>term</em></a></td></tr></table><h4><a name=Term>Term <span style="font-weight: normal">(<em>term</em>)</span></a></h4>
+<table><tr><td><em>expr<sub>9</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Function"><em>fun</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>map</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Function"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>fold</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Function"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>slice</tt></b>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Type-size"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Tuple-argument"><em>tuple-arg</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Tuple-argument"><em>tuple-arg</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Tuple-argument"><em>tuple-arg</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Tuple-argument"><em>tuple-arg</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Type-reference"><em>tref</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Structure-argument"><em>struct-arg</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Structure-argument"><em>struct-arg</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>assert</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>disclose</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Term"><em>term</em></a></td></tr></table><h4><a name=Term>Term <span style="font-weight: normal">(<em>term</em>)</span></a></h4>
 <table><tr><td><em>term</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>true</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>false</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>pad</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>default</tt></b>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></table><h4><a name=Tuple-argument>Tuple-argument <span style="font-weight: normal">(<em>tuple-arg</em>, <em>bytes-arg</em>)</span></a></h4>
-<table><tr><td><em>tuple-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr></table><h4><a name=Structure-argument>Structure-argument <span style="font-weight: normal">(<em>struct-arg</em>)</span></a></h4>
+<table><tr><td><em>tuple-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td><em>bytes-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>tuple-arg</em></td></tr></table><h4><a name=Structure-argument>Structure-argument <span style="font-weight: normal">(<em>struct-arg</em>)</span></a></h4>
 <table><tr><td><em>struct-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr></table><h4><a name=Function>Function <span style="font-weight: normal">(<em>fun</em>)</span></a></h4>
 <table><tr><td><em>fun</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Generic-argument-list"><em>gargs</em></a><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Arrow-parameter-list"><em>arrow-parameter-list</em></a>&nbsp;&nbsp;<a href="#Return-type"><em>return-type</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>=></tt></b>&nbsp;&nbsp;<a href="#Block"><em>block</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Arrow-parameter-list"><em>arrow-parameter-list</em></a>&nbsp;&nbsp;<a href="#Return-type"><em>return-type</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>=></tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Function"><em>fun</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></table><h4><a name=Return-type>Return-type <span style="font-weight: normal">(<em>return-type</em>)</span></a></h4>
 <table><tr><td><em>return-type</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Optionally-typed-pattern>Optionally-typed-pattern <span style="font-weight: normal">(<em>optionally-typed-pattern</em>)</span></a></h4>

From 4857655e51f39b79bda2830890642d983ed7580a Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Mon, 9 Mar 2026 18:40:33 +0100
Subject: [PATCH 02/41] first cut at markdown version of compact-grammar.mdx
 along with corresponding changes to custom.css

---
 docs/compact/reference/compact-grammar.mdx | 484 ++++++++++++++++++++-
 src/css/custom.css                         |   9 +-
 static/language/compact.html               |  81 ----
 3 files changed, 483 insertions(+), 91 deletions(-)
 delete mode 100644 static/language/compact.html

diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index f8f35f2b..35530c4b 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -1,12 +1,478 @@
----
-SPDX-License-Identifier: Apache-2.0
-copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
-title: Formal grammar
-sidebar_position: 15
----
 
-# Formal grammar
 
-import Iframe from "@site/src/components/IFrame/Iframe";
 
-<Iframe src="/language/compact.html" />
+
+
+# Compact Grammar
+
+Compact language version 0.21.0.
+
+Notational note: In the grammar productions below, ellipses are used to specify repetition. The notation <em>X</em> ... <em>X</em>, where <em>X</em> is a grammar symbol, represents zero or more occurrences of <em>X</em>. The notation <em>X</em> <b><tt>,</tt></b> ... <b><tt>,</tt></b> <em>X</em>, where <em>X</em> is a grammar symbol and <b><tt>,</tt></b> is a separator, represents zero or more occurrences of <em>X</em> separated by <b><tt>,</tt></b>. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one <em>X</em>. When such a sequence is followed by <em>,</em><sup>opt</sup>, an optional trailing separator is allowed, but only if there is at least one <em>X</em>. For example, <em>id</em> &mldr; <em>id</em> represents zero or more <em>id</em>s, and <em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup> represents one or more comma-separated <em>expr</em>s possibly followed by an extra comma. There are two separators: comma and semicolon.
+### end-of-file (*eof*)
+
+end of file
+### identifier (*id*, *module-name*, *function-name*, *struct-name*, *enum-name*, *contract-name*, *tvar-name*, *type-name*)
+
+identifiers have the same syntax as Typescript identifiers
+### field-literal (*nat*)
+
+a field literal is 0 or a natural number formed from a sequence of digits starting with 1-9, e.g. 723, whose value does not exceed the maximum field value
+### string-literal (*str*, *file*)
+
+a string literal has the same syntax as a Typescript string
+### version-literal (*version*)
+
+a version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2.3, representing major, minor, and bugfix versions
+### Compact  (**program**)
+<div className="lang-ref-table">
+|                 |        |                                                   |
+|-----------------|--------|---------------------------------------------------|
+| *program*&nbsp; | &rarr; | &nbsp;&nbsp;*pelt* &mldr; *pelt*&nbsp;&nbsp;*eof* |
+</div>
+### Program-element  (**pelt**)
+<div className="lang-ref-table">
+|              |        |                                      |
+|--------------|--------|--------------------------------------|
+| *pelt*&nbsp; | &rarr; | &nbsp;&nbsp;*pragma-form*            |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*module-definition*      |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*import-form*            |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*export-form*            |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*include-form*           |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*struct-declaration*     |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*enum-declaration*       |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*contract-declaration*   |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*type-alias-declaration* |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*ledger-declaration*     |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*witness-declaration*    |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*constructor-definition* |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*circuit-definition*     |
+</div>
+### Pragma  (**pragma-form**)
+<div className="lang-ref-table">
+|                     |        |                                                                                                           |
+|---------------------|--------|-----------------------------------------------------------------------------------------------------------|
+| *pragma-form*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>pragma</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;*version-expr*&nbsp;&nbsp;<b><tt>;</tt></b> |
+</div>
+### Version-expression  (**version-expr**)
+<div className="lang-ref-table">
+|                      |        |                                                                                                  |
+|----------------------|--------|--------------------------------------------------------------------------------------------------|
+| *version-expr*&nbsp; | &rarr; | &nbsp;&nbsp;*version-expr*&nbsp;&nbsp;<b><tt>\|\|</tt></b>&nbsp;&nbsp;*version-expr<sub>0</sub>* |
+| &nbsp;               | &rarr; | &nbsp;&nbsp;*version-expr<sub>0</sub>*                                                           |
+</div>
+### Version-expression<sub>0</sub>  (**version-expr<sub>0</sub>**)
+<div className="lang-ref-table">
+|                                  |        |                                                                                                        |
+|----------------------------------|--------|--------------------------------------------------------------------------------------------------------|
+| *version-expr<sub>0</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*version-expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>&amp;&amp;</tt></b>&nbsp;&nbsp;*version-term* |
+| &nbsp;                           | &rarr; | &nbsp;&nbsp;*version-term*                                                                             |
+</div>
+### Version-Term  (**version-term**)
+<div className="lang-ref-table">
+|                      |        |                                                                                      |
+|----------------------|--------|--------------------------------------------------------------------------------------|
+| *version-term*&nbsp; | &rarr; | &nbsp;&nbsp;*version-atom*                                                           |
+| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;*version-atom*                              |
+| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*version-atom*                           |
+| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>&lt;=</tt></b>&nbsp;&nbsp;*version-atom*                          |
+| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>&gt;=</tt></b>&nbsp;&nbsp;*version-atom*                          |
+| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>&gt;</tt></b>&nbsp;&nbsp;*version-atom*                           |
+| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*version-expr*&nbsp;&nbsp;<b><tt>)</tt></b> |
+</div>
+### Version-atom  (**version-atom**)
+<div className="lang-ref-table">
+|                      |        |                       |
+|----------------------|--------|-----------------------|
+| *version-atom*&nbsp; | &rarr; | &nbsp;&nbsp;*nat*     |
+| &nbsp;               | &rarr; | &nbsp;&nbsp;*version* |
+</div>
+### Include  (**include-form**)
+<div className="lang-ref-table">
+|                      |        |                                                                                    |
+|----------------------|--------|------------------------------------------------------------------------------------|
+| *include-form*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>include</tt></b>&nbsp;&nbsp;*file*&nbsp;&nbsp;<b><tt>;</tt></b> |
+</div>
+### Module-definition  (**module-definition**)
+<div className="lang-ref-table">
+|                           |        |                                                                                                                                                                                                                                           |
+|---------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *module-definition*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>module</tt></b>&nbsp;&nbsp;*module-name*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*pelt* &mldr; *pelt*&nbsp;&nbsp;<b><tt>}</tt></b> |
+</div>
+### Generic-parameter-list  (**gparams**)
+<div className="lang-ref-table">
+|                 |        |                                                                                                                                                                                        |
+|-----------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *gparams*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*generic-param* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *generic-param* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>&gt;</tt></b> |
+</div>
+### Generic-parameter  (**generic-param**)
+<div className="lang-ref-table">
+|                       |        |                                                      |
+|-----------------------|--------|------------------------------------------------------|
+| *generic-param*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>#</tt></b>&nbsp;&nbsp;*tvar-name* |
+| &nbsp;                | &rarr; | &nbsp;&nbsp;*tvar-name*                              |
+</div>
+### Import-declaration  (**import-form**)
+<div className="lang-ref-table">
+|                     |        |                                                                                                                                                                                                                |
+|---------------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *import-form*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>import</tt></b>&nbsp;&nbsp;*import-selection*<sup>opt</sup>&nbsp;&nbsp;*import-name*&nbsp;&nbsp;*gargs*<sup>opt</sup>&nbsp;&nbsp;*import-prefix*<sup>opt</sup>&nbsp;&nbsp;<b><tt>;</tt></b> |
+</div>
+### Import-selection  (**import-selection**)
+<div className="lang-ref-table">
+|                          |        |                                                                                                                                                                                                                     |
+|--------------------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *import-selection*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*import-element* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *import-element* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>from</tt></b> |
+</div>
+### Import-element  (**import-element**)
+<div className="lang-ref-table">
+|                        |        |                                                                |
+|------------------------|--------|----------------------------------------------------------------|
+| *import-element*&nbsp; | &rarr; | &nbsp;&nbsp;*id*                                               |
+| &nbsp;                 | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;*id* |
+</div>
+### Import-name  (**import-name**)
+<div className="lang-ref-table">
+|                     |        |                    |
+|---------------------|--------|--------------------|
+| *import-name*&nbsp; | &rarr; | &nbsp;&nbsp;*id*   |
+| &nbsp;              | &rarr; | &nbsp;&nbsp;*file* |
+</div>
+### Import-prefix  (**import-prefix**)
+<div className="lang-ref-table">
+|                       |        |                                                    |
+|-----------------------|--------|----------------------------------------------------|
+| *import-prefix*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>prefix</tt></b>&nbsp;&nbsp;*id* |
+</div>
+### Generic-argument-list  (**gargs**)
+<div className="lang-ref-table">
+|               |        |                                                                                                                                                                      |
+|---------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *gargs*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*garg* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *garg* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>&gt;</tt></b> |
+</div>
+### Generic-argument  (**garg**)
+<div className="lang-ref-table">
+|              |        |                    |
+|--------------|--------|--------------------|
+| *garg*&nbsp; | &rarr; | &nbsp;&nbsp;*nat*  |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*type* |
+</div>
+### Export-declaration  (**export-form**)
+<div className="lang-ref-table">
+|                     |        |                                                                                                                                                                                                                                          |
+|---------------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *export-form*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*id* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *id* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
+</div>
+### Ledger-declaration  (**ledger-declaration**)
+<div className="lang-ref-table">
+|                            |        |                                                                                                                                                                                                                                |
+|----------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *ledger-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>sealed</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;<b><tt>;</tt></b> |
+</div>
+### Witness-declaration  (**witness-declaration**)
+<div className="lang-ref-table">
+|                             |        |                                                                                                                                                                                                                                                       |
+|-----------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *witness-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>witness</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;*simple-parameter-list*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;<b><tt>;</tt></b> |
+</div>
+### Constructor  (**constructor-definition**)
+<div className="lang-ref-table">
+|                                |        |                                                                                                |
+|--------------------------------|--------|------------------------------------------------------------------------------------------------|
+| *constructor-definition*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>constructor</tt></b>&nbsp;&nbsp;*pattern-parameter-list*&nbsp;&nbsp;*block* |
+</div>
+### Circuit-definition  (**circuit-definition**)
+<div className="lang-ref-table">
+|                            |        |                                                                                                                                                                                                                                                                                                       |
+|----------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *circuit-definition*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;*function-name*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;*pattern-parameter-list*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;*block* |
+</div>
+### Structure-declaration  (**struct-declaration**)
+<div className="lang-ref-table">
+|                            |        |                                                                                                                                                                                                                                                                                                                                                                                  |
+|----------------------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *struct-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;*struct-name*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*typed-identifier* <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> *typed-identifier* <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
+| &nbsp;                     | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;*struct-name*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*typed-identifier* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *typed-identifier* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
+</div>
+### Enum-declaration  (**enum-declaration**)
+<div className="lang-ref-table">
+|                          |        |                                                                                                                                                                                                                                                                                                                     |
+|--------------------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *enum-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>enum</tt></b>&nbsp;&nbsp;*enum-name*&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*id* <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> *id* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
+</div>
+### External-contract-declaration  (**contract-declaration**)
+<div className="lang-ref-table">
+|                              |        |                                                                                                                                                                                                                                                                                                                                                         |
+|------------------------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *contract-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>contract</tt></b>&nbsp;&nbsp;*contract-name*&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*circuit-declaration* <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> *circuit-declaration* <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
+| &nbsp;                       | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>contract</tt></b>&nbsp;&nbsp;*contract-name*&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*circuit-declaration* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *circuit-declaration* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
+</div>
+### External-contract-circuit  (**circuit-declaration**)
+<div className="lang-ref-table">
+|                             |        |                                                                                                                                                                                     |
+|-----------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *circuit-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;*simple-parameter-list*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type* |
+</div>
+### Type-declaration  (**type-alias-declaration**)
+<div className="lang-ref-table">
+|                                |        |                                                                                                                                                                                                                                                                     |
+|--------------------------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *type-alias-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>new</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>type</tt></b>&nbsp;&nbsp;*type-name*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;<b><tt>;</tt></b> |
+</div>
+### Typed-identifier  (**typed-identifier**)
+<div className="lang-ref-table">
+|                          |        |                                                                 |
+|--------------------------|--------|-----------------------------------------------------------------|
+| *typed-identifier*&nbsp; | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type* |
+</div>
+### Simple-parameter-list  (**simple-parameter-list**)
+<div className="lang-ref-table">
+|                               |        |                                                                                                                                                                                        |
+|-------------------------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *simple-parameter-list*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*typed-identifier* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *typed-identifier* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b> |
+</div>
+### Typed-pattern  (**typed-pattern**)
+<div className="lang-ref-table">
+|                       |        |                                                                      |
+|-----------------------|--------|----------------------------------------------------------------------|
+| *typed-pattern*&nbsp; | &rarr; | &nbsp;&nbsp;*pattern*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type* |
+</div>
+### Pattern-parameter-list  (**pattern-parameter-list**)
+<div className="lang-ref-table">
+|                                |        |                                                                                                                                                                                  |
+|--------------------------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *pattern-parameter-list*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*typed-pattern* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *typed-pattern* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b> |
+</div>
+### Type  (**type**)
+<div className="lang-ref-table">
+|              |        |                                                                                                                                                                      |
+|--------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *type*&nbsp; | &rarr; | &nbsp;&nbsp;*tref*                                                                                                                                                   |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Boolean</tt></b>                                                                                                                                  |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Field</tt></b>                                                                                                                                    |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>&gt;</tt></b>                                                  |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>&gt;</tt></b> |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>&gt;</tt></b>                                                 |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Opaque</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*str*&nbsp;&nbsp;<b><tt>&gt;</tt></b>                                                  |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Vector</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;<b><tt>&gt;</tt></b> |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;*type* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *type* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b>       |
+</div>
+### Type-reference  (**tref**)
+<div className="lang-ref-table">
+|              |        |                                                   |
+|--------------|--------|---------------------------------------------------|
+| *tref*&nbsp; | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;*gargs*<sup>opt</sup> |
+</div>
+### Type-size  (**tsize**)
+<div className="lang-ref-table">
+|               |        |                   |
+|---------------|--------|-------------------|
+| *tsize*&nbsp; | &rarr; | &nbsp;&nbsp;*nat* |
+| &nbsp;        | &rarr; | &nbsp;&nbsp;*id*  |
+</div>
+### Block  (**block**)
+<div className="lang-ref-table">
+|               |        |                                                                                             |
+|---------------|--------|---------------------------------------------------------------------------------------------|
+| *block*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*stmt* &mldr; *stmt*&nbsp;&nbsp;<b><tt>}</tt></b> |
+</div>
+### Statement  (**stmt**)
+<div className="lang-ref-table">
+|              |        |                                                                                                                                  |
+|--------------|--------|----------------------------------------------------------------------------------------------------------------------------------|
+| *stmt*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;*stmt* |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*stmt<sub>0</sub>*                                                                                                   |
+</div>
+### Statement<sub>0</sub>  (**stmt<sub>0</sub>**)
+<div className="lang-ref-table">
+|                          |        |                                                                                                                                                                                                                                                            |
+|--------------------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *stmt<sub>0</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>;</tt></b>                                                                                                                                                                                                        |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;*cbinding* <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> *cbinding* &nbsp;&nbsp;<b><tt>;</tt></b>                                                                                                          |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;*stmt<sub>0</sub>*&nbsp;&nbsp;<b><tt>else</tt></b>&nbsp;&nbsp;*stmt*                                                             |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;*nat*&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;*nat*&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;*stmt* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;*stmt*                                           |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>;</tt></b>                                                                                                                                                                      |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b>                                                                                                                                                                                            |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*block*                                                                                                                                                                                                                                        |
+</div>
+### Pattern  (**pattern**)
+<div className="lang-ref-table">
+|                 |        |                                                                                                                                                                                                  |
+|-----------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *pattern*&nbsp; | &rarr; | &nbsp;&nbsp;*id*                                                                                                                                                                                 |
+| &nbsp;          | &rarr; | &nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;*pattern*<sup>opt</sup> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *pattern*<sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b> |
+| &nbsp;          | &rarr; | &nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*pattern-struct-elt* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *pattern-struct-elt* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>      |
+</div>
+### Pattern-struct-element  (**pattern-struct-elt**)
+<div className="lang-ref-table">
+|                            |        |                                                                    |
+|----------------------------|--------|--------------------------------------------------------------------|
+| *pattern-struct-elt*&nbsp; | &rarr; | &nbsp;&nbsp;*id*                                                   |
+| &nbsp;                     | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*pattern* |
+</div>
+### Expression-sequence  (**expr-seq**)
+<div className="lang-ref-table">
+|                  |        |                                                                                                                            |
+|------------------|--------|----------------------------------------------------------------------------------------------------------------------------|
+| *expr-seq*&nbsp; | &rarr; | &nbsp;&nbsp;*expr*                                                                                                         |
+| &nbsp;           | &rarr; | &nbsp;&nbsp;*expr* <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> *expr* &nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*expr* |
+</div>
+### Expression  (**expr**)
+<div className="lang-ref-table">
+|              |        |                                                                                                                              |
+|--------------|--------|------------------------------------------------------------------------------------------------------------------------------|
+| *expr*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>?</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*expr* |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;*expr*                                                |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>+=</tt></b>&nbsp;&nbsp;*expr*                                               |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>-=</tt></b>&nbsp;&nbsp;*expr*                                               |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*                                                                                               |
+</div>
+### Expression<sub>0</sub>  (**expr<sub>0</sub>**)
+<div className="lang-ref-table">
+|                          |        |                                                                                              |
+|--------------------------|--------|----------------------------------------------------------------------------------------------|
+| *expr<sub>0</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>\|\|</tt></b>&nbsp;&nbsp;*expr<sub>1</sub>* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>1</sub>*                                                               |
+</div>
+### Expression<sub>1</sub>  (**expr<sub>1</sub>**)
+<div className="lang-ref-table">
+|                          |        |                                                                                                    |
+|--------------------------|--------|----------------------------------------------------------------------------------------------------|
+| *expr<sub>1</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>1</sub>*&nbsp;&nbsp;<b><tt>&amp;&amp;</tt></b>&nbsp;&nbsp;*expr<sub>2</sub>* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>2</sub>*                                                                     |
+</div>
+### Expression<sub>2</sub>  (**expr<sub>2</sub>**)
+<div className="lang-ref-table">
+|                          |        |                                                                                            |
+|--------------------------|--------|--------------------------------------------------------------------------------------------|
+| *expr<sub>2</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>2</sub>*&nbsp;&nbsp;<b><tt>==</tt></b>&nbsp;&nbsp;*expr<sub>3</sub>* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>2</sub>*&nbsp;&nbsp;<b><tt>!=</tt></b>&nbsp;&nbsp;*expr<sub>3</sub>* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>3</sub>*                                                             |
+</div>
+### Expression<sub>3</sub>  (**expr<sub>3</sub>**)
+<div className="lang-ref-table">
+|                          |        |                                                                                               |
+|--------------------------|--------|-----------------------------------------------------------------------------------------------|
+| *expr<sub>3</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*expr<sub>4</sub>*  |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*&nbsp;&nbsp;<b><tt>&lt;=</tt></b>&nbsp;&nbsp;*expr<sub>4</sub>* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*&nbsp;&nbsp;<b><tt>&gt;=</tt></b>&nbsp;&nbsp;*expr<sub>4</sub>* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*&nbsp;&nbsp;<b><tt>&gt;</tt></b>&nbsp;&nbsp;*expr<sub>4</sub>*  |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*                                                                |
+</div>
+### Expression<sub>4</sub>  (**expr<sub>4</sub>**)
+<div className="lang-ref-table">
+|                          |        |                                                                                |
+|--------------------------|--------|--------------------------------------------------------------------------------|
+| *expr<sub>4</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;*type* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>5</sub>*                                                 |
+</div>
+### Expression<sub>5</sub>  (**expr<sub>5</sub>**)
+<div className="lang-ref-table">
+|                          |        |                                                                                           |
+|--------------------------|--------|-------------------------------------------------------------------------------------------|
+| *expr<sub>5</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>5</sub>*&nbsp;&nbsp;<b><tt>+</tt></b>&nbsp;&nbsp;*expr<sub>6</sub>* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>5</sub>*&nbsp;&nbsp;<b><tt>-</tt></b>&nbsp;&nbsp;*expr<sub>6</sub>* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>6</sub>*                                                            |
+</div>
+### Expression<sub>6</sub>  (**expr<sub>6</sub>**)
+<div className="lang-ref-table">
+|                          |        |                                                                                           |
+|--------------------------|--------|-------------------------------------------------------------------------------------------|
+| *expr<sub>6</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>6</sub>*&nbsp;&nbsp;<b><tt>*</tt></b>&nbsp;&nbsp;*expr<sub>7</sub>* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>7</sub>*                                                            |
+</div>
+### Expression<sub>7</sub>  (**expr<sub>7</sub>**)
+<div className="lang-ref-table">
+|                          |        |                                                             |
+|--------------------------|--------|-------------------------------------------------------------|
+| *expr<sub>7</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;*expr<sub>7</sub>* |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>8</sub>*                              |
+</div>
+### Expression<sub>8</sub>  (**expr<sub>8</sub>**)
+<div className="lang-ref-table">
+|                          |        |                                                                                                                                                                                                                                           |
+|--------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *expr<sub>8</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>8</sub>*&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>]</tt></b>                                                                                                                                |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>8</sub>*&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;*id*                                                                                                                                                               |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>8</sub>*&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *expr* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b> |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>9</sub>*                                                                                                                                                                                                            |
+</div>
+### Expression<sub>9</sub>  (**expr<sub>9</sub>**)
+<div className="lang-ref-table">
+|                          |        |                                                                                                                                                                                                                                                                                                   |
+|--------------------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *expr<sub>9</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*fun*&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *expr* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b>                                                                                                                   |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>map</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*fun*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*expr* <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> *expr* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b>                                                 |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>fold</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*fun*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*expr* <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> *expr* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b> |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>slice</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>&gt;</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>)</tt></b>                                                   |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;*tuple-arg* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *tuple-arg* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b>                                                                                                                          |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;*tuple-arg* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *tuple-arg* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b>                                                                                         |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*tref*&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*struct-arg* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *struct-arg* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>                                                                                                     |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>assert</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*str*&nbsp;&nbsp;<b><tt>)</tt></b>                                                                                                                                      |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>disclose</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>)</tt></b>                                                                                                                                                                                  |
+| &nbsp;                   | &rarr; | &nbsp;&nbsp;*term*                                                                                                                                                                                                                                                                                |
+</div>
+### Term  (**term**)
+<div className="lang-ref-table">
+|              |        |                                                                                                                                                          |
+|--------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *term*&nbsp; | &rarr; | &nbsp;&nbsp;*id*                                                                                                                                         |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>true</tt></b>                                                                                                                         |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>false</tt></b>                                                                                                                        |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*nat*                                                                                                                                        |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;*str*                                                                                                                                        |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>pad</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*nat*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*str*&nbsp;&nbsp;<b><tt>)</tt></b> |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>default</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;<b><tt>&gt;</tt></b>                                    |
+| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>)</tt></b>                                                                         |
+</div>
+### Tuple-argument  (**tuple-arg**, **bytes-arg**)
+<div className="lang-ref-table">
+|                   |        |                                                   |
+|-------------------|--------|---------------------------------------------------|
+| *tuple-arg*&nbsp; | &rarr; | &nbsp;&nbsp;*expr*                                |
+| &nbsp;            | &rarr; | &nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;*expr* |
+| *bytes-arg*&nbsp; | &rarr; | &nbsp;&nbsp;*tuple-arg*                           |
+</div>
+### Structure-argument  (**struct-arg**)
+<div className="lang-ref-table">
+|                    |        |                                                                 |
+|--------------------|--------|-----------------------------------------------------------------|
+| *struct-arg*&nbsp; | &rarr; | &nbsp;&nbsp;*expr*                                              |
+| &nbsp;             | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*expr* |
+| &nbsp;             | &rarr; | &nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;*expr*               |
+</div>
+### Function  (**fun**)
+<div className="lang-ref-table">
+|             |        |                                                                                                                               |
+|-------------|--------|-------------------------------------------------------------------------------------------------------------------------------|
+| *fun*&nbsp; | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;*gargs*<sup>opt</sup>                                                                             |
+| &nbsp;      | &rarr; | &nbsp;&nbsp;*arrow-parameter-list*&nbsp;&nbsp;*return-type*<sup>opt</sup>&nbsp;&nbsp;<b><tt>=&gt;</tt></b>&nbsp;&nbsp;*block* |
+| &nbsp;      | &rarr; | &nbsp;&nbsp;*arrow-parameter-list*&nbsp;&nbsp;*return-type*<sup>opt</sup>&nbsp;&nbsp;<b><tt>=&gt;</tt></b>&nbsp;&nbsp;*expr*  |
+| &nbsp;      | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*fun*&nbsp;&nbsp;<b><tt>)</tt></b>                                                   |
+</div>
+### Return-type  (**return-type**)
+<div className="lang-ref-table">
+|                     |        |                                                 |
+|---------------------|--------|-------------------------------------------------|
+| *return-type*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type* |
+</div>
+### Optionally-typed-pattern  (**optionally-typed-pattern**)
+<div className="lang-ref-table">
+|                                  |        |                             |
+|----------------------------------|--------|-----------------------------|
+| *optionally-typed-pattern*&nbsp; | &rarr; | &nbsp;&nbsp;*pattern*       |
+| &nbsp;                           | &rarr; | &nbsp;&nbsp;*typed-pattern* |
+</div>
+### Const-Binding  (**cbinding**)
+<div className="lang-ref-table">
+|                  |        |                                                                                       |
+|------------------|--------|---------------------------------------------------------------------------------------|
+| *cbinding*&nbsp; | &rarr; | &nbsp;&nbsp;*optionally-typed-pattern*&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;*expr* |
+</div>
+### Arrow-parameter-list  (**arrow-parameter-list**)
+<div className="lang-ref-table">
+|                              |        |                                                                                                                                                                                                        |
+|------------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *arrow-parameter-list*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*optionally-typed-pattern* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *optionally-typed-pattern* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b> |
+</div>
+
diff --git a/src/css/custom.css b/src/css/custom.css
index fbc9ee72..d47b7e44 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -606,7 +606,14 @@ pre {
   border-collapse: separate;
   border-spacing: 0;
   --ifm-table-stripe-background: none;
-  border: 1px solid; /* Add border to the table */
+}
+
+.lang-ref-table thead {
+  display: none
+}
+
+.lang-ref-table tbody tr {
+  border: none
 }
 
 .lang-ref-table td,
diff --git a/static/language/compact.html b/static/language/compact.html
deleted file mode 100644
index c243b726..00000000
--- a/static/language/compact.html
+++ /dev/null
@@ -1,81 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<meta http-equiv=Content-Type content="text/html;charset=utf-8">
-<title>Compact</title>
-</head>
-<h1>Compact Grammar</h1>
-<p>Compact language version 0.21.0.
-</p><p>Notational note: In the grammar productions below, ellipses are used to specify repetition. The notation <em>X</em> ... <em>X</em>, where <em>X</em> is a grammar symbol, represents zero or more occurrences of <em>X</em>. The notation <em>X</em> <b><tt>,</tt></b> ... <b><tt>,</tt></b> <em>X</em>, where <em>X</em> is a grammar symbol and <b><tt>,</tt></b> is a separator, represents zero or more occurrences of <em>X</em> separated by <b><tt>,</tt></b>. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one <em>X</em>. When such a sequence is followed by <em>,</em><sup>opt</sup>, an optional trailing separator is allowed, but only if there is at least one <em>X</em>. For example, <em>id</em> &mldr; <em>id</em> represents zero or more <em>id</em>s, and <em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup> represents one or more comma-separated <em>expr</em>s possibly followed by an extra comma. There are two separators: comma and semicolon.
-</p><h4><a name=end-of-file>end-of-file <span style="font-weight: normal">(<em>eof</em>)</span></a></h4>
-<p>end of file
-</p><h4><a name=identifier>identifier <span style="font-weight: normal">(<em>id</em>, <em>module-name</em>, <em>function-name</em>, <em>struct-name</em>, <em>enum-name</em>, <em>contract-name</em>, <em>tvar-name</em>, <em>type-name</em>)</span></a></h4>
-<p>identifiers have the same syntax as Typescript identifiers
-</p><h4><a name=field-literal>field-literal <span style="font-weight: normal">(<em>nat</em>)</span></a></h4>
-<p>a field literal is 0 or a natural number formed from a sequence of digits starting with 1-9, e.g. 723, whose value does not exceed the maximum field value
-</p><h4><a name=string-literal>string-literal <span style="font-weight: normal">(<em>str</em>, <em>file</em>)</span></a></h4>
-<p>a string literal has the same syntax as a Typescript string
-</p><h4><a name=version-literal>version-literal <span style="font-weight: normal">(<em>version</em>)</span></a></h4>
-<p>a version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2.3, representing major, minor, and bugfix versions
-</p><h4><a name=Compact>Compact <span style="font-weight: normal">(<em>program</em>)</span></a></h4>
-<table><tr><td><em>program</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Program-element"><em>pelt</em></a> &mldr; <a href="#Program-element"><em>pelt</em></a>&nbsp;&nbsp;<a href="#end-of-file"><em>eof</em></a></td></tr></table><h4><a name=Program-element>Program-element <span style="font-weight: normal">(<em>pelt</em>)</span></a></h4>
-<table><tr><td><em>pelt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Pragma"><em>pragma-form</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Module-definition"><em>module-definition</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Import-declaration"><em>import-form</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Export-declaration"><em>export-form</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Include"><em>include-form</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Structure-declaration"><em>struct-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Enum-declaration"><em>enum-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#External-contract-declaration"><em>contract-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Type-declaration"><em>type-alias-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Ledger-declaration"><em>ledger-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Witness-declaration"><em>witness-declaration</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Constructor"><em>constructor-definition</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Circuit-definition"><em>circuit-definition</em></a></td></tr></table><h4><a name=Pragma>Pragma <span style="font-weight: normal">(<em>pragma-form</em>)</span></a></h4>
-<table><tr><td><em>pragma-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>pragma</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Version-expression"><em>version-expr</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Version-expression>Version-expression <span style="font-weight: normal">(<em>version-expr</em>)</span></a></h4>
-<table><tr><td><em>version-expr</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Version-expression"><em>version-expr</em></a>&nbsp;&nbsp;<b><tt>||</tt></b>&nbsp;&nbsp;<a href="#Version-expression0"><em>version-expr<sub>0</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Version-expression0"><em>version-expr<sub>0</sub></em></a></td></tr></table><h4><a name=Version-expression0>Version-expression<sub>0</sub> <span style="font-weight: normal">(<em>version-expr<sub>0</sub></em>)</span></a></h4>
-<table><tr><td><em>version-expr<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Version-expression0"><em>version-expr<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>&&</tt></b>&nbsp;&nbsp;<a href="#Version-Term"><em>version-term</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Version-Term"><em>version-term</em></a></td></tr></table><h4><a name=Version-Term>Version-Term <span style="font-weight: normal">(<em>version-term</em>)</span></a></h4>
-<table><tr><td><em>version-term</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt><=</tt></b>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>>=</tt></b>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<a href="#Version-atom"><em>version-atom</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Version-expression"><em>version-expr</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></table><h4><a name=Version-atom>Version-atom <span style="font-weight: normal">(<em>version-atom</em>)</span></a></h4>
-<table><tr><td><em>version-atom</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#version-literal"><em>version</em></a></td></tr></table><h4><a name=Include>Include <span style="font-weight: normal">(<em>include-form</em>)</span></a></h4>
-<table><tr><td><em>include-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>include</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>file</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Module-definition>Module-definition <span style="font-weight: normal">(<em>module-definition</em>)</span></a></h4>
-<table><tr><td><em>module-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>module</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>module-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Program-element"><em>pelt</em></a> &mldr; <a href="#Program-element"><em>pelt</em></a>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></table><h4><a name=Generic-parameter-list>Generic-parameter-list <span style="font-weight: normal">(<em>gparams</em>)</span></a></h4>
-<table><tr><td><em>gparams</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Generic-parameter"><em>generic-param</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Generic-parameter"><em>generic-param</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr></table><h4><a name=Generic-parameter>Generic-parameter <span style="font-weight: normal">(<em>generic-param</em>)</span></a></h4>
-<table><tr><td><em>generic-param</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>#</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr></table><h4><a name=Import-declaration>Import-declaration <span style="font-weight: normal">(<em>import-form</em>)</span></a></h4>
-<table><tr><td><em>import-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>import</tt></b>&nbsp;&nbsp;<a href="#Import-selection"><em>import-selection</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Import-name"><em>import-name</em></a>&nbsp;&nbsp;<a href="#Generic-argument-list"><em>gargs</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Import-prefix"><em>import-prefix</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Import-selection>Import-selection <span style="font-weight: normal">(<em>import-selection</em>)</span></a></h4>
-<table><tr><td><em>import-selection</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Import-element"><em>import-element</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Import-element"><em>import-element</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>from</tt></b></td></tr></table><h4><a name=Import-element>Import-element <span style="font-weight: normal">(<em>import-element</em>)</span></a></h4>
-<table><tr><td><em>import-element</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></table><h4><a name=Import-name>Import-name <span style="font-weight: normal">(<em>import-name</em>)</span></a></h4>
-<table><tr><td><em>import-name</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#string-literal"><em>file</em></a></td></tr></table><h4><a name=Import-prefix>Import-prefix <span style="font-weight: normal">(<em>import-prefix</em>)</span></a></h4>
-<table><tr><td><em>import-prefix</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>prefix</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></table><h4><a name=Generic-argument-list>Generic-argument-list <span style="font-weight: normal">(<em>gargs</em>)</span></a></h4>
-<table><tr><td><em>gargs</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Generic-argument"><em>garg</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Generic-argument"><em>garg</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr></table><h4><a name=Generic-argument>Generic-argument <span style="font-weight: normal">(<em>garg</em>)</span></a></h4>
-<table><tr><td><em>garg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Export-declaration>Export-declaration <span style="font-weight: normal">(<em>export-form</em>)</span></a></h4>
-<table><tr><td><em>export-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=Ledger-declaration>Ledger-declaration <span style="font-weight: normal">(<em>ledger-declaration</em>)</span></a></h4>
-<table><tr><td><em>ledger-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>sealed</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Witness-declaration>Witness-declaration <span style="font-weight: normal">(<em>witness-declaration</em>)</span></a></h4>
-<table><tr><td><em>witness-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>witness</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Simple-parameter-list"><em>simple-parameter-list</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Constructor>Constructor <span style="font-weight: normal">(<em>constructor-definition</em>)</span></a></h4>
-<table><tr><td><em>constructor-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>constructor</tt></b>&nbsp;&nbsp;<a href="#Pattern-parameter-list"><em>pattern-parameter-list</em></a>&nbsp;&nbsp;<a href="#Block"><em>block</em></a></td></tr></table><h4><a name=Circuit-definition>Circuit-definition <span style="font-weight: normal">(<em>circuit-definition</em>)</span></a></h4>
-<table><tr><td><em>circuit-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>function-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<a href="#Pattern-parameter-list"><em>pattern-parameter-list</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<a href="#Block"><em>block</em></a></td></tr></table><h4><a name=Structure-declaration>Structure-declaration <span style="font-weight: normal">(<em>struct-declaration</em>)</span></a></h4>
-<table><tr><td><em>struct-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> <a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=Enum-declaration>Enum-declaration <span style="font-weight: normal">(<em>enum-declaration</em>)</span></a></h4>
-<table><tr><td><em>enum-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>enum</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>enum-name</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=External-contract-declaration>External-contract-declaration <span style="font-weight: normal">(<em>contract-declaration</em>)</span></a></h4>
-<table><tr><td><em>contract-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>contract</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>contract-name</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#External-contract-circuit"><em>circuit-declaration</em></a> <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> <a href="#External-contract-circuit"><em>circuit-declaration</em></a> <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>contract</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>contract-name</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#External-contract-circuit"><em>circuit-declaration</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#External-contract-circuit"><em>circuit-declaration</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></table><h4><a name=External-contract-circuit>External-contract-circuit <span style="font-weight: normal">(<em>circuit-declaration</em>)</span></a></h4>
-<table><tr><td><em>circuit-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Simple-parameter-list"><em>simple-parameter-list</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Type-declaration>Type-declaration <span style="font-weight: normal">(<em>type-alias-declaration</em>)</span></a></h4>
-<table><tr><td><em>type-alias-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>new</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>type</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>type-name</em></a>&nbsp;&nbsp;<a href="#Generic-parameter-list"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></table><h4><a name=Typed-identifier>Typed-identifier <span style="font-weight: normal">(<em>typed-identifier</em>)</span></a></h4>
-<table><tr><td><em>typed-identifier</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Simple-parameter-list>Simple-parameter-list <span style="font-weight: normal">(<em>simple-parameter-list</em>)</span></a></h4>
-<table><tr><td><em>simple-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Typed-identifier"><em>typed-identifier</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></table><h4><a name=Typed-pattern>Typed-pattern <span style="font-weight: normal">(<em>typed-pattern</em>)</span></a></h4>
-<table><tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Pattern"><em>pattern</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Pattern-parameter-list>Pattern-parameter-list <span style="font-weight: normal">(<em>pattern-parameter-list</em>)</span></a></h4>
-<table><tr><td><em>pattern-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Typed-pattern"><em>typed-pattern</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Typed-pattern"><em>typed-pattern</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></table><h4><a name=Type>Type <span style="font-weight: normal">(<em>type</em>)</span></a></h4>
-<table><tr><td><em>type</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Type-reference"><em>tref</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>Boolean</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>Field</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Type-size"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Type-size"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<a href="#Type-size"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Type-size"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>Opaque</tt></b>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>Vector</tt></b>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Type-size"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Type"><em>type</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr></table><h4><a name=Type-reference>Type-reference <span style="font-weight: normal">(<em>tref</em>)</span></a></h4>
-<table><tr><td><em>tref</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Generic-argument-list"><em>gargs</em></a><sup>opt</sup></td></tr></table><h4><a name=Type-size>Type-size <span style="font-weight: normal">(<em>tsize</em>)</span></a></h4>
-<table><tr><td><em>tsize</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></table><h4><a name=Block>Block <span style="font-weight: normal">(<em>block</em>)</span></a></h4>
-<table><tr><td><em>block</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a> &mldr; <a href="#Statement"><em>stmt</em></a>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></table><h4><a name=Statement>Statement <span style="font-weight: normal">(<em>stmt</em>)</span></a></h4>
-<table><tr><td><em>stmt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Statement0"><em>stmt<sub>0</sub></em></a></td></tr></table><h4><a name=Statement0>Statement<sub>0</sub> <span style="font-weight: normal">(<em>stmt<sub>0</sub></em>)</span></a></h4>
-<table><tr><td><em>stmt<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#Const-Binding"><em>cbinding</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#Const-Binding"><em>cbinding</em></a> &nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement0"><em>stmt<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>else</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<a href="#Statement"><em>stmt</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Block"><em>block</em></a></td></tr></table><h4><a name=Pattern>Pattern <span style="font-weight: normal">(<em>pattern</em>)</span></a></h4>
-<table><tr><td><em>pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Pattern"><em>pattern</em></a><sup>opt</sup> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Pattern"><em>pattern</em></a><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Pattern-struct-element"><em>pattern-struct-elt</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Pattern-struct-element"><em>pattern-struct-elt</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></table><h4><a name=Pattern-struct-element>Pattern-struct-element <span style="font-weight: normal">(<em>pattern-struct-elt</em>)</span></a></h4>
-<table><tr><td><em>pattern-struct-elt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Pattern"><em>pattern</em></a></td></tr></table><h4><a name=Expression-sequence>Expression-sequence <span style="font-weight: normal">(<em>expr-seq</em>)</span></a></h4>
-<table><tr><td><em>expr-seq</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> &nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr></table><h4><a name=Expression>Expression <span style="font-weight: normal">(<em>expr</em>)</span></a></h4>
-<table><tr><td><em>expr</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression0"><em>expr<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>?</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression0"><em>expr<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression0"><em>expr<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>+=</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression0"><em>expr<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>-=</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression0"><em>expr<sub>0</sub></em></a></td></tr></table><h4><a name=Expression0>Expression<sub>0</sub> <span style="font-weight: normal">(<em>expr<sub>0</sub></em>)</span></a></h4>
-<table><tr><td><em>expr<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression0"><em>expr<sub>0</sub></em></a>&nbsp;&nbsp;<b><tt>||</tt></b>&nbsp;&nbsp;<a href="#Expression1"><em>expr<sub>1</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression1"><em>expr<sub>1</sub></em></a></td></tr></table><h4><a name=Expression1>Expression<sub>1</sub> <span style="font-weight: normal">(<em>expr<sub>1</sub></em>)</span></a></h4>
-<table><tr><td><em>expr<sub>1</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression1"><em>expr<sub>1</sub></em></a>&nbsp;&nbsp;<b><tt>&&</tt></b>&nbsp;&nbsp;<a href="#Expression2"><em>expr<sub>2</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression2"><em>expr<sub>2</sub></em></a></td></tr></table><h4><a name=Expression2>Expression<sub>2</sub> <span style="font-weight: normal">(<em>expr<sub>2</sub></em>)</span></a></h4>
-<table><tr><td><em>expr<sub>2</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression2"><em>expr<sub>2</sub></em></a>&nbsp;&nbsp;<b><tt>==</tt></b>&nbsp;&nbsp;<a href="#Expression3"><em>expr<sub>3</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression2"><em>expr<sub>2</sub></em></a>&nbsp;&nbsp;<b><tt>!=</tt></b>&nbsp;&nbsp;<a href="#Expression3"><em>expr<sub>3</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression3"><em>expr<sub>3</sub></em></a></td></tr></table><h4><a name=Expression3>Expression<sub>3</sub> <span style="font-weight: normal">(<em>expr<sub>3</sub></em>)</span></a></h4>
-<table><tr><td><em>expr<sub>3</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression4"><em>expr<sub>4</sub></em></a>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Expression4"><em>expr<sub>4</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression4"><em>expr<sub>4</sub></em></a>&nbsp;&nbsp;<b><tt><=</tt></b>&nbsp;&nbsp;<a href="#Expression4"><em>expr<sub>4</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression4"><em>expr<sub>4</sub></em></a>&nbsp;&nbsp;<b><tt>>=</tt></b>&nbsp;&nbsp;<a href="#Expression4"><em>expr<sub>4</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression4"><em>expr<sub>4</sub></em></a>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<a href="#Expression4"><em>expr<sub>4</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression4"><em>expr<sub>4</sub></em></a></td></tr></table><h4><a name=Expression4>Expression<sub>4</sub> <span style="font-weight: normal">(<em>expr<sub>4</sub></em>)</span></a></h4>
-<table><tr><td><em>expr<sub>4</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression4"><em>expr<sub>4</sub></em></a>&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression5"><em>expr<sub>5</sub></em></a></td></tr></table><h4><a name=Expression5>Expression<sub>5</sub> <span style="font-weight: normal">(<em>expr<sub>5</sub></em>)</span></a></h4>
-<table><tr><td><em>expr<sub>5</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression5"><em>expr<sub>5</sub></em></a>&nbsp;&nbsp;<b><tt>+</tt></b>&nbsp;&nbsp;<a href="#Expression6"><em>expr<sub>6</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression5"><em>expr<sub>5</sub></em></a>&nbsp;&nbsp;<b><tt>-</tt></b>&nbsp;&nbsp;<a href="#Expression6"><em>expr<sub>6</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression6"><em>expr<sub>6</sub></em></a></td></tr></table><h4><a name=Expression6>Expression<sub>6</sub> <span style="font-weight: normal">(<em>expr<sub>6</sub></em>)</span></a></h4>
-<table><tr><td><em>expr<sub>6</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression6"><em>expr<sub>6</sub></em></a>&nbsp;&nbsp;<b><tt>*</tt></b>&nbsp;&nbsp;<a href="#Expression7"><em>expr<sub>7</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression7"><em>expr<sub>7</sub></em></a></td></tr></table><h4><a name=Expression7>Expression<sub>7</sub> <span style="font-weight: normal">(<em>expr<sub>7</sub></em>)</span></a></h4>
-<table><tr><td><em>expr<sub>7</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<a href="#Expression7"><em>expr<sub>7</sub></em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression8"><em>expr<sub>8</sub></em></a></td></tr></table><h4><a name=Expression8>Expression<sub>8</sub> <span style="font-weight: normal">(<em>expr<sub>8</sub></em>)</span></a></h4>
-<table><tr><td><em>expr<sub>8</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression8"><em>expr<sub>8</sub></em></a>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression8"><em>expr<sub>8</sub></em></a>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression8"><em>expr<sub>8</sub></em></a>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression9"><em>expr<sub>9</sub></em></a></td></tr></table><h4><a name=Expression9>Expression<sub>9</sub> <span style="font-weight: normal">(<em>expr<sub>9</sub></em>)</span></a></h4>
-<table><tr><td><em>expr<sub>9</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Function"><em>fun</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>map</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Function"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>fold</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Function"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#Expression"><em>expr</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>slice</tt></b>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Type-size"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Tuple-argument"><em>tuple-arg</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Tuple-argument"><em>tuple-arg</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<a href="#Tuple-argument"><em>tuple-arg</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Tuple-argument"><em>tuple-arg</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Type-reference"><em>tref</em></a>&nbsp;&nbsp;<b><tt>{</tt></b>&nbsp;&nbsp;<a href="#Structure-argument"><em>struct-arg</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Structure-argument"><em>struct-arg</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>assert</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>disclose</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Term"><em>term</em></a></td></tr></table><h4><a name=Term>Term <span style="font-weight: normal">(<em>term</em>)</span></a></h4>
-<table><tr><td><em>term</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>true</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>false</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>pad</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>default</tt></b>&nbsp;&nbsp;<b><tt><</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></table><h4><a name=Tuple-argument>Tuple-argument <span style="font-weight: normal">(<em>tuple-arg</em>, <em>bytes-arg</em>)</span></a></h4>
-<table><tr><td><em>tuple-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td><em>bytes-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>tuple-arg</em></td></tr></table><h4><a name=Structure-argument>Structure-argument <span style="font-weight: normal">(<em>struct-arg</em>)</span></a></h4>
-<table><tr><td><em>struct-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr></table><h4><a name=Function>Function <span style="font-weight: normal">(<em>fun</em>)</span></a></h4>
-<table><tr><td><em>fun</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#Generic-argument-list"><em>gargs</em></a><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Arrow-parameter-list"><em>arrow-parameter-list</em></a>&nbsp;&nbsp;<a href="#Return-type"><em>return-type</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>=></tt></b>&nbsp;&nbsp;<a href="#Block"><em>block</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Arrow-parameter-list"><em>arrow-parameter-list</em></a>&nbsp;&nbsp;<a href="#Return-type"><em>return-type</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>=></tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Function"><em>fun</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></table><h4><a name=Return-type>Return-type <span style="font-weight: normal">(<em>return-type</em>)</span></a></h4>
-<table><tr><td><em>return-type</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#Type"><em>type</em></a></td></tr></table><h4><a name=Optionally-typed-pattern>Optionally-typed-pattern <span style="font-weight: normal">(<em>optionally-typed-pattern</em>)</span></a></h4>
-<table><tr><td><em>optionally-typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Pattern"><em>pattern</em></a></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Typed-pattern"><em>typed-pattern</em></a></td></tr></table><h4><a name=Const-Binding>Const-Binding <span style="font-weight: normal">(<em>cbinding</em>)</span></a></h4>
-<table><tr><td><em>cbinding</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#Optionally-typed-pattern"><em>optionally-typed-pattern</em></a>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<a href="#Expression"><em>expr</em></a></td></tr></table><h4><a name=Arrow-parameter-list>Arrow-parameter-list <span style="font-weight: normal">(<em>arrow-parameter-list</em>)</span></a></h4>
-<table><tr><td><em>arrow-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#Optionally-typed-pattern"><em>optionally-typed-pattern</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#Optionally-typed-pattern"><em>optionally-typed-pattern</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></table>
-</html>
\ No newline at end of file

From b2574ebdd47e246ab5569e9df3b11722f3846789 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Mon, 9 Mar 2026 21:14:34 +0100
Subject: [PATCH 03/41] commiting the latest compact-grammar.mdx plus some
 changes to custom.css to make the table rendering prettier.

---
 docs/compact/reference/compact-grammar.mdx | 884 ++++++++++++---------
 src/css/custom.css                         |  12 +-
 2 files changed, 512 insertions(+), 384 deletions(-)

diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index 35530c4b..5c537079 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -1,478 +1,598 @@
+# Compact grammar
 
+Compact language version 0.21.0.
 
+Notational note: In the grammar below, terminals are in `monospaced` font. Non-terminals are in *emphasized* font. Alternation is indicated by a vertical bar (`|`). Optional items are indicated by the superscript <sup>opt</sup>. Repetition is specified by ellipses. The notation *X* &mldr; *X*, where *X* is a grammar symbol, represents zero or more occurrences of *X*. The notation *X* `,` &mldr; `,` *X*, where *X* is a grammar symbol and `,` is a literal comma, represents zero or more occurrences of *X* separated by commas. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one *X*. When such a sequence is followed by *,*<sup>opt</sup>, an optional trailing comma is allowed, but only if there is at least one *X*. For example, *id* &mldr; *id* represents zero or more *id*s, and *expr* `,` &mldr;&sup1; `,` *expr* `,`<sup>opt</sup> represents one or more comma-separated *expr*s possibly followed by an extra comma. The rules involving commas apply equally to semicolons, i.e., apply when `,` is replaced by `;`.
 
+#### end-of-file (*eof*)
 
+End of file.
 
-# Compact Grammar
+#### identifier (*id*, *module-name*, *function-name*, *struct-name*, *enum-name*, *contract-name*, *tvar-name*, *type-name*)
 
-Compact language version 0.21.0.
+Identifiers have the same syntax as Typescript identifiers.
+
+#### field-literal (*nat*)
 
-Notational note: In the grammar productions below, ellipses are used to specify repetition. The notation <em>X</em> ... <em>X</em>, where <em>X</em> is a grammar symbol, represents zero or more occurrences of <em>X</em>. The notation <em>X</em> <b><tt>,</tt></b> ... <b><tt>,</tt></b> <em>X</em>, where <em>X</em> is a grammar symbol and <b><tt>,</tt></b> is a separator, represents zero or more occurrences of <em>X</em> separated by <b><tt>,</tt></b>. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one <em>X</em>. When such a sequence is followed by <em>,</em><sup>opt</sup>, an optional trailing separator is allowed, but only if there is at least one <em>X</em>. For example, <em>id</em> &mldr; <em>id</em> represents zero or more <em>id</em>s, and <em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup> represents one or more comma-separated <em>expr</em>s possibly followed by an extra comma. There are two separators: comma and semicolon.
-### end-of-file (*eof*)
+A field literal is 0 or a natural number formed from a sequence of digits starting with 1-9, e.g. 723, whose value does not exceed the maximum field value.
 
-end of file
-### identifier (*id*, *module-name*, *function-name*, *struct-name*, *enum-name*, *contract-name*, *tvar-name*, *type-name*)
+#### string-literal (*str*, *file*)
 
-identifiers have the same syntax as Typescript identifiers
-### field-literal (*nat*)
+A string literal has the same syntax as a Typescript string.
 
-a field literal is 0 or a natural number formed from a sequence of digits starting with 1-9, e.g. 723, whose value does not exceed the maximum field value
-### string-literal (*str*, *file*)
+#### version-literal (*version*)
 
-a string literal has the same syntax as a Typescript string
-### version-literal (*version*)
+A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2.3, representing major, minor, and bugfix versions.
+
+#### Compact (**program**)
 
-a version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2.3, representing major, minor, and bugfix versions
-### Compact  (**program**)
 <div className="lang-ref-table">
-|                 |        |                                                   |
-|-----------------|--------|---------------------------------------------------|
-| *program*&nbsp; | &rarr; | &nbsp;&nbsp;*pelt* &mldr; *pelt*&nbsp;&nbsp;*eof* |
+|           |         |                            |
+|-----------|---------|----------------------------|
+| *program* | &xrarr; | *pelt* &mldr; *pelt* *eof* |
 </div>
-### Program-element  (**pelt**)
+
+#### Program-element (**pelt**)
+
 <div className="lang-ref-table">
-|              |        |                                      |
-|--------------|--------|--------------------------------------|
-| *pelt*&nbsp; | &rarr; | &nbsp;&nbsp;*pragma-form*            |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*module-definition*      |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*import-form*            |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*export-form*            |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*include-form*           |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*struct-declaration*     |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*enum-declaration*       |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*contract-declaration*   |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*type-alias-declaration* |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*ledger-declaration*     |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*witness-declaration*    |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*constructor-definition* |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*circuit-definition*     |
+|        |         |                          |
+|--------|---------|--------------------------|
+| *pelt* | &xrarr; | *pragma-form*            |
+|        | \|      | *module-definition*      |
+|        | \|      | *import-form*            |
+|        | \|      | *export-form*            |
+|        | \|      | *include-form*           |
+|        | \|      | *struct-declaration*     |
+|        | \|      | *enum-declaration*       |
+|        | \|      | *contract-declaration*   |
+|        | \|      | *type-alias-declaration* |
+|        | \|      | *ledger-declaration*     |
+|        | \|      | *witness-declaration*    |
+|        | \|      | *constructor-definition* |
+|        | \|      | *circuit-definition*     |
 </div>
-### Pragma  (**pragma-form**)
+
+#### Pragma (**pragma-form**)
+
 <div className="lang-ref-table">
-|                     |        |                                                                                                           |
-|---------------------|--------|-----------------------------------------------------------------------------------------------------------|
-| *pragma-form*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>pragma</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;*version-expr*&nbsp;&nbsp;<b><tt>;</tt></b> |
+|               |         |                                  |
+|---------------|---------|----------------------------------|
+| *pragma-form* | &xrarr; | `pragma` *id* *version-expr* `;` |
 </div>
-### Version-expression  (**version-expr**)
+
+#### Version-expression (**version-expr**)
+
 <div className="lang-ref-table">
-|                      |        |                                                                                                  |
-|----------------------|--------|--------------------------------------------------------------------------------------------------|
-| *version-expr*&nbsp; | &rarr; | &nbsp;&nbsp;*version-expr*&nbsp;&nbsp;<b><tt>\|\|</tt></b>&nbsp;&nbsp;*version-expr<sub>0</sub>* |
-| &nbsp;               | &rarr; | &nbsp;&nbsp;*version-expr<sub>0</sub>*                                                           |
+|                |         |                                                  |
+|----------------|---------|--------------------------------------------------|
+| *version-expr* | &xrarr; | *version-expr* `\|\|` *version-expr<sub>0</sub>* |
+|                | \|      | *version-expr<sub>0</sub>*                       |
 </div>
-### Version-expression<sub>0</sub>  (**version-expr<sub>0</sub>**)
+
+#### Version-expression<sub>0</sub> (**version-expr<sub>0</sub>**)
+
 <div className="lang-ref-table">
-|                                  |        |                                                                                                        |
-|----------------------------------|--------|--------------------------------------------------------------------------------------------------------|
-| *version-expr<sub>0</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*version-expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>&amp;&amp;</tt></b>&nbsp;&nbsp;*version-term* |
-| &nbsp;                           | &rarr; | &nbsp;&nbsp;*version-term*                                                                             |
+|                            |         |                                                |
+|----------------------------|---------|------------------------------------------------|
+| *version-expr<sub>0</sub>* | &xrarr; | *version-expr<sub>0</sub>* `&&` *version-term* |
+|                            | \|      | *version-term*                                 |
 </div>
-### Version-Term  (**version-term**)
+
+#### Version-Term (**version-term**)
+
 <div className="lang-ref-table">
-|                      |        |                                                                                      |
-|----------------------|--------|--------------------------------------------------------------------------------------|
-| *version-term*&nbsp; | &rarr; | &nbsp;&nbsp;*version-atom*                                                           |
-| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;*version-atom*                              |
-| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*version-atom*                           |
-| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>&lt;=</tt></b>&nbsp;&nbsp;*version-atom*                          |
-| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>&gt;=</tt></b>&nbsp;&nbsp;*version-atom*                          |
-| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>&gt;</tt></b>&nbsp;&nbsp;*version-atom*                           |
-| &nbsp;               | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*version-expr*&nbsp;&nbsp;<b><tt>)</tt></b> |
+|                |         |                        |
+|----------------|---------|------------------------|
+| *version-term* | &xrarr; | *version-atom*         |
+|                | \|      | `!` *version-atom*     |
+|                | \|      | `<` *version-atom*     |
+|                | \|      | `<=` *version-atom*    |
+|                | \|      | `>=` *version-atom*    |
+|                | \|      | `>` *version-atom*     |
+|                | \|      | `(` *version-expr* `)` |
 </div>
-### Version-atom  (**version-atom**)
+
+#### Version-atom (**version-atom**)
+
 <div className="lang-ref-table">
-|                      |        |                       |
-|----------------------|--------|-----------------------|
-| *version-atom*&nbsp; | &rarr; | &nbsp;&nbsp;*nat*     |
-| &nbsp;               | &rarr; | &nbsp;&nbsp;*version* |
+|                |         |           |
+|----------------|---------|-----------|
+| *version-atom* | &xrarr; | *nat*     |
+|                | \|      | *version* |
 </div>
-### Include  (**include-form**)
+
+#### Include (**include-form**)
+
 <div className="lang-ref-table">
-|                      |        |                                                                                    |
-|----------------------|--------|------------------------------------------------------------------------------------|
-| *include-form*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>include</tt></b>&nbsp;&nbsp;*file*&nbsp;&nbsp;<b><tt>;</tt></b> |
+|                |         |                      |
+|----------------|---------|----------------------|
+| *include-form* | &xrarr; | `include` *file* `;` |
 </div>
-### Module-definition  (**module-definition**)
+
+#### Module-definition (**module-definition**)
+
 <div className="lang-ref-table">
-|                           |        |                                                                                                                                                                                                                                           |
-|---------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *module-definition*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>module</tt></b>&nbsp;&nbsp;*module-name*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*pelt* &mldr; *pelt*&nbsp;&nbsp;<b><tt>}</tt></b> |
+|                     |         |                                                                                                    |
+|---------------------|---------|----------------------------------------------------------------------------------------------------|
+| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` *module-name* *gparams*<sup>opt</sup> `{` *pelt* &mldr; *pelt* `}` |
 </div>
-### Generic-parameter-list  (**gparams**)
+
+#### Generic-parameter-list (**gparams**)
+
 <div className="lang-ref-table">
-|                 |        |                                                                                                                                                                                        |
-|-----------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *gparams*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*generic-param* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *generic-param* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>&gt;</tt></b> |
+|           |         |                                                                          |
+|-----------|---------|--------------------------------------------------------------------------|
+| *gparams* | &xrarr; | `<` *generic-param* `,` &mldr; `,` *generic-param* `,`<sup>opt</sup> `>` |
 </div>
-### Generic-parameter  (**generic-param**)
+
+#### Generic-parameter (**generic-param**)
+
 <div className="lang-ref-table">
-|                       |        |                                                      |
-|-----------------------|--------|------------------------------------------------------|
-| *generic-param*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>#</tt></b>&nbsp;&nbsp;*tvar-name* |
-| &nbsp;                | &rarr; | &nbsp;&nbsp;*tvar-name*                              |
+|                 |         |                 |
+|-----------------|---------|-----------------|
+| *generic-param* | &xrarr; | `#` *tvar-name* |
+|                 | \|      | *tvar-name*     |
 </div>
-### Import-declaration  (**import-form**)
+
+#### Import-declaration (**import-form**)
+
 <div className="lang-ref-table">
-|                     |        |                                                                                                                                                                                                                |
-|---------------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *import-form*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>import</tt></b>&nbsp;&nbsp;*import-selection*<sup>opt</sup>&nbsp;&nbsp;*import-name*&nbsp;&nbsp;*gargs*<sup>opt</sup>&nbsp;&nbsp;*import-prefix*<sup>opt</sup>&nbsp;&nbsp;<b><tt>;</tt></b> |
+|               |         |                                                                                                                 |
+|---------------|---------|-----------------------------------------------------------------------------------------------------------------|
+| *import-form* | &xrarr; | `import` *import-selection*<sup>opt</sup> *import-name* *gargs*<sup>opt</sup> *import-prefix*<sup>opt</sup> `;` |
 </div>
-### Import-selection  (**import-selection**)
+
+#### Import-selection (**import-selection**)
+
 <div className="lang-ref-table">
-|                          |        |                                                                                                                                                                                                                     |
-|--------------------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *import-selection*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*import-element* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *import-element* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>from</tt></b> |
+|                    |         |                                                                                   |
+|--------------------|---------|-----------------------------------------------------------------------------------|
+| *import-selection* | &xrarr; | `{` *import-element* `,` &mldr; `,` *import-element* `,`<sup>opt</sup> `}` `from` |
 </div>
-### Import-element  (**import-element**)
+
+#### Import-element (**import-element**)
+
 <div className="lang-ref-table">
-|                        |        |                                                                |
-|------------------------|--------|----------------------------------------------------------------|
-| *import-element*&nbsp; | &rarr; | &nbsp;&nbsp;*id*                                               |
-| &nbsp;                 | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;*id* |
+|                  |         |                |
+|------------------|---------|----------------|
+| *import-element* | &xrarr; | *id*           |
+|                  | \|      | *id* `as` *id* |
 </div>
-### Import-name  (**import-name**)
+
+#### Import-name (**import-name**)
+
 <div className="lang-ref-table">
-|                     |        |                    |
-|---------------------|--------|--------------------|
-| *import-name*&nbsp; | &rarr; | &nbsp;&nbsp;*id*   |
-| &nbsp;              | &rarr; | &nbsp;&nbsp;*file* |
+|               |         |        |
+|---------------|---------|--------|
+| *import-name* | &xrarr; | *id*   |
+|               | \|      | *file* |
 </div>
-### Import-prefix  (**import-prefix**)
+
+#### Import-prefix (**import-prefix**)
+
 <div className="lang-ref-table">
-|                       |        |                                                    |
-|-----------------------|--------|----------------------------------------------------|
-| *import-prefix*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>prefix</tt></b>&nbsp;&nbsp;*id* |
+|                 |         |               |
+|-----------------|---------|---------------|
+| *import-prefix* | &xrarr; | `prefix` *id* |
 </div>
-### Generic-argument-list  (**gargs**)
+
+#### Generic-argument-list (**gargs**)
+
 <div className="lang-ref-table">
-|               |        |                                                                                                                                                                      |
-|---------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *gargs*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*garg* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *garg* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>&gt;</tt></b> |
+|         |         |                                                        |
+|---------|---------|--------------------------------------------------------|
+| *gargs* | &xrarr; | `<` *garg* `,` &mldr; `,` *garg* `,`<sup>opt</sup> `>` |
 </div>
-### Generic-argument  (**garg**)
+
+#### Generic-argument (**garg**)
+
 <div className="lang-ref-table">
-|              |        |                    |
-|--------------|--------|--------------------|
-| *garg*&nbsp; | &rarr; | &nbsp;&nbsp;*nat*  |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*type* |
+|        |         |        |
+|--------|---------|--------|
+| *garg* | &xrarr; | *nat*  |
+|        | \|      | *type* |
 </div>
-### Export-declaration  (**export-form**)
+
+#### Export-declaration (**export-form**)
+
 <div className="lang-ref-table">
-|                     |        |                                                                                                                                                                                                                                          |
-|---------------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *export-form*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*id* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *id* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
+|               |         |                                                                               |
+|---------------|---------|-------------------------------------------------------------------------------|
+| *export-form* | &xrarr; | `export` `{` *id* `,` &mldr; `,` *id* `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
-### Ledger-declaration  (**ledger-declaration**)
+
+#### Ledger-declaration (**ledger-declaration**)
+
 <div className="lang-ref-table">
-|                            |        |                                                                                                                                                                                                                                |
-|----------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *ledger-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>sealed</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;<b><tt>;</tt></b> |
+|                      |         |                                                                            |
+|----------------------|---------|----------------------------------------------------------------------------|
+| *ledger-declaration* | &xrarr; | `export`<sup>opt</sup> `sealed`<sup>opt</sup> `ledger` *id* `:` *type* `;` |
 </div>
-### Witness-declaration  (**witness-declaration**)
+
+#### Witness-declaration (**witness-declaration**)
+
 <div className="lang-ref-table">
-|                             |        |                                                                                                                                                                                                                                                       |
-|-----------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *witness-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>witness</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;*simple-parameter-list*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;<b><tt>;</tt></b> |
+|                       |         |                                                                                                      |
+|-----------------------|---------|------------------------------------------------------------------------------------------------------|
+| *witness-declaration* | &xrarr; | `export`<sup>opt</sup> `witness` *id* *gparams*<sup>opt</sup> *simple-parameter-list* `:` *type* `;` |
 </div>
-### Constructor  (**constructor-definition**)
+
+#### Constructor (**constructor-definition**)
+
 <div className="lang-ref-table">
-|                                |        |                                                                                                |
-|--------------------------------|--------|------------------------------------------------------------------------------------------------|
-| *constructor-definition*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>constructor</tt></b>&nbsp;&nbsp;*pattern-parameter-list*&nbsp;&nbsp;*block* |
+|                          |         |                                                |
+|--------------------------|---------|------------------------------------------------|
+| *constructor-definition* | &xrarr; | `constructor` *pattern-parameter-list* *block* |
 </div>
-### Circuit-definition  (**circuit-definition**)
+
+#### Circuit-definition (**circuit-definition**)
+
 <div className="lang-ref-table">
-|                            |        |                                                                                                                                                                                                                                                                                                       |
-|----------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *circuit-definition*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;*function-name*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;*pattern-parameter-list*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;*block* |
+|                      |         |                                                                                                                                           |
+|----------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------|
+| *circuit-definition* | &xrarr; | `export`<sup>opt</sup> `pure`<sup>opt</sup> `circuit` *function-name* *gparams*<sup>opt</sup> *pattern-parameter-list* `:` *type* *block* |
 </div>
-### Structure-declaration  (**struct-declaration**)
+
+#### Structure-declaration (**struct-declaration**)
+
 <div className="lang-ref-table">
-|                            |        |                                                                                                                                                                                                                                                                                                                                                                                  |
-|----------------------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *struct-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;*struct-name*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*typed-identifier* <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> *typed-identifier* <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
-| &nbsp;                     | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;*struct-name*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*typed-identifier* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *typed-identifier* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
+|                      |         |                                                                                                                                                                        |
+|----------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *struct-declaration* | &xrarr; | `export`<sup>opt</sup> `struct` *struct-name* *gparams*<sup>opt</sup> `{` *typed-identifier* `;` &mldr; `;` *typed-identifier* `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                      | \|      | `export`<sup>opt</sup> `struct` *struct-name* *gparams*<sup>opt</sup> `{` *typed-identifier* `,` &mldr; `,` *typed-identifier* `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
-### Enum-declaration  (**enum-declaration**)
+
+#### Enum-declaration (**enum-declaration**)
+
 <div className="lang-ref-table">
-|                          |        |                                                                                                                                                                                                                                                                                                                     |
-|--------------------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *enum-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>enum</tt></b>&nbsp;&nbsp;*enum-name*&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*id* <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> *id* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
+|                    |         |                                                                                                                      |
+|--------------------|---------|----------------------------------------------------------------------------------------------------------------------|
+| *enum-declaration* | &xrarr; | `export`<sup>opt</sup> `enum` *enum-name* `{` *id* `,` &mldr;&sup1; `,` *id* `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
-### External-contract-declaration  (**contract-declaration**)
+
+#### External-contract-declaration (**contract-declaration**)
+
 <div className="lang-ref-table">
-|                              |        |                                                                                                                                                                                                                                                                                                                                                         |
-|------------------------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *contract-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>contract</tt></b>&nbsp;&nbsp;*contract-name*&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*circuit-declaration* <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> *circuit-declaration* <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
-| &nbsp;                       | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>contract</tt></b>&nbsp;&nbsp;*contract-name*&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*circuit-declaration* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *circuit-declaration* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup> |
+|                        |         |                                                                                                                                                          |
+|------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *contract-declaration* | &xrarr; | `export`<sup>opt</sup> `contract` *contract-name* `{` *circuit-declaration* `;` &mldr; `;` *circuit-declaration* `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                        | \|      | `export`<sup>opt</sup> `contract` *contract-name* `{` *circuit-declaration* `,` &mldr; `,` *circuit-declaration* `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
-### External-contract-circuit  (**circuit-declaration**)
+
+#### External-contract-circuit (**circuit-declaration**)
+
 <div className="lang-ref-table">
-|                             |        |                                                                                                                                                                                     |
-|-----------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *circuit-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;*simple-parameter-list*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type* |
+|                       |         |                                                                        |
+|-----------------------|---------|------------------------------------------------------------------------|
+| *circuit-declaration* | &xrarr; | `pure`<sup>opt</sup> `circuit` *id* *simple-parameter-list* `:` *type* |
 </div>
-### Type-declaration  (**type-alias-declaration**)
+
+#### Type-declaration (**type-alias-declaration**)
+
 <div className="lang-ref-table">
-|                                |        |                                                                                                                                                                                                                                                                     |
-|--------------------------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *type-alias-declaration*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>new</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>type</tt></b>&nbsp;&nbsp;*type-name*&nbsp;&nbsp;*gparams*<sup>opt</sup>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;<b><tt>;</tt></b> |
+|                          |         |                                                                                                      |
+|--------------------------|---------|------------------------------------------------------------------------------------------------------|
+| *type-alias-declaration* | &xrarr; | `export`<sup>opt</sup> `new`<sup>opt</sup> `type` *type-name* *gparams*<sup>opt</sup> `=` *type* `;` |
 </div>
-### Typed-identifier  (**typed-identifier**)
+
+#### Typed-identifier (**typed-identifier**)
+
 <div className="lang-ref-table">
-|                          |        |                                                                 |
-|--------------------------|--------|-----------------------------------------------------------------|
-| *typed-identifier*&nbsp; | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type* |
+|                    |         |                 |
+|--------------------|---------|-----------------|
+| *typed-identifier* | &xrarr; | *id* `:` *type* |
 </div>
-### Simple-parameter-list  (**simple-parameter-list**)
+
+#### Simple-parameter-list (**simple-parameter-list**)
+
 <div className="lang-ref-table">
-|                               |        |                                                                                                                                                                                        |
-|-------------------------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *simple-parameter-list*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*typed-identifier* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *typed-identifier* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b> |
+|                         |         |                                                                                |
+|-------------------------|---------|--------------------------------------------------------------------------------|
+| *simple-parameter-list* | &xrarr; | `(` *typed-identifier* `,` &mldr; `,` *typed-identifier* `,`<sup>opt</sup> `)` |
 </div>
-### Typed-pattern  (**typed-pattern**)
+
+#### Typed-pattern (**typed-pattern**)
+
 <div className="lang-ref-table">
-|                       |        |                                                                      |
-|-----------------------|--------|----------------------------------------------------------------------|
-| *typed-pattern*&nbsp; | &rarr; | &nbsp;&nbsp;*pattern*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type* |
+|                 |         |                      |
+|-----------------|---------|----------------------|
+| *typed-pattern* | &xrarr; | *pattern* `:` *type* |
 </div>
-### Pattern-parameter-list  (**pattern-parameter-list**)
+
+#### Pattern-parameter-list (**pattern-parameter-list**)
+
 <div className="lang-ref-table">
-|                                |        |                                                                                                                                                                                  |
-|--------------------------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *pattern-parameter-list*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*typed-pattern* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *typed-pattern* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b> |
+|                          |         |                                                                          |
+|--------------------------|---------|--------------------------------------------------------------------------|
+| *pattern-parameter-list* | &xrarr; | `(` *typed-pattern* `,` &mldr; `,` *typed-pattern* `,`<sup>opt</sup> `)` |
 </div>
-### Type  (**type**)
+
+#### Type (**type**)
+
 <div className="lang-ref-table">
-|              |        |                                                                                                                                                                      |
-|--------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *type*&nbsp; | &rarr; | &nbsp;&nbsp;*tref*                                                                                                                                                   |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Boolean</tt></b>                                                                                                                                  |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Field</tt></b>                                                                                                                                    |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>&gt;</tt></b>                                                  |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>&gt;</tt></b> |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>&gt;</tt></b>                                                 |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Opaque</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*str*&nbsp;&nbsp;<b><tt>&gt;</tt></b>                                                  |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>Vector</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;<b><tt>&gt;</tt></b> |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;*type* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *type* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b>       |
+|        |         |                                                        |
+|--------|---------|--------------------------------------------------------|
+| *type* | &xrarr; | *tref*                                                 |
+|        | \|      | `Boolean`                                              |
+|        | \|      | `Field`                                                |
+|        | \|      | `Uint` `<` *tsize* `>`                                 |
+|        | \|      | `Uint` `<` *tsize* `..` *tsize* `>`                    |
+|        | \|      | `Bytes` `<` *tsize* `>`                                |
+|        | \|      | `Opaque` `<` *str* `>`                                 |
+|        | \|      | `Vector` `<` *tsize* `,` *type* `>`                    |
+|        | \|      | `[` *type* `,` &mldr; `,` *type* `,`<sup>opt</sup> `]` |
 </div>
-### Type-reference  (**tref**)
+
+#### Type-reference (**tref**)
+
 <div className="lang-ref-table">
-|              |        |                                                   |
-|--------------|--------|---------------------------------------------------|
-| *tref*&nbsp; | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;*gargs*<sup>opt</sup> |
+|        |         |                            |
+|--------|---------|----------------------------|
+| *tref* | &xrarr; | *id* *gargs*<sup>opt</sup> |
 </div>
-### Type-size  (**tsize**)
+
+#### Type-size (**tsize**)
+
 <div className="lang-ref-table">
-|               |        |                   |
-|---------------|--------|-------------------|
-| *tsize*&nbsp; | &rarr; | &nbsp;&nbsp;*nat* |
-| &nbsp;        | &rarr; | &nbsp;&nbsp;*id*  |
+|         |         |       |
+|---------|---------|-------|
+| *tsize* | &xrarr; | *nat* |
+|         | \|      | *id*  |
 </div>
-### Block  (**block**)
+
+#### Block (**block**)
+
 <div className="lang-ref-table">
-|               |        |                                                                                             |
-|---------------|--------|---------------------------------------------------------------------------------------------|
-| *block*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*stmt* &mldr; *stmt*&nbsp;&nbsp;<b><tt>}</tt></b> |
+|         |         |                              |
+|---------|---------|------------------------------|
+| *block* | &xrarr; | `{` *stmt* &mldr; *stmt* `}` |
 </div>
-### Statement  (**stmt**)
+
+#### Statement (**stmt**)
+
 <div className="lang-ref-table">
-|              |        |                                                                                                                                  |
-|--------------|--------|----------------------------------------------------------------------------------------------------------------------------------|
-| *stmt*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;*stmt* |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*stmt<sub>0</sub>*                                                                                                   |
+|        |         |                                |
+|--------|---------|--------------------------------|
+| *stmt* | &xrarr; | `if` `(` *expr-seq* `)` *stmt* |
+|        | \|      | *stmt<sub>0</sub>*             |
 </div>
-### Statement<sub>0</sub>  (**stmt<sub>0</sub>**)
+
+#### Statement<sub>0</sub> (**stmt<sub>0</sub>**)
+
 <div className="lang-ref-table">
-|                          |        |                                                                                                                                                                                                                                                            |
-|--------------------------|--------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *stmt<sub>0</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>;</tt></b>                                                                                                                                                                                                        |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;*cbinding* <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> *cbinding* &nbsp;&nbsp;<b><tt>;</tt></b>                                                                                                          |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;*stmt<sub>0</sub>*&nbsp;&nbsp;<b><tt>else</tt></b>&nbsp;&nbsp;*stmt*                                                             |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;*nat*&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;*nat*&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;*stmt* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;*stmt*                                           |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>;</tt></b>                                                                                                                                                                      |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b>                                                                                                                                                                                            |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*block*                                                                                                                                                                                                                                        |
+|                    |         |                                                          |
+|--------------------|---------|----------------------------------------------------------|
+| *stmt<sub>0</sub>* | &xrarr; | *expr-seq* `;`                                           |
+|                    | \|      | `const` *cbinding* `,` &mldr;&sup1; `,` *cbinding*  `;`  |
+|                    | \|      | `if` `(` *expr-seq* `)` *stmt<sub>0</sub>* `else` *stmt* |
+|                    | \|      | `for` `(` `const` *id* `of` *nat* `..` *nat* `)` *stmt*  |
+|                    | \|      | `for` `(` `const` *id* `of` *expr-seq* `)` *stmt*        |
+|                    | \|      | `return` *expr-seq* `;`                                  |
+|                    | \|      | `return` `;`                                             |
+|                    | \|      | *block*                                                  |
 </div>
-### Pattern  (**pattern**)
+
+#### Pattern (**pattern**)
+
 <div className="lang-ref-table">
-|                 |        |                                                                                                                                                                                                  |
-|-----------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *pattern*&nbsp; | &rarr; | &nbsp;&nbsp;*id*                                                                                                                                                                                 |
-| &nbsp;          | &rarr; | &nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;*pattern*<sup>opt</sup> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *pattern*<sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b> |
-| &nbsp;          | &rarr; | &nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*pattern-struct-elt* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *pattern-struct-elt* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>      |
+|           |         |                                                                                          |
+|-----------|---------|------------------------------------------------------------------------------------------|
+| *pattern* | &xrarr; | *id*                                                                                     |
+|           | \|      | `[` *pattern*<sup>opt</sup> `,` &mldr; `,` *pattern*<sup>opt</sup> `,`<sup>opt</sup> `]` |
+|           | \|      | `{` *pattern-struct-elt* `,` &mldr; `,` *pattern-struct-elt* `,`<sup>opt</sup> `}`       |
 </div>
-### Pattern-struct-element  (**pattern-struct-elt**)
+
+#### Pattern-struct-element (**pattern-struct-elt**)
+
+<div className="lang-ref-table">
+|                      |         |                    |
+|----------------------|---------|--------------------|
+| *pattern-struct-elt* | &xrarr; | *id*               |
+|                      | \|      | *id* `:` *pattern* |
+</div>
+
+#### Expression-sequence (**expr-seq**)
+
+<div className="lang-ref-table">
+|            |         |                                                |
+|------------|---------|------------------------------------------------|
+| *expr-seq* | &xrarr; | *expr*                                         |
+|            | \|      | *expr* `,` &mldr;&sup1; `,` *expr*  `,` *expr* |
+</div>
+
+#### Expression (**expr**)
+
+<div className="lang-ref-table">
+|        |         |                                          |
+|--------|---------|------------------------------------------|
+| *expr* | &xrarr; | *expr<sub>0</sub>* `?` *expr* `:` *expr* |
+|        | \|      | *expr<sub>0</sub>* `=` *expr*            |
+|        | \|      | *expr<sub>0</sub>* `+=` *expr*           |
+|        | \|      | *expr<sub>0</sub>* `-=` *expr*           |
+|        | \|      | *expr<sub>0</sub>*                       |
+</div>
+
+#### Expression<sub>0</sub> (**expr<sub>0</sub>**)
+
+<div className="lang-ref-table">
+|                    |         |                                              |
+|--------------------|---------|----------------------------------------------|
+| *expr<sub>0</sub>* | &xrarr; | *expr<sub>0</sub>* `\|\|` *expr<sub>1</sub>* |
+|                    | \|      | *expr<sub>1</sub>*                           |
+</div>
+
+#### Expression<sub>1</sub> (**expr<sub>1</sub>**)
+
+<div className="lang-ref-table">
+|                    |         |                                            |
+|--------------------|---------|--------------------------------------------|
+| *expr<sub>1</sub>* | &xrarr; | *expr<sub>1</sub>* `&&` *expr<sub>2</sub>* |
+|                    | \|      | *expr<sub>2</sub>*                         |
+</div>
+
+#### Expression<sub>2</sub> (**expr<sub>2</sub>**)
+
+<div className="lang-ref-table">
+|                    |         |                                            |
+|--------------------|---------|--------------------------------------------|
+| *expr<sub>2</sub>* | &xrarr; | *expr<sub>2</sub>* `==` *expr<sub>3</sub>* |
+|                    | \|      | *expr<sub>2</sub>* `!=` *expr<sub>3</sub>* |
+|                    | \|      | *expr<sub>3</sub>*                         |
+</div>
+
+#### Expression<sub>3</sub> (**expr<sub>3</sub>**)
+
+<div className="lang-ref-table">
+|                    |         |                                            |
+|--------------------|---------|--------------------------------------------|
+| *expr<sub>3</sub>* | &xrarr; | *expr<sub>4</sub>* `<` *expr<sub>4</sub>*  |
+|                    | \|      | *expr<sub>4</sub>* `<=` *expr<sub>4</sub>* |
+|                    | \|      | *expr<sub>4</sub>* `>=` *expr<sub>4</sub>* |
+|                    | \|      | *expr<sub>4</sub>* `>` *expr<sub>4</sub>*  |
+|                    | \|      | *expr<sub>4</sub>*                         |
+</div>
+
+#### Expression<sub>4</sub> (**expr<sub>4</sub>**)
+
 <div className="lang-ref-table">
-|                            |        |                                                                    |
-|----------------------------|--------|--------------------------------------------------------------------|
-| *pattern-struct-elt*&nbsp; | &rarr; | &nbsp;&nbsp;*id*                                                   |
-| &nbsp;                     | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*pattern* |
+|                    |         |                                |
+|--------------------|---------|--------------------------------|
+| *expr<sub>4</sub>* | &xrarr; | *expr<sub>4</sub>* `as` *type* |
+|                    | \|      | *expr<sub>5</sub>*             |
 </div>
-### Expression-sequence  (**expr-seq**)
+
+#### Expression<sub>5</sub> (**expr<sub>5</sub>**)
+
+<div className="lang-ref-table">
+|                    |         |                                           |
+|--------------------|---------|-------------------------------------------|
+| *expr<sub>5</sub>* | &xrarr; | *expr<sub>5</sub>* `+` *expr<sub>6</sub>* |
+|                    | \|      | *expr<sub>5</sub>* `-` *expr<sub>6</sub>* |
+|                    | \|      | *expr<sub>6</sub>*                        |
+</div>
+
+#### Expression<sub>6</sub> (**expr<sub>6</sub>**)
+
+<div className="lang-ref-table">
+|                    |         |                                           |
+|--------------------|---------|-------------------------------------------|
+| *expr<sub>6</sub>* | &xrarr; | *expr<sub>6</sub>* `*` *expr<sub>7</sub>* |
+|                    | \|      | *expr<sub>7</sub>*                        |
+</div>
+
+#### Expression<sub>7</sub> (**expr<sub>7</sub>**)
+
 <div className="lang-ref-table">
-|                  |        |                                                                                                                            |
-|------------------|--------|----------------------------------------------------------------------------------------------------------------------------|
-| *expr-seq*&nbsp; | &rarr; | &nbsp;&nbsp;*expr*                                                                                                         |
-| &nbsp;           | &rarr; | &nbsp;&nbsp;*expr* <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> *expr* &nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*expr* |
+|                    |         |                        |
+|--------------------|---------|------------------------|
+| *expr<sub>7</sub>* | &xrarr; | `!` *expr<sub>7</sub>* |
+|                    | \|      | *expr<sub>8</sub>*     |
 </div>
-### Expression  (**expr**)
-<div className="lang-ref-table">
-|              |        |                                                                                                                              |
-|--------------|--------|------------------------------------------------------------------------------------------------------------------------------|
-| *expr*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>?</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*expr* |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;*expr*                                                |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>+=</tt></b>&nbsp;&nbsp;*expr*                                               |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>-=</tt></b>&nbsp;&nbsp;*expr*                                               |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*                                                                                               |
-</div>
-### Expression<sub>0</sub>  (**expr<sub>0</sub>**)
-<div className="lang-ref-table">
-|                          |        |                                                                                              |
-|--------------------------|--------|----------------------------------------------------------------------------------------------|
-| *expr<sub>0</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>0</sub>*&nbsp;&nbsp;<b><tt>\|\|</tt></b>&nbsp;&nbsp;*expr<sub>1</sub>* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>1</sub>*                                                               |
-</div>
-### Expression<sub>1</sub>  (**expr<sub>1</sub>**)
-<div className="lang-ref-table">
-|                          |        |                                                                                                    |
-|--------------------------|--------|----------------------------------------------------------------------------------------------------|
-| *expr<sub>1</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>1</sub>*&nbsp;&nbsp;<b><tt>&amp;&amp;</tt></b>&nbsp;&nbsp;*expr<sub>2</sub>* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>2</sub>*                                                                     |
-</div>
-### Expression<sub>2</sub>  (**expr<sub>2</sub>**)
-<div className="lang-ref-table">
-|                          |        |                                                                                            |
-|--------------------------|--------|--------------------------------------------------------------------------------------------|
-| *expr<sub>2</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>2</sub>*&nbsp;&nbsp;<b><tt>==</tt></b>&nbsp;&nbsp;*expr<sub>3</sub>* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>2</sub>*&nbsp;&nbsp;<b><tt>!=</tt></b>&nbsp;&nbsp;*expr<sub>3</sub>* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>3</sub>*                                                             |
-</div>
-### Expression<sub>3</sub>  (**expr<sub>3</sub>**)
-<div className="lang-ref-table">
-|                          |        |                                                                                               |
-|--------------------------|--------|-----------------------------------------------------------------------------------------------|
-| *expr<sub>3</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*expr<sub>4</sub>*  |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*&nbsp;&nbsp;<b><tt>&lt;=</tt></b>&nbsp;&nbsp;*expr<sub>4</sub>* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*&nbsp;&nbsp;<b><tt>&gt;=</tt></b>&nbsp;&nbsp;*expr<sub>4</sub>* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*&nbsp;&nbsp;<b><tt>&gt;</tt></b>&nbsp;&nbsp;*expr<sub>4</sub>*  |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*                                                                |
-</div>
-### Expression<sub>4</sub>  (**expr<sub>4</sub>**)
-<div className="lang-ref-table">
-|                          |        |                                                                                |
-|--------------------------|--------|--------------------------------------------------------------------------------|
-| *expr<sub>4</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>4</sub>*&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;*type* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>5</sub>*                                                 |
-</div>
-### Expression<sub>5</sub>  (**expr<sub>5</sub>**)
-<div className="lang-ref-table">
-|                          |        |                                                                                           |
-|--------------------------|--------|-------------------------------------------------------------------------------------------|
-| *expr<sub>5</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>5</sub>*&nbsp;&nbsp;<b><tt>+</tt></b>&nbsp;&nbsp;*expr<sub>6</sub>* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>5</sub>*&nbsp;&nbsp;<b><tt>-</tt></b>&nbsp;&nbsp;*expr<sub>6</sub>* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>6</sub>*                                                            |
-</div>
-### Expression<sub>6</sub>  (**expr<sub>6</sub>**)
-<div className="lang-ref-table">
-|                          |        |                                                                                           |
-|--------------------------|--------|-------------------------------------------------------------------------------------------|
-| *expr<sub>6</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>6</sub>*&nbsp;&nbsp;<b><tt>*</tt></b>&nbsp;&nbsp;*expr<sub>7</sub>* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>7</sub>*                                                            |
-</div>
-### Expression<sub>7</sub>  (**expr<sub>7</sub>**)
-<div className="lang-ref-table">
-|                          |        |                                                             |
-|--------------------------|--------|-------------------------------------------------------------|
-| *expr<sub>7</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;*expr<sub>7</sub>* |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>8</sub>*                              |
-</div>
-### Expression<sub>8</sub>  (**expr<sub>8</sub>**)
-<div className="lang-ref-table">
-|                          |        |                                                                                                                                                                                                                                           |
-|--------------------------|--------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *expr<sub>8</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*expr<sub>8</sub>*&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>]</tt></b>                                                                                                                                |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>8</sub>*&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;*id*                                                                                                                                                               |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>8</sub>*&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *expr* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b> |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*expr<sub>9</sub>*                                                                                                                                                                                                            |
-</div>
-### Expression<sub>9</sub>  (**expr<sub>9</sub>**)
-<div className="lang-ref-table">
-|                          |        |                                                                                                                                                                                                                                                                                                   |
-|--------------------------|--------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *expr<sub>9</sub>*&nbsp; | &rarr; | &nbsp;&nbsp;*fun*&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *expr* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b>                                                                                                                   |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>map</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*fun*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*expr* <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> *expr* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b>                                                 |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>fold</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*fun*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*expr* <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> *expr* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b> |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>slice</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*tsize*&nbsp;&nbsp;<b><tt>&gt;</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>)</tt></b>                                                   |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;*tuple-arg* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *tuple-arg* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b>                                                                                                                          |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;*tuple-arg* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *tuple-arg* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b>                                                                                         |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*tref*&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;*struct-arg* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *struct-arg* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>                                                                                                     |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>assert</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*str*&nbsp;&nbsp;<b><tt>)</tt></b>                                                                                                                                      |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;<b><tt>disclose</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr*&nbsp;&nbsp;<b><tt>)</tt></b>                                                                                                                                                                                  |
-| &nbsp;                   | &rarr; | &nbsp;&nbsp;*term*                                                                                                                                                                                                                                                                                |
-</div>
-### Term  (**term**)
-<div className="lang-ref-table">
-|              |        |                                                                                                                                                          |
-|--------------|--------|----------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *term*&nbsp; | &rarr; | &nbsp;&nbsp;*id*                                                                                                                                         |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>true</tt></b>                                                                                                                         |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>false</tt></b>                                                                                                                        |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*nat*                                                                                                                                        |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;*str*                                                                                                                                        |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>pad</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*nat*&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;*str*&nbsp;&nbsp;<b><tt>)</tt></b> |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>default</tt></b>&nbsp;&nbsp;<b><tt>&lt;</tt></b>&nbsp;&nbsp;*type*&nbsp;&nbsp;<b><tt>&gt;</tt></b>                                    |
-| &nbsp;       | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*expr-seq*&nbsp;&nbsp;<b><tt>)</tt></b>                                                                         |
-</div>
-### Tuple-argument  (**tuple-arg**, **bytes-arg**)
-<div className="lang-ref-table">
-|                   |        |                                                   |
-|-------------------|--------|---------------------------------------------------|
-| *tuple-arg*&nbsp; | &rarr; | &nbsp;&nbsp;*expr*                                |
-| &nbsp;            | &rarr; | &nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;*expr* |
-| *bytes-arg*&nbsp; | &rarr; | &nbsp;&nbsp;*tuple-arg*                           |
-</div>
-### Structure-argument  (**struct-arg**)
-<div className="lang-ref-table">
-|                    |        |                                                                 |
-|--------------------|--------|-----------------------------------------------------------------|
-| *struct-arg*&nbsp; | &rarr; | &nbsp;&nbsp;*expr*                                              |
-| &nbsp;             | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*expr* |
-| &nbsp;             | &rarr; | &nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;*expr*               |
-</div>
-### Function  (**fun**)
-<div className="lang-ref-table">
-|             |        |                                                                                                                               |
-|-------------|--------|-------------------------------------------------------------------------------------------------------------------------------|
-| *fun*&nbsp; | &rarr; | &nbsp;&nbsp;*id*&nbsp;&nbsp;*gargs*<sup>opt</sup>                                                                             |
-| &nbsp;      | &rarr; | &nbsp;&nbsp;*arrow-parameter-list*&nbsp;&nbsp;*return-type*<sup>opt</sup>&nbsp;&nbsp;<b><tt>=&gt;</tt></b>&nbsp;&nbsp;*block* |
-| &nbsp;      | &rarr; | &nbsp;&nbsp;*arrow-parameter-list*&nbsp;&nbsp;*return-type*<sup>opt</sup>&nbsp;&nbsp;<b><tt>=&gt;</tt></b>&nbsp;&nbsp;*expr*  |
-| &nbsp;      | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*fun*&nbsp;&nbsp;<b><tt>)</tt></b>                                                   |
-</div>
-### Return-type  (**return-type**)
-<div className="lang-ref-table">
-|                     |        |                                                 |
-|---------------------|--------|-------------------------------------------------|
-| *return-type*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;*type* |
-</div>
-### Optionally-typed-pattern  (**optionally-typed-pattern**)
-<div className="lang-ref-table">
-|                                  |        |                             |
-|----------------------------------|--------|-----------------------------|
-| *optionally-typed-pattern*&nbsp; | &rarr; | &nbsp;&nbsp;*pattern*       |
-| &nbsp;                           | &rarr; | &nbsp;&nbsp;*typed-pattern* |
-</div>
-### Const-Binding  (**cbinding**)
-<div className="lang-ref-table">
-|                  |        |                                                                                       |
-|------------------|--------|---------------------------------------------------------------------------------------|
-| *cbinding*&nbsp; | &rarr; | &nbsp;&nbsp;*optionally-typed-pattern*&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;*expr* |
-</div>
-### Arrow-parameter-list  (**arrow-parameter-list**)
-<div className="lang-ref-table">
-|                              |        |                                                                                                                                                                                                        |
-|------------------------------|--------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *arrow-parameter-list*&nbsp; | &rarr; | &nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;*optionally-typed-pattern* <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> *optionally-typed-pattern* <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b> |
+
+#### Expression<sub>8</sub> (**expr<sub>8</sub>**)
+
+<div className="lang-ref-table">
+|                    |         |                                                                                    |
+|--------------------|---------|------------------------------------------------------------------------------------|
+| *expr<sub>8</sub>* | &xrarr; | *expr<sub>8</sub>* `[` *expr* `]`                                                  |
+|                    | \|      | *expr<sub>8</sub>* `.` *id*                                                        |
+|                    | \|      | *expr<sub>8</sub>* `.` *id* `(` *expr* `,` &mldr; `,` *expr* `,`<sup>opt</sup> `)` |
+|                    | \|      | *expr<sub>9</sub>*                                                                 |
+</div>
+
+#### Expression<sub>9</sub> (**expr<sub>9</sub>**)
+
+<div className="lang-ref-table">
+|                    |         |                                                                                          |
+|--------------------|---------|------------------------------------------------------------------------------------------|
+| *expr<sub>9</sub>* | &xrarr; | *fun* `(` *expr* `,` &mldr; `,` *expr* `,`<sup>opt</sup> `)`                             |
+|                    | \|      | `map` `(` *fun* `,` *expr* `,` &mldr;&sup1; `,` *expr* `,`<sup>opt</sup> `)`             |
+|                    | \|      | `fold` `(` *fun* `,` *expr* `,` *expr* `,` &mldr;&sup1; `,` *expr* `,`<sup>opt</sup> `)` |
+|                    | \|      | `slice` `<` *tsize* `>` `(` *expr* `,` *expr* `)`                                        |
+|                    | \|      | `[` *tuple-arg* `,` &mldr; `,` *tuple-arg* `,`<sup>opt</sup> `]`                         |
+|                    | \|      | `Bytes` `[` *tuple-arg* `,` &mldr; `,` *tuple-arg* `,`<sup>opt</sup> `]`                 |
+|                    | \|      | *tref* `{` *struct-arg* `,` &mldr; `,` *struct-arg* `,`<sup>opt</sup> `}`                |
+|                    | \|      | `assert` `(` *expr* `,` *str* `)`                                                        |
+|                    | \|      | `disclose` `(` *expr* `)`                                                                |
+|                    | \|      | *term*                                                                                   |
+</div>
+
+#### Term (**term**)
+
+<div className="lang-ref-table">
+|        |         |                               |
+|--------|---------|-------------------------------|
+| *term* | &xrarr; | *id*                          |
+|        | \|      | `true`                        |
+|        | \|      | `false`                       |
+|        | \|      | *nat*                         |
+|        | \|      | *str*                         |
+|        | \|      | `pad` `(` *nat* `,` *str* `)` |
+|        | \|      | `default` `<` *type* `>`      |
+|        | \|      | `(` *expr-seq* `)`            |
+</div>
+
+#### Tuple-argument (**tuple-arg**, **bytes-arg**)
+
+<div className="lang-ref-table">
+|             |         |              |
+|-------------|---------|--------------|
+| *tuple-arg* | &xrarr; | *expr*       |
+|             | \|      | `...` *expr* |
+| *bytes-arg* | &xrarr; | *tuple-arg*  |
+</div>
+
+#### Structure-argument (**struct-arg**)
+
+<div className="lang-ref-table">
+|              |         |                 |
+|--------------|---------|-----------------|
+| *struct-arg* | &xrarr; | *expr*          |
+|              | \|      | *id* `:` *expr* |
+|              | \|      | `...` *expr*    |
+</div>
+
+#### Function (**fun**)
+
+<div className="lang-ref-table">
+|       |         |                                                                 |
+|-------|---------|-----------------------------------------------------------------|
+| *fun* | &xrarr; | *id* *gargs*<sup>opt</sup>                                      |
+|       | \|      | *arrow-parameter-list* *return-type*<sup>opt</sup> `=>` *block* |
+|       | \|      | *arrow-parameter-list* *return-type*<sup>opt</sup> `=>` *expr*  |
+|       | \|      | `(` *fun* `)`                                                   |
+</div>
+
+#### Return-type (**return-type**)
+
+<div className="lang-ref-table">
+|               |         |            |
+|---------------|---------|------------|
+| *return-type* | &xrarr; | `:` *type* |
+</div>
+
+#### Optionally-typed-pattern (**optionally-typed-pattern**)
+
+<div className="lang-ref-table">
+|                            |         |                 |
+|----------------------------|---------|-----------------|
+| *optionally-typed-pattern* | &xrarr; | *pattern*       |
+|                            | \|      | *typed-pattern* |
+</div>
+
+#### Const-Binding (**cbinding**)
+
+<div className="lang-ref-table">
+|            |         |                                       |
+|------------|---------|---------------------------------------|
+| *cbinding* | &xrarr; | *optionally-typed-pattern* `=` *expr* |
+</div>
+
+#### Arrow-parameter-list (**arrow-parameter-list**)
+
+<div className="lang-ref-table">
+|                        |         |                                                                                                |
+|------------------------|---------|------------------------------------------------------------------------------------------------|
+| *arrow-parameter-list* | &xrarr; | `(` *optionally-typed-pattern* `,` &mldr; `,` *optionally-typed-pattern* `,`<sup>opt</sup> `)` |
 </div>
 
diff --git a/src/css/custom.css b/src/css/custom.css
index d47b7e44..c311eb12 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -89,6 +89,10 @@ h6 {
   color: var(--ifm-heading-color);
 }
 
+body h4 {
+  font-size: 1.1rem;
+}
+
 /* ============================================
    MINTLIFY-INSPIRED SIDEBAR STYLES
    ============================================ */
@@ -605,6 +609,7 @@ pre {
 .lang-ref-table {
   border-collapse: separate;
   border-spacing: 0;
+  padding-left: 20px;
   --ifm-table-stripe-background: none;
 }
 
@@ -613,13 +618,16 @@ pre {
 }
 
 .lang-ref-table tbody tr {
-  border: none
+  border: none;
 }
 
 .lang-ref-table td,
 .lang-ref-table th {
   border: none;
-  padding: 1px;
+  padding-top: 1px;
+  padding-bottom: 1px;
+  padding-left: 5px;
+  padding-right: 5px;
   text-align: left;
 }
 

From 05ffc7cc359673c8e95a66193c04001cde7a14bc Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Tue, 10 Mar 2026 06:33:24 +0100
Subject: [PATCH 04/41] limit lang-ref-table to <table> elements

---
 src/css/custom.css | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/css/custom.css b/src/css/custom.css
index c311eb12..7699a371 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -606,7 +606,7 @@ pre {
 }
 
 /* The following table is specific to the Compact reference document */
-.lang-ref-table {
+.lang-ref-table table {
   border-collapse: separate;
   border-spacing: 0;
   padding-left: 20px;
@@ -632,7 +632,7 @@ pre {
 }
 
 .lang-ref-table td:nth-child(2) {
-  text-align: right; /* Right-align the middle column */
+  text-align: center; /* Right-align the middle column */
 }
 
 /* Animate navbar active tab */

From 31a4e4a65d3a5d48319227b4a2224eb042630a6b Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Tue, 10 Mar 2026 06:57:20 +0100
Subject: [PATCH 05/41] latest compact-grammar.mdx complete with link marks and
 references

---
 docs/compact/reference/compact-grammar.mdx | 674 ++++++++++-----------
 1 file changed, 337 insertions(+), 337 deletions(-)

diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index 5c537079..1a49dcc8 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -4,595 +4,595 @@ Compact language version 0.21.0.
 
 Notational note: In the grammar below, terminals are in `monospaced` font. Non-terminals are in *emphasized* font. Alternation is indicated by a vertical bar (`|`). Optional items are indicated by the superscript <sup>opt</sup>. Repetition is specified by ellipses. The notation *X* &mldr; *X*, where *X* is a grammar symbol, represents zero or more occurrences of *X*. The notation *X* `,` &mldr; `,` *X*, where *X* is a grammar symbol and `,` is a literal comma, represents zero or more occurrences of *X* separated by commas. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one *X*. When such a sequence is followed by *,*<sup>opt</sup>, an optional trailing comma is allowed, but only if there is at least one *X*. For example, *id* &mldr; *id* represents zero or more *id*s, and *expr* `,` &mldr;&sup1; `,` *expr* `,`<sup>opt</sup> represents one or more comma-separated *expr*s possibly followed by an extra comma. The rules involving commas apply equally to semicolons, i.e., apply when `,` is replaced by `;`.
 
-#### end-of-file (*eof*)
+#### <a name="end-of-file">end-of-file</a> (*eof*)
 
 End of file.
 
-#### identifier (*id*, *module-name*, *function-name*, *struct-name*, *enum-name*, *contract-name*, *tvar-name*, *type-name*)
+#### <a name="identifier">identifier</a> (*id*, *module-name*, *function-name*, *struct-name*, *enum-name*, *contract-name*, *tvar-name*, *type-name*)
 
 Identifiers have the same syntax as Typescript identifiers.
 
-#### field-literal (*nat*)
+#### <a name="field-literal">field-literal</a> (*nat*)
 
 A field literal is 0 or a natural number formed from a sequence of digits starting with 1-9, e.g. 723, whose value does not exceed the maximum field value.
 
-#### string-literal (*str*, *file*)
+#### <a name="string-literal">string-literal</a> (*str*, *file*)
 
 A string literal has the same syntax as a Typescript string.
 
-#### version-literal (*version*)
+#### <a name="version-literal">version-literal</a> (*version*)
 
 A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2.3, representing major, minor, and bugfix versions.
 
-#### Compact (**program**)
+#### <a name="Compact">Compact</a> (**program**)
 
 <div className="lang-ref-table">
-|           |         |                            |
-|-----------|---------|----------------------------|
-| *program* | &xrarr; | *pelt* &mldr; *pelt* *eof* |
+|           |         |                                                                                    |
+|-----------|---------|------------------------------------------------------------------------------------|
+| *program* | &xrarr; | [*pelt*](#Program-element) &mldr; [*pelt*](#Program-element) [*eof*](#end-of-file) |
 </div>
 
-#### Program-element (**pelt**)
+#### <a name="Program-element">Program-element</a> (**pelt**)
 
 <div className="lang-ref-table">
-|        |         |                          |
-|--------|---------|--------------------------|
-| *pelt* | &xrarr; | *pragma-form*            |
-|        | \|      | *module-definition*      |
-|        | \|      | *import-form*            |
-|        | \|      | *export-form*            |
-|        | \|      | *include-form*           |
-|        | \|      | *struct-declaration*     |
-|        | \|      | *enum-declaration*       |
-|        | \|      | *contract-declaration*   |
-|        | \|      | *type-alias-declaration* |
-|        | \|      | *ledger-declaration*     |
-|        | \|      | *witness-declaration*    |
-|        | \|      | *constructor-definition* |
-|        | \|      | *circuit-definition*     |
+|        |         |                                                          |
+|--------|---------|----------------------------------------------------------|
+| *pelt* | &xrarr; | [*pragma-form*](#Pragma)                                 |
+|        | \|      | [*module-definition*](#Module-definition)                |
+|        | \|      | [*import-form*](#Import-declaration)                     |
+|        | \|      | [*export-form*](#Export-declaration)                     |
+|        | \|      | [*include-form*](#Include)                               |
+|        | \|      | [*struct-declaration*](#Structure-declaration)           |
+|        | \|      | [*enum-declaration*](#Enum-declaration)                  |
+|        | \|      | [*contract-declaration*](#External-contract-declaration) |
+|        | \|      | [*type-alias-declaration*](#Type-declaration)            |
+|        | \|      | [*ledger-declaration*](#Ledger-declaration)              |
+|        | \|      | [*witness-declaration*](#Witness-declaration)            |
+|        | \|      | [*constructor-definition*](#Constructor)                 |
+|        | \|      | [*circuit-definition*](#Circuit-definition)              |
 </div>
 
-#### Pragma (**pragma-form**)
+#### <a name="Pragma">Pragma</a> (**pragma-form**)
 
 <div className="lang-ref-table">
-|               |         |                                  |
-|---------------|---------|----------------------------------|
-| *pragma-form* | &xrarr; | `pragma` *id* *version-expr* `;` |
+|               |         |                                                                        |
+|---------------|---------|------------------------------------------------------------------------|
+| *pragma-form* | &xrarr; | `pragma` [*id*](#identifier) [*version-expr*](#Version-expression) `;` |
 </div>
 
-#### Version-expression (**version-expr**)
+#### <a name="Version-expression">Version-expression</a> (**version-expr**)
 
 <div className="lang-ref-table">
-|                |         |                                                  |
-|----------------|---------|--------------------------------------------------|
-| *version-expr* | &xrarr; | *version-expr* `\|\|` *version-expr<sub>0</sub>* |
-|                | \|      | *version-expr<sub>0</sub>*                       |
+|                |         |                                                                                                 |
+|----------------|---------|-------------------------------------------------------------------------------------------------|
+| *version-expr* | &xrarr; | [*version-expr*](#Version-expression) `\|\|` [*version-expr<sub>0</sub>*](#Version-expression0) |
+|                | \|      | [*version-expr<sub>0</sub>*](#Version-expression0)                                              |
 </div>
 
-#### Version-expression<sub>0</sub> (**version-expr<sub>0</sub>**)
+#### <a name="Version-expression0">Version-expression<sub>0</sub></a> (**version-expr<sub>0</sub>**)
 
 <div className="lang-ref-table">
-|                            |         |                                                |
-|----------------------------|---------|------------------------------------------------|
-| *version-expr<sub>0</sub>* | &xrarr; | *version-expr<sub>0</sub>* `&&` *version-term* |
-|                            | \|      | *version-term*                                 |
+|                            |         |                                                                                         |
+|----------------------------|---------|-----------------------------------------------------------------------------------------|
+| *version-expr<sub>0</sub>* | &xrarr; | [*version-expr<sub>0</sub>*](#Version-expression0) `&&` [*version-term*](#Version-Term) |
+|                            | \|      | [*version-term*](#Version-Term)                                                         |
 </div>
 
-#### Version-Term (**version-term**)
+#### <a name="Version-Term">Version-Term</a> (**version-term**)
 
 <div className="lang-ref-table">
-|                |         |                        |
-|----------------|---------|------------------------|
-| *version-term* | &xrarr; | *version-atom*         |
-|                | \|      | `!` *version-atom*     |
-|                | \|      | `<` *version-atom*     |
-|                | \|      | `<=` *version-atom*    |
-|                | \|      | `>=` *version-atom*    |
-|                | \|      | `>` *version-atom*     |
-|                | \|      | `(` *version-expr* `)` |
+|                |         |                                               |
+|----------------|---------|-----------------------------------------------|
+| *version-term* | &xrarr; | [*version-atom*](#Version-atom)               |
+|                | \|      | `!` [*version-atom*](#Version-atom)           |
+|                | \|      | `<` [*version-atom*](#Version-atom)           |
+|                | \|      | `<=` [*version-atom*](#Version-atom)          |
+|                | \|      | `>=` [*version-atom*](#Version-atom)          |
+|                | \|      | `>` [*version-atom*](#Version-atom)           |
+|                | \|      | `(` [*version-expr*](#Version-expression) `)` |
 </div>
 
-#### Version-atom (**version-atom**)
+#### <a name="Version-atom">Version-atom</a> (**version-atom**)
 
 <div className="lang-ref-table">
-|                |         |           |
-|----------------|---------|-----------|
-| *version-atom* | &xrarr; | *nat*     |
-|                | \|      | *version* |
+|                |         |                               |
+|----------------|---------|-------------------------------|
+| *version-atom* | &xrarr; | [*nat*](#field-literal)       |
+|                | \|      | [*version*](#version-literal) |
 </div>
 
-#### Include (**include-form**)
+#### <a name="Include">Include</a> (**include-form**)
 
 <div className="lang-ref-table">
-|                |         |                      |
-|----------------|---------|----------------------|
-| *include-form* | &xrarr; | `include` *file* `;` |
+|                |         |                                         |
+|----------------|---------|-----------------------------------------|
+| *include-form* | &xrarr; | `include` [*file*](#string-literal) `;` |
 </div>
 
-#### Module-definition (**module-definition**)
+#### <a name="Module-definition">Module-definition</a> (**module-definition**)
 
 <div className="lang-ref-table">
-|                     |         |                                                                                                    |
-|---------------------|---------|----------------------------------------------------------------------------------------------------|
-| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` *module-name* *gparams*<sup>opt</sup> `{` *pelt* &mldr; *pelt* `}` |
+|                     |         |                                                                                                                                                                                      |
+|---------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*pelt*](#Program-element) &mldr; [*pelt*](#Program-element) `}` |
 </div>
 
-#### Generic-parameter-list (**gparams**)
+#### <a name="Generic-parameter-list">Generic-parameter-list</a> (**gparams**)
 
 <div className="lang-ref-table">
-|           |         |                                                                          |
-|-----------|---------|--------------------------------------------------------------------------|
-| *gparams* | &xrarr; | `<` *generic-param* `,` &mldr; `,` *generic-param* `,`<sup>opt</sup> `>` |
+|           |         |                                                                                                                      |
+|-----------|---------|----------------------------------------------------------------------------------------------------------------------|
+| *gparams* | &xrarr; | `<` [*generic-param*](#Generic-parameter) `,` &mldr; `,` [*generic-param*](#Generic-parameter) `,`<sup>opt</sup> `>` |
 </div>
 
-#### Generic-parameter (**generic-param**)
+#### <a name="Generic-parameter">Generic-parameter</a> (**generic-param**)
 
 <div className="lang-ref-table">
-|                 |         |                 |
-|-----------------|---------|-----------------|
-| *generic-param* | &xrarr; | `#` *tvar-name* |
-|                 | \|      | *tvar-name*     |
+|                 |         |                                |
+|-----------------|---------|--------------------------------|
+| *generic-param* | &xrarr; | `#` [*tvar-name*](#identifier) |
+|                 | \|      | [*tvar-name*](#identifier)     |
 </div>
 
-#### Import-declaration (**import-form**)
+#### <a name="Import-declaration">Import-declaration</a> (**import-form**)
 
 <div className="lang-ref-table">
-|               |         |                                                                                                                 |
-|---------------|---------|-----------------------------------------------------------------------------------------------------------------|
-| *import-form* | &xrarr; | `import` *import-selection*<sup>opt</sup> *import-name* *gargs*<sup>opt</sup> *import-prefix*<sup>opt</sup> `;` |
+|               |         |                                                                                                                                                                                                  |
+|---------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *import-form* | &xrarr; | `import` [*import-selection*](#Import-selection)<sup>opt</sup> [*import-name*](#Import-name) [*gargs*](#Generic-argument-list)<sup>opt</sup> [*import-prefix*](#Import-prefix)<sup>opt</sup> `;` |
 </div>
 
-#### Import-selection (**import-selection**)
+#### <a name="Import-selection">Import-selection</a> (**import-selection**)
 
 <div className="lang-ref-table">
-|                    |         |                                                                                   |
-|--------------------|---------|-----------------------------------------------------------------------------------|
-| *import-selection* | &xrarr; | `{` *import-element* `,` &mldr; `,` *import-element* `,`<sup>opt</sup> `}` `from` |
+|                    |         |                                                                                                                         |
+|--------------------|---------|-------------------------------------------------------------------------------------------------------------------------|
+| *import-selection* | &xrarr; | `{` [*import-element*](#Import-element) `,` &mldr; `,` [*import-element*](#Import-element) `,`<sup>opt</sup> `}` `from` |
 </div>
 
-#### Import-element (**import-element**)
+#### <a name="Import-element">Import-element</a> (**import-element**)
 
 <div className="lang-ref-table">
-|                  |         |                |
-|------------------|---------|----------------|
-| *import-element* | &xrarr; | *id*           |
-|                  | \|      | *id* `as` *id* |
+|                  |         |                                              |
+|------------------|---------|----------------------------------------------|
+| *import-element* | &xrarr; | [*id*](#identifier)                          |
+|                  | \|      | [*id*](#identifier) `as` [*id*](#identifier) |
 </div>
 
-#### Import-name (**import-name**)
+#### <a name="Import-name">Import-name</a> (**import-name**)
 
 <div className="lang-ref-table">
-|               |         |        |
-|---------------|---------|--------|
-| *import-name* | &xrarr; | *id*   |
-|               | \|      | *file* |
+|               |         |                           |
+|---------------|---------|---------------------------|
+| *import-name* | &xrarr; | [*id*](#identifier)       |
+|               | \|      | [*file*](#string-literal) |
 </div>
 
-#### Import-prefix (**import-prefix**)
+#### <a name="Import-prefix">Import-prefix</a> (**import-prefix**)
 
 <div className="lang-ref-table">
-|                 |         |               |
-|-----------------|---------|---------------|
-| *import-prefix* | &xrarr; | `prefix` *id* |
+|                 |         |                              |
+|-----------------|---------|------------------------------|
+| *import-prefix* | &xrarr; | `prefix` [*id*](#identifier) |
 </div>
 
-#### Generic-argument-list (**gargs**)
+#### <a name="Generic-argument-list">Generic-argument-list</a> (**gargs**)
 
 <div className="lang-ref-table">
-|         |         |                                                        |
-|---------|---------|--------------------------------------------------------|
-| *gargs* | &xrarr; | `<` *garg* `,` &mldr; `,` *garg* `,`<sup>opt</sup> `>` |
+|         |         |                                                                                                  |
+|---------|---------|--------------------------------------------------------------------------------------------------|
+| *gargs* | &xrarr; | `<` [*garg*](#Generic-argument) `,` &mldr; `,` [*garg*](#Generic-argument) `,`<sup>opt</sup> `>` |
 </div>
 
-#### Generic-argument (**garg**)
+#### <a name="Generic-argument">Generic-argument</a> (**garg**)
 
 <div className="lang-ref-table">
-|        |         |        |
-|--------|---------|--------|
-| *garg* | &xrarr; | *nat*  |
-|        | \|      | *type* |
+|        |         |                         |
+|--------|---------|-------------------------|
+| *garg* | &xrarr; | [*nat*](#field-literal) |
+|        | \|      | [*type*](#Type)         |
 </div>
 
-#### Export-declaration (**export-form**)
+#### <a name="Export-declaration">Export-declaration</a> (**export-form**)
 
 <div className="lang-ref-table">
-|               |         |                                                                               |
-|---------------|---------|-------------------------------------------------------------------------------|
-| *export-form* | &xrarr; | `export` `{` *id* `,` &mldr; `,` *id* `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|               |         |                                                                                                             |
+|---------------|---------|-------------------------------------------------------------------------------------------------------------|
+| *export-form* | &xrarr; | `export` `{` [*id*](#identifier) `,` &mldr; `,` [*id*](#identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### Ledger-declaration (**ledger-declaration**)
+#### <a name="Ledger-declaration">Ledger-declaration</a> (**ledger-declaration**)
 
 <div className="lang-ref-table">
-|                      |         |                                                                            |
-|----------------------|---------|----------------------------------------------------------------------------|
-| *ledger-declaration* | &xrarr; | `export`<sup>opt</sup> `sealed`<sup>opt</sup> `ledger` *id* `:` *type* `;` |
+|                      |         |                                                                                                    |
+|----------------------|---------|----------------------------------------------------------------------------------------------------|
+| *ledger-declaration* | &xrarr; | `export`<sup>opt</sup> `sealed`<sup>opt</sup> `ledger` [*id*](#identifier) `:` [*type*](#Type) `;` |
 </div>
 
-#### Witness-declaration (**witness-declaration**)
+#### <a name="Witness-declaration">Witness-declaration</a> (**witness-declaration**)
 
 <div className="lang-ref-table">
-|                       |         |                                                                                                      |
-|-----------------------|---------|------------------------------------------------------------------------------------------------------|
-| *witness-declaration* | &xrarr; | `export`<sup>opt</sup> `witness` *id* *gparams*<sup>opt</sup> *simple-parameter-list* `:` *type* `;` |
+|                       |         |                                                                                                                                                                                   |
+|-----------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *witness-declaration* | &xrarr; | `export`<sup>opt</sup> `witness` [*id*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> [*simple-parameter-list*](#Simple-parameter-list) `:` [*type*](#Type) `;` |
 </div>
 
-#### Constructor (**constructor-definition**)
+#### <a name="Constructor">Constructor</a> (**constructor-definition**)
 
 <div className="lang-ref-table">
-|                          |         |                                                |
-|--------------------------|---------|------------------------------------------------|
-| *constructor-definition* | &xrarr; | `constructor` *pattern-parameter-list* *block* |
+|                          |         |                                                                                     |
+|--------------------------|---------|-------------------------------------------------------------------------------------|
+| *constructor-definition* | &xrarr; | `constructor` [*pattern-parameter-list*](#Pattern-parameter-list) [*block*](#Block) |
 </div>
 
-#### Circuit-definition (**circuit-definition**)
+#### <a name="Circuit-definition">Circuit-definition</a> (**circuit-definition**)
 
 <div className="lang-ref-table">
-|                      |         |                                                                                                                                           |
-|----------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------|
-| *circuit-definition* | &xrarr; | `export`<sup>opt</sup> `pure`<sup>opt</sup> `circuit` *function-name* *gparams*<sup>opt</sup> *pattern-parameter-list* `:` *type* *block* |
+|                      |         |                                                                                                                                                                                                                                   |
+|----------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *circuit-definition* | &xrarr; | `export`<sup>opt</sup> `pure`<sup>opt</sup> `circuit` [*function-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> [*pattern-parameter-list*](#Pattern-parameter-list) `:` [*type*](#Type) [*block*](#Block) |
 </div>
 
-#### Structure-declaration (**struct-declaration**)
+#### <a name="Structure-declaration">Structure-declaration</a> (**struct-declaration**)
 
 <div className="lang-ref-table">
-|                      |         |                                                                                                                                                                        |
-|----------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *struct-declaration* | &xrarr; | `export`<sup>opt</sup> `struct` *struct-name* *gparams*<sup>opt</sup> `{` *typed-identifier* `;` &mldr; `;` *typed-identifier* `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
-|                      | \|      | `export`<sup>opt</sup> `struct` *struct-name* *gparams*<sup>opt</sup> `{` *typed-identifier* `,` &mldr; `,` *typed-identifier* `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                      |         |                                                                                                                                                                                                                                                            |
+|----------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *struct-declaration* | &xrarr; | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-identifier*](#Typed-identifier) `;` &mldr; `;` [*typed-identifier*](#Typed-identifier) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                      | \|      | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-identifier*](#Typed-identifier) `,` &mldr; `,` [*typed-identifier*](#Typed-identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### Enum-declaration (**enum-declaration**)
+#### <a name="Enum-declaration">Enum-declaration</a> (**enum-declaration**)
 
 <div className="lang-ref-table">
-|                    |         |                                                                                                                      |
-|--------------------|---------|----------------------------------------------------------------------------------------------------------------------|
-| *enum-declaration* | &xrarr; | `export`<sup>opt</sup> `enum` *enum-name* `{` *id* `,` &mldr;&sup1; `,` *id* `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                    |         |                                                                                                                                                                   |
+|--------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *enum-declaration* | &xrarr; | `export`<sup>opt</sup> `enum` [*enum-name*](#identifier) `{` [*id*](#identifier) `,` &mldr;&sup1; `,` [*id*](#identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### External-contract-declaration (**contract-declaration**)
+#### <a name="External-contract-declaration">External-contract-declaration</a> (**contract-declaration**)
 
 <div className="lang-ref-table">
-|                        |         |                                                                                                                                                          |
-|------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *contract-declaration* | &xrarr; | `export`<sup>opt</sup> `contract` *contract-name* `{` *circuit-declaration* `;` &mldr; `;` *circuit-declaration* `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
-|                        | \|      | `export`<sup>opt</sup> `contract` *contract-name* `{` *circuit-declaration* `,` &mldr; `,` *circuit-declaration* `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                        |         |                                                                                                                                                                                                                                     |
+|------------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *contract-declaration* | &xrarr; | `export`<sup>opt</sup> `contract` [*contract-name*](#identifier) `{` [*circuit-declaration*](#External-contract-circuit) `;` &mldr; `;` [*circuit-declaration*](#External-contract-circuit) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                        | \|      | `export`<sup>opt</sup> `contract` [*contract-name*](#identifier) `{` [*circuit-declaration*](#External-contract-circuit) `,` &mldr; `,` [*circuit-declaration*](#External-contract-circuit) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### External-contract-circuit (**circuit-declaration**)
+#### <a name="External-contract-circuit">External-contract-circuit</a> (**circuit-declaration**)
 
 <div className="lang-ref-table">
-|                       |         |                                                                        |
-|-----------------------|---------|------------------------------------------------------------------------|
-| *circuit-declaration* | &xrarr; | `pure`<sup>opt</sup> `circuit` *id* *simple-parameter-list* `:` *type* |
+|                       |         |                                                                                                                          |
+|-----------------------|---------|--------------------------------------------------------------------------------------------------------------------------|
+| *circuit-declaration* | &xrarr; | `pure`<sup>opt</sup> `circuit` [*id*](#identifier) [*simple-parameter-list*](#Simple-parameter-list) `:` [*type*](#Type) |
 </div>
 
-#### Type-declaration (**type-alias-declaration**)
+#### <a name="Type-declaration">Type-declaration</a> (**type-alias-declaration**)
 
 <div className="lang-ref-table">
-|                          |         |                                                                                                      |
-|--------------------------|---------|------------------------------------------------------------------------------------------------------|
-| *type-alias-declaration* | &xrarr; | `export`<sup>opt</sup> `new`<sup>opt</sup> `type` *type-name* *gparams*<sup>opt</sup> `=` *type* `;` |
+|                          |         |                                                                                                                                                         |
+|--------------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *type-alias-declaration* | &xrarr; | `export`<sup>opt</sup> `new`<sup>opt</sup> `type` [*type-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `=` [*type*](#Type) `;` |
 </div>
 
-#### Typed-identifier (**typed-identifier**)
+#### <a name="Typed-identifier">Typed-identifier</a> (**typed-identifier**)
 
 <div className="lang-ref-table">
-|                    |         |                 |
-|--------------------|---------|-----------------|
-| *typed-identifier* | &xrarr; | *id* `:` *type* |
+|                    |         |                                         |
+|--------------------|---------|-----------------------------------------|
+| *typed-identifier* | &xrarr; | [*id*](#identifier) `:` [*type*](#Type) |
 </div>
 
-#### Simple-parameter-list (**simple-parameter-list**)
+#### <a name="Simple-parameter-list">Simple-parameter-list</a> (**simple-parameter-list**)
 
 <div className="lang-ref-table">
-|                         |         |                                                                                |
-|-------------------------|---------|--------------------------------------------------------------------------------|
-| *simple-parameter-list* | &xrarr; | `(` *typed-identifier* `,` &mldr; `,` *typed-identifier* `,`<sup>opt</sup> `)` |
+|                         |         |                                                                                                                          |
+|-------------------------|---------|--------------------------------------------------------------------------------------------------------------------------|
+| *simple-parameter-list* | &xrarr; | `(` [*typed-identifier*](#Typed-identifier) `,` &mldr; `,` [*typed-identifier*](#Typed-identifier) `,`<sup>opt</sup> `)` |
 </div>
 
-#### Typed-pattern (**typed-pattern**)
+#### <a name="Typed-pattern">Typed-pattern</a> (**typed-pattern**)
 
 <div className="lang-ref-table">
-|                 |         |                      |
-|-----------------|---------|----------------------|
-| *typed-pattern* | &xrarr; | *pattern* `:` *type* |
+|                 |         |                                           |
+|-----------------|---------|-------------------------------------------|
+| *typed-pattern* | &xrarr; | [*pattern*](#Pattern) `:` [*type*](#Type) |
 </div>
 
-#### Pattern-parameter-list (**pattern-parameter-list**)
+#### <a name="Pattern-parameter-list">Pattern-parameter-list</a> (**pattern-parameter-list**)
 
 <div className="lang-ref-table">
-|                          |         |                                                                          |
-|--------------------------|---------|--------------------------------------------------------------------------|
-| *pattern-parameter-list* | &xrarr; | `(` *typed-pattern* `,` &mldr; `,` *typed-pattern* `,`<sup>opt</sup> `)` |
+|                          |         |                                                                                                              |
+|--------------------------|---------|--------------------------------------------------------------------------------------------------------------|
+| *pattern-parameter-list* | &xrarr; | `(` [*typed-pattern*](#Typed-pattern) `,` &mldr; `,` [*typed-pattern*](#Typed-pattern) `,`<sup>opt</sup> `)` |
 </div>
 
-#### Type (**type**)
+#### <a name="Type">Type</a> (**type**)
 
 <div className="lang-ref-table">
-|        |         |                                                        |
-|--------|---------|--------------------------------------------------------|
-| *type* | &xrarr; | *tref*                                                 |
-|        | \|      | `Boolean`                                              |
-|        | \|      | `Field`                                                |
-|        | \|      | `Uint` `<` *tsize* `>`                                 |
-|        | \|      | `Uint` `<` *tsize* `..` *tsize* `>`                    |
-|        | \|      | `Bytes` `<` *tsize* `>`                                |
-|        | \|      | `Opaque` `<` *str* `>`                                 |
-|        | \|      | `Vector` `<` *tsize* `,` *type* `>`                    |
-|        | \|      | `[` *type* `,` &mldr; `,` *type* `,`<sup>opt</sup> `]` |
+|        |         |                                                                          |
+|--------|---------|--------------------------------------------------------------------------|
+| *type* | &xrarr; | [*tref*](#Type-reference)                                                |
+|        | \|      | `Boolean`                                                                |
+|        | \|      | `Field`                                                                  |
+|        | \|      | `Uint` `<` [*tsize*](#Type-size) `>`                                     |
+|        | \|      | `Uint` `<` [*tsize*](#Type-size) `..` [*tsize*](#Type-size) `>`          |
+|        | \|      | `Bytes` `<` [*tsize*](#Type-size) `>`                                    |
+|        | \|      | `Opaque` `<` [*str*](#string-literal) `>`                                |
+|        | \|      | `Vector` `<` [*tsize*](#Type-size) `,` [*type*](#Type) `>`               |
+|        | \|      | `[` [*type*](#Type) `,` &mldr; `,` [*type*](#Type) `,`<sup>opt</sup> `]` |
 </div>
 
-#### Type-reference (**tref**)
+#### <a name="Type-reference">Type-reference</a> (**tref**)
 
 <div className="lang-ref-table">
-|        |         |                            |
-|--------|---------|----------------------------|
-| *tref* | &xrarr; | *id* *gargs*<sup>opt</sup> |
+|        |         |                                                                     |
+|--------|---------|---------------------------------------------------------------------|
+| *tref* | &xrarr; | [*id*](#identifier) [*gargs*](#Generic-argument-list)<sup>opt</sup> |
 </div>
 
-#### Type-size (**tsize**)
+#### <a name="Type-size">Type-size</a> (**tsize**)
 
 <div className="lang-ref-table">
-|         |         |       |
-|---------|---------|-------|
-| *tsize* | &xrarr; | *nat* |
-|         | \|      | *id*  |
+|         |         |                         |
+|---------|---------|-------------------------|
+| *tsize* | &xrarr; | [*nat*](#field-literal) |
+|         | \|      | [*id*](#identifier)     |
 </div>
 
-#### Block (**block**)
+#### <a name="Block">Block</a> (**block**)
 
 <div className="lang-ref-table">
-|         |         |                              |
-|---------|---------|------------------------------|
-| *block* | &xrarr; | `{` *stmt* &mldr; *stmt* `}` |
+|         |         |                                                          |
+|---------|---------|----------------------------------------------------------|
+| *block* | &xrarr; | `{` [*stmt*](#Statement) &mldr; [*stmt*](#Statement) `}` |
 </div>
 
-#### Statement (**stmt**)
+#### <a name="Statement">Statement</a> (**stmt**)
 
 <div className="lang-ref-table">
-|        |         |                                |
-|--------|---------|--------------------------------|
-| *stmt* | &xrarr; | `if` `(` *expr-seq* `)` *stmt* |
-|        | \|      | *stmt<sub>0</sub>*             |
+|        |         |                                                                      |
+|--------|---------|----------------------------------------------------------------------|
+| *stmt* | &xrarr; | `if` `(` [*expr-seq*](#Expression-sequence) `)` [*stmt*](#Statement) |
+|        | \|      | [*stmt<sub>0</sub>*](#Statement0)                                    |
 </div>
 
-#### Statement<sub>0</sub> (**stmt<sub>0</sub>**)
+#### <a name="Statement0">Statement<sub>0</sub></a> (**stmt<sub>0</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                                          |
-|--------------------|---------|----------------------------------------------------------|
-| *stmt<sub>0</sub>* | &xrarr; | *expr-seq* `;`                                           |
-|                    | \|      | `const` *cbinding* `,` &mldr;&sup1; `,` *cbinding*  `;`  |
-|                    | \|      | `if` `(` *expr-seq* `)` *stmt<sub>0</sub>* `else` *stmt* |
-|                    | \|      | `for` `(` `const` *id* `of` *nat* `..` *nat* `)` *stmt*  |
-|                    | \|      | `for` `(` `const` *id* `of` *expr-seq* `)` *stmt*        |
-|                    | \|      | `return` *expr-seq* `;`                                  |
-|                    | \|      | `return` `;`                                             |
-|                    | \|      | *block*                                                  |
+|                    |         |                                                                                                                          |
+|--------------------|---------|--------------------------------------------------------------------------------------------------------------------------|
+| *stmt<sub>0</sub>* | &xrarr; | [*expr-seq*](#Expression-sequence) `;`                                                                                   |
+|                    | \|      | `const` [*cbinding*](#Const-Binding) `,` &mldr;&sup1; `,` [*cbinding*](#Const-Binding)  `;`                              |
+|                    | \|      | `if` `(` [*expr-seq*](#Expression-sequence) `)` [*stmt<sub>0</sub>*](#Statement0) `else` [*stmt*](#Statement)            |
+|                    | \|      | `for` `(` `const` [*id*](#identifier) `of` [*nat*](#field-literal) `..` [*nat*](#field-literal) `)` [*stmt*](#Statement) |
+|                    | \|      | `for` `(` `const` [*id*](#identifier) `of` [*expr-seq*](#Expression-sequence) `)` [*stmt*](#Statement)                   |
+|                    | \|      | `return` [*expr-seq*](#Expression-sequence) `;`                                                                          |
+|                    | \|      | `return` `;`                                                                                                             |
+|                    | \|      | [*block*](#Block)                                                                                                        |
 </div>
 
-#### Pattern (**pattern**)
+#### <a name="Pattern">Pattern</a> (**pattern**)
 
 <div className="lang-ref-table">
-|           |         |                                                                                          |
-|-----------|---------|------------------------------------------------------------------------------------------|
-| *pattern* | &xrarr; | *id*                                                                                     |
-|           | \|      | `[` *pattern*<sup>opt</sup> `,` &mldr; `,` *pattern*<sup>opt</sup> `,`<sup>opt</sup> `]` |
-|           | \|      | `{` *pattern-struct-elt* `,` &mldr; `,` *pattern-struct-elt* `,`<sup>opt</sup> `}`       |
+|           |         |                                                                                                                                          |
+|-----------|---------|------------------------------------------------------------------------------------------------------------------------------------------|
+| *pattern* | &xrarr; | [*id*](#identifier)                                                                                                                      |
+|           | \|      | `[` [*pattern*](#Pattern)<sup>opt</sup> `,` &mldr; `,` [*pattern*](#Pattern)<sup>opt</sup> `,`<sup>opt</sup> `]`                         |
+|           | \|      | `{` [*pattern-struct-elt*](#Pattern-struct-element) `,` &mldr; `,` [*pattern-struct-elt*](#Pattern-struct-element) `,`<sup>opt</sup> `}` |
 </div>
 
-#### Pattern-struct-element (**pattern-struct-elt**)
+#### <a name="Pattern-struct-element">Pattern-struct-element</a> (**pattern-struct-elt**)
 
 <div className="lang-ref-table">
-|                      |         |                    |
-|----------------------|---------|--------------------|
-| *pattern-struct-elt* | &xrarr; | *id*               |
-|                      | \|      | *id* `:` *pattern* |
+|                      |         |                                               |
+|----------------------|---------|-----------------------------------------------|
+| *pattern-struct-elt* | &xrarr; | [*id*](#identifier)                           |
+|                      | \|      | [*id*](#identifier) `:` [*pattern*](#Pattern) |
 </div>
 
-#### Expression-sequence (**expr-seq**)
+#### <a name="Expression-sequence">Expression-sequence</a> (**expr-seq**)
 
 <div className="lang-ref-table">
-|            |         |                                                |
-|------------|---------|------------------------------------------------|
-| *expr-seq* | &xrarr; | *expr*                                         |
-|            | \|      | *expr* `,` &mldr;&sup1; `,` *expr*  `,` *expr* |
+|            |         |                                                                                             |
+|------------|---------|---------------------------------------------------------------------------------------------|
+| *expr-seq* | &xrarr; | [*expr*](#Expression)                                                                       |
+|            | \|      | [*expr*](#Expression) `,` &mldr;&sup1; `,` [*expr*](#Expression)  `,` [*expr*](#Expression) |
 </div>
 
-#### Expression (**expr**)
+#### <a name="Expression">Expression</a> (**expr**)
 
 <div className="lang-ref-table">
-|        |         |                                          |
-|--------|---------|------------------------------------------|
-| *expr* | &xrarr; | *expr<sub>0</sub>* `?` *expr* `:` *expr* |
-|        | \|      | *expr<sub>0</sub>* `=` *expr*            |
-|        | \|      | *expr<sub>0</sub>* `+=` *expr*           |
-|        | \|      | *expr<sub>0</sub>* `-=` *expr*           |
-|        | \|      | *expr<sub>0</sub>*                       |
+|        |         |                                                                                        |
+|--------|---------|----------------------------------------------------------------------------------------|
+| *expr* | &xrarr; | [*expr<sub>0</sub>*](#Expression0) `?` [*expr*](#Expression) `:` [*expr*](#Expression) |
+|        | \|      | [*expr<sub>0</sub>*](#Expression0) `=` [*expr*](#Expression)                           |
+|        | \|      | [*expr<sub>0</sub>*](#Expression0) `+=` [*expr*](#Expression)                          |
+|        | \|      | [*expr<sub>0</sub>*](#Expression0) `-=` [*expr*](#Expression)                          |
+|        | \|      | [*expr<sub>0</sub>*](#Expression0)                                                     |
 </div>
 
-#### Expression<sub>0</sub> (**expr<sub>0</sub>**)
+#### <a name="Expression0">Expression<sub>0</sub></a> (**expr<sub>0</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                              |
-|--------------------|---------|----------------------------------------------|
-| *expr<sub>0</sub>* | &xrarr; | *expr<sub>0</sub>* `\|\|` *expr<sub>1</sub>* |
-|                    | \|      | *expr<sub>1</sub>*                           |
+|                    |         |                                                                              |
+|--------------------|---------|------------------------------------------------------------------------------|
+| *expr<sub>0</sub>* | &xrarr; | [*expr<sub>0</sub>*](#Expression0) `\|\|` [*expr<sub>1</sub>*](#Expression1) |
+|                    | \|      | [*expr<sub>1</sub>*](#Expression1)                                           |
 </div>
 
-#### Expression<sub>1</sub> (**expr<sub>1</sub>**)
+#### <a name="Expression1">Expression<sub>1</sub></a> (**expr<sub>1</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                            |
-|--------------------|---------|--------------------------------------------|
-| *expr<sub>1</sub>* | &xrarr; | *expr<sub>1</sub>* `&&` *expr<sub>2</sub>* |
-|                    | \|      | *expr<sub>2</sub>*                         |
+|                    |         |                                                                            |
+|--------------------|---------|----------------------------------------------------------------------------|
+| *expr<sub>1</sub>* | &xrarr; | [*expr<sub>1</sub>*](#Expression1) `&&` [*expr<sub>2</sub>*](#Expression2) |
+|                    | \|      | [*expr<sub>2</sub>*](#Expression2)                                         |
 </div>
 
-#### Expression<sub>2</sub> (**expr<sub>2</sub>**)
+#### <a name="Expression2">Expression<sub>2</sub></a> (**expr<sub>2</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                            |
-|--------------------|---------|--------------------------------------------|
-| *expr<sub>2</sub>* | &xrarr; | *expr<sub>2</sub>* `==` *expr<sub>3</sub>* |
-|                    | \|      | *expr<sub>2</sub>* `!=` *expr<sub>3</sub>* |
-|                    | \|      | *expr<sub>3</sub>*                         |
+|                    |         |                                                                            |
+|--------------------|---------|----------------------------------------------------------------------------|
+| *expr<sub>2</sub>* | &xrarr; | [*expr<sub>2</sub>*](#Expression2) `==` [*expr<sub>3</sub>*](#Expression3) |
+|                    | \|      | [*expr<sub>2</sub>*](#Expression2) `!=` [*expr<sub>3</sub>*](#Expression3) |
+|                    | \|      | [*expr<sub>3</sub>*](#Expression3)                                         |
 </div>
 
-#### Expression<sub>3</sub> (**expr<sub>3</sub>**)
+#### <a name="Expression3">Expression<sub>3</sub></a> (**expr<sub>3</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                            |
-|--------------------|---------|--------------------------------------------|
-| *expr<sub>3</sub>* | &xrarr; | *expr<sub>4</sub>* `<` *expr<sub>4</sub>*  |
-|                    | \|      | *expr<sub>4</sub>* `<=` *expr<sub>4</sub>* |
-|                    | \|      | *expr<sub>4</sub>* `>=` *expr<sub>4</sub>* |
-|                    | \|      | *expr<sub>4</sub>* `>` *expr<sub>4</sub>*  |
-|                    | \|      | *expr<sub>4</sub>*                         |
+|                    |         |                                                                            |
+|--------------------|---------|----------------------------------------------------------------------------|
+| *expr<sub>3</sub>* | &xrarr; | [*expr<sub>4</sub>*](#Expression4) `<` [*expr<sub>4</sub>*](#Expression4)  |
+|                    | \|      | [*expr<sub>4</sub>*](#Expression4) `<=` [*expr<sub>4</sub>*](#Expression4) |
+|                    | \|      | [*expr<sub>4</sub>*](#Expression4) `>=` [*expr<sub>4</sub>*](#Expression4) |
+|                    | \|      | [*expr<sub>4</sub>*](#Expression4) `>` [*expr<sub>4</sub>*](#Expression4)  |
+|                    | \|      | [*expr<sub>4</sub>*](#Expression4)                                         |
 </div>
 
-#### Expression<sub>4</sub> (**expr<sub>4</sub>**)
+#### <a name="Expression4">Expression<sub>4</sub></a> (**expr<sub>4</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                |
-|--------------------|---------|--------------------------------|
-| *expr<sub>4</sub>* | &xrarr; | *expr<sub>4</sub>* `as` *type* |
-|                    | \|      | *expr<sub>5</sub>*             |
+|                    |         |                                                         |
+|--------------------|---------|---------------------------------------------------------|
+| *expr<sub>4</sub>* | &xrarr; | [*expr<sub>4</sub>*](#Expression4) `as` [*type*](#Type) |
+|                    | \|      | [*expr<sub>5</sub>*](#Expression5)                      |
 </div>
 
-#### Expression<sub>5</sub> (**expr<sub>5</sub>**)
+#### <a name="Expression5">Expression<sub>5</sub></a> (**expr<sub>5</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                           |
-|--------------------|---------|-------------------------------------------|
-| *expr<sub>5</sub>* | &xrarr; | *expr<sub>5</sub>* `+` *expr<sub>6</sub>* |
-|                    | \|      | *expr<sub>5</sub>* `-` *expr<sub>6</sub>* |
-|                    | \|      | *expr<sub>6</sub>*                        |
+|                    |         |                                                                           |
+|--------------------|---------|---------------------------------------------------------------------------|
+| *expr<sub>5</sub>* | &xrarr; | [*expr<sub>5</sub>*](#Expression5) `+` [*expr<sub>6</sub>*](#Expression6) |
+|                    | \|      | [*expr<sub>5</sub>*](#Expression5) `-` [*expr<sub>6</sub>*](#Expression6) |
+|                    | \|      | [*expr<sub>6</sub>*](#Expression6)                                        |
 </div>
 
-#### Expression<sub>6</sub> (**expr<sub>6</sub>**)
+#### <a name="Expression6">Expression<sub>6</sub></a> (**expr<sub>6</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                           |
-|--------------------|---------|-------------------------------------------|
-| *expr<sub>6</sub>* | &xrarr; | *expr<sub>6</sub>* `*` *expr<sub>7</sub>* |
-|                    | \|      | *expr<sub>7</sub>*                        |
+|                    |         |                                                                           |
+|--------------------|---------|---------------------------------------------------------------------------|
+| *expr<sub>6</sub>* | &xrarr; | [*expr<sub>6</sub>*](#Expression6) `*` [*expr<sub>7</sub>*](#Expression7) |
+|                    | \|      | [*expr<sub>7</sub>*](#Expression7)                                        |
 </div>
 
-#### Expression<sub>7</sub> (**expr<sub>7</sub>**)
+#### <a name="Expression7">Expression<sub>7</sub></a> (**expr<sub>7</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                        |
-|--------------------|---------|------------------------|
-| *expr<sub>7</sub>* | &xrarr; | `!` *expr<sub>7</sub>* |
-|                    | \|      | *expr<sub>8</sub>*     |
+|                    |         |                                        |
+|--------------------|---------|----------------------------------------|
+| *expr<sub>7</sub>* | &xrarr; | `!` [*expr<sub>7</sub>*](#Expression7) |
+|                    | \|      | [*expr<sub>8</sub>*](#Expression8)     |
 </div>
 
-#### Expression<sub>8</sub> (**expr<sub>8</sub>**)
+#### <a name="Expression8">Expression<sub>8</sub></a> (**expr<sub>8</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                                                                    |
-|--------------------|---------|------------------------------------------------------------------------------------|
-| *expr<sub>8</sub>* | &xrarr; | *expr<sub>8</sub>* `[` *expr* `]`                                                  |
-|                    | \|      | *expr<sub>8</sub>* `.` *id*                                                        |
-|                    | \|      | *expr<sub>8</sub>* `.` *id* `(` *expr* `,` &mldr; `,` *expr* `,`<sup>opt</sup> `)` |
-|                    | \|      | *expr<sub>9</sub>*                                                                 |
+|                    |         |                                                                                                                                                 |
+|--------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------|
+| *expr<sub>8</sub>* | &xrarr; | [*expr<sub>8</sub>*](#Expression8) `[` [*expr*](#Expression) `]`                                                                                |
+|                    | \|      | [*expr<sub>8</sub>*](#Expression8) `.` [*id*](#identifier)                                                                                      |
+|                    | \|      | [*expr<sub>8</sub>*](#Expression8) `.` [*id*](#identifier) `(` [*expr*](#Expression) `,` &mldr; `,` [*expr*](#Expression) `,`<sup>opt</sup> `)` |
+|                    | \|      | [*expr<sub>9</sub>*](#Expression9)                                                                                                              |
 </div>
 
-#### Expression<sub>9</sub> (**expr<sub>9</sub>**)
+#### <a name="Expression9">Expression<sub>9</sub></a> (**expr<sub>9</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                                                                          |
-|--------------------|---------|------------------------------------------------------------------------------------------|
-| *expr<sub>9</sub>* | &xrarr; | *fun* `(` *expr* `,` &mldr; `,` *expr* `,`<sup>opt</sup> `)`                             |
-|                    | \|      | `map` `(` *fun* `,` *expr* `,` &mldr;&sup1; `,` *expr* `,`<sup>opt</sup> `)`             |
-|                    | \|      | `fold` `(` *fun* `,` *expr* `,` *expr* `,` &mldr;&sup1; `,` *expr* `,`<sup>opt</sup> `)` |
-|                    | \|      | `slice` `<` *tsize* `>` `(` *expr* `,` *expr* `)`                                        |
-|                    | \|      | `[` *tuple-arg* `,` &mldr; `,` *tuple-arg* `,`<sup>opt</sup> `]`                         |
-|                    | \|      | `Bytes` `[` *tuple-arg* `,` &mldr; `,` *tuple-arg* `,`<sup>opt</sup> `]`                 |
-|                    | \|      | *tref* `{` *struct-arg* `,` &mldr; `,` *struct-arg* `,`<sup>opt</sup> `}`                |
-|                    | \|      | `assert` `(` *expr* `,` *str* `)`                                                        |
-|                    | \|      | `disclose` `(` *expr* `)`                                                                |
-|                    | \|      | *term*                                                                                   |
+|                    |         |                                                                                                                                                    |
+|--------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------|
+| *expr<sub>9</sub>* | &xrarr; | [*fun*](#Function) `(` [*expr*](#Expression) `,` &mldr; `,` [*expr*](#Expression) `,`<sup>opt</sup> `)`                                            |
+|                    | \|      | `map` `(` [*fun*](#Function) `,` [*expr*](#Expression) `,` &mldr;&sup1; `,` [*expr*](#Expression) `,`<sup>opt</sup> `)`                            |
+|                    | \|      | `fold` `(` [*fun*](#Function) `,` [*expr*](#Expression) `,` [*expr*](#Expression) `,` &mldr;&sup1; `,` [*expr*](#Expression) `,`<sup>opt</sup> `)` |
+|                    | \|      | `slice` `<` [*tsize*](#Type-size) `>` `(` [*expr*](#Expression) `,` [*expr*](#Expression) `)`                                                      |
+|                    | \|      | `[` [*tuple-arg*](#Tuple-argument) `,` &mldr; `,` [*tuple-arg*](#Tuple-argument) `,`<sup>opt</sup> `]`                                             |
+|                    | \|      | `Bytes` `[` [*tuple-arg*](#Tuple-argument) `,` &mldr; `,` [*tuple-arg*](#Tuple-argument) `,`<sup>opt</sup> `]`                                     |
+|                    | \|      | [*tref*](#Type-reference) `{` [*struct-arg*](#Structure-argument) `,` &mldr; `,` [*struct-arg*](#Structure-argument) `,`<sup>opt</sup> `}`         |
+|                    | \|      | `assert` `(` [*expr*](#Expression) `,` [*str*](#string-literal) `)`                                                                                |
+|                    | \|      | `disclose` `(` [*expr*](#Expression) `)`                                                                                                           |
+|                    | \|      | [*term*](#Term)                                                                                                                                    |
 </div>
 
-#### Term (**term**)
+#### <a name="Term">Term</a> (**term**)
 
 <div className="lang-ref-table">
-|        |         |                               |
-|--------|---------|-------------------------------|
-| *term* | &xrarr; | *id*                          |
-|        | \|      | `true`                        |
-|        | \|      | `false`                       |
-|        | \|      | *nat*                         |
-|        | \|      | *str*                         |
-|        | \|      | `pad` `(` *nat* `,` *str* `)` |
-|        | \|      | `default` `<` *type* `>`      |
-|        | \|      | `(` *expr-seq* `)`            |
+|        |         |                                                                    |
+|--------|---------|--------------------------------------------------------------------|
+| *term* | &xrarr; | [*id*](#identifier)                                                |
+|        | \|      | `true`                                                             |
+|        | \|      | `false`                                                            |
+|        | \|      | [*nat*](#field-literal)                                            |
+|        | \|      | [*str*](#string-literal)                                           |
+|        | \|      | `pad` `(` [*nat*](#field-literal) `,` [*str*](#string-literal) `)` |
+|        | \|      | `default` `<` [*type*](#Type) `>`                                  |
+|        | \|      | `(` [*expr-seq*](#Expression-sequence) `)`                         |
 </div>
 
-#### Tuple-argument (**tuple-arg**, **bytes-arg**)
+#### <a name="Tuple-argument">Tuple-argument</a> (**tuple-arg**, **bytes-arg**)
 
 <div className="lang-ref-table">
-|             |         |              |
-|-------------|---------|--------------|
-| *tuple-arg* | &xrarr; | *expr*       |
-|             | \|      | `...` *expr* |
-| *bytes-arg* | &xrarr; | *tuple-arg*  |
+|             |         |                             |
+|-------------|---------|-----------------------------|
+| *tuple-arg* | &xrarr; | [*expr*](#Expression)       |
+|             | \|      | `...` [*expr*](#Expression) |
+| *bytes-arg* | &xrarr; | *tuple-arg*                 |
 </div>
 
-#### Structure-argument (**struct-arg**)
+#### <a name="Structure-argument">Structure-argument</a> (**struct-arg**)
 
 <div className="lang-ref-table">
-|              |         |                 |
-|--------------|---------|-----------------|
-| *struct-arg* | &xrarr; | *expr*          |
-|              | \|      | *id* `:` *expr* |
-|              | \|      | `...` *expr*    |
+|              |         |                                               |
+|--------------|---------|-----------------------------------------------|
+| *struct-arg* | &xrarr; | [*expr*](#Expression)                         |
+|              | \|      | [*id*](#identifier) `:` [*expr*](#Expression) |
+|              | \|      | `...` [*expr*](#Expression)                   |
 </div>
 
-#### Function (**fun**)
+#### <a name="Function">Function</a> (**fun**)
 
 <div className="lang-ref-table">
-|       |         |                                                                 |
-|-------|---------|-----------------------------------------------------------------|
-| *fun* | &xrarr; | *id* *gargs*<sup>opt</sup>                                      |
-|       | \|      | *arrow-parameter-list* *return-type*<sup>opt</sup> `=>` *block* |
-|       | \|      | *arrow-parameter-list* *return-type*<sup>opt</sup> `=>` *expr*  |
-|       | \|      | `(` *fun* `)`                                                   |
+|       |         |                                                                                                                        |
+|-------|---------|------------------------------------------------------------------------------------------------------------------------|
+| *fun* | &xrarr; | [*id*](#identifier) [*gargs*](#Generic-argument-list)<sup>opt</sup>                                                    |
+|       | \|      | [*arrow-parameter-list*](#Arrow-parameter-list) [*return-type*](#Return-type)<sup>opt</sup> `=>` [*block*](#Block)     |
+|       | \|      | [*arrow-parameter-list*](#Arrow-parameter-list) [*return-type*](#Return-type)<sup>opt</sup> `=>` [*expr*](#Expression) |
+|       | \|      | `(` [*fun*](#Function) `)`                                                                                             |
 </div>
 
-#### Return-type (**return-type**)
+#### <a name="Return-type">Return-type</a> (**return-type**)
 
 <div className="lang-ref-table">
-|               |         |            |
-|---------------|---------|------------|
-| *return-type* | &xrarr; | `:` *type* |
+|               |         |                     |
+|---------------|---------|---------------------|
+| *return-type* | &xrarr; | `:` [*type*](#Type) |
 </div>
 
-#### Optionally-typed-pattern (**optionally-typed-pattern**)
+#### <a name="Optionally-typed-pattern">Optionally-typed-pattern</a> (**optionally-typed-pattern**)
 
 <div className="lang-ref-table">
-|                            |         |                 |
-|----------------------------|---------|-----------------|
-| *optionally-typed-pattern* | &xrarr; | *pattern*       |
-|                            | \|      | *typed-pattern* |
+|                            |         |                                   |
+|----------------------------|---------|-----------------------------------|
+| *optionally-typed-pattern* | &xrarr; | [*pattern*](#Pattern)             |
+|                            | \|      | [*typed-pattern*](#Typed-pattern) |
 </div>
 
-#### Const-Binding (**cbinding**)
+#### <a name="Const-Binding">Const-Binding</a> (**cbinding**)
 
 <div className="lang-ref-table">
-|            |         |                                       |
-|------------|---------|---------------------------------------|
-| *cbinding* | &xrarr; | *optionally-typed-pattern* `=` *expr* |
+|            |         |                                                                                   |
+|------------|---------|-----------------------------------------------------------------------------------|
+| *cbinding* | &xrarr; | [*optionally-typed-pattern*](#Optionally-typed-pattern) `=` [*expr*](#Expression) |
 </div>
 
-#### Arrow-parameter-list (**arrow-parameter-list**)
+#### <a name="Arrow-parameter-list">Arrow-parameter-list</a> (**arrow-parameter-list**)
 
 <div className="lang-ref-table">
-|                        |         |                                                                                                |
-|------------------------|---------|------------------------------------------------------------------------------------------------|
-| *arrow-parameter-list* | &xrarr; | `(` *optionally-typed-pattern* `,` &mldr; `,` *optionally-typed-pattern* `,`<sup>opt</sup> `)` |
+|                        |         |                                                                                                                                                          |
+|------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *arrow-parameter-list* | &xrarr; | `(` [*optionally-typed-pattern*](#Optionally-typed-pattern) `,` &mldr; `,` [*optionally-typed-pattern*](#Optionally-typed-pattern) `,`<sup>opt</sup> `)` |
 </div>
 

From 23de83dd887a14e7b42d30990cdbd5202d36bae2 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Tue, 10 Mar 2026 07:04:22 +0100
Subject: [PATCH 06/41] backed out limiting lang-ref-table to table elements
 for now because it doesn't work when included in <table ...>, only when
 introduced outside of <table>...</table>

---
 src/css/custom.css | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/css/custom.css b/src/css/custom.css
index 7699a371..07575102 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -606,7 +606,7 @@ pre {
 }
 
 /* The following table is specific to the Compact reference document */
-.lang-ref-table table {
+.lang-ref-table {
   border-collapse: separate;
   border-spacing: 0;
   padding-left: 20px;

From ca4cba94d187e4afd2bde30c999f78adb71fd195 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Tue, 10 Mar 2026 07:22:24 +0100
Subject: [PATCH 07/41] latest lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 106 ++++++++++++----------------
 1 file changed, 46 insertions(+), 60 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 737f140c..d32b5f2e 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -88,26 +88,25 @@ separately.
 The syntax of Compact programs is given by an EBNF grammar.  We use the
 following notational conventions in the grammar:
 
-- Terminals are in <b><tt>bold monospaced</tt></b> font
-- Non-terminals are in <em>emphasized</em> font
-- Alternation is indicated by a vertical bar (`|`)
-- Optional items are indicated by a superscript <sup>opt</sup>
-- Repetition is specified by ellipses. The
-  notation <em>X</em> ... <em>X</em>, where <em>X</em> is a grammar symbol,
-  represents zero or more occurrences of <em>X</em>. The notation <em>X</em>
-  <b><tt>,</tt></b> ... <b><tt>,</tt></b> <em>X</em>, where <em>X</em> is a
-  grammar symbol and <b><tt>,</tt></b> is a literal comma, represents zero or more
-  occurrences of <em>X</em> separated by commas. In either case, when
-  the ellipsis is marked with the superscript 1, the notation represents a
-  sequence containing at least one <em>X</em>. When such a sequence is followed
-  by <em>,</em><sup>opt</sup>, an optional trailing comma is allowed, but
-  only if there is at least one <em>X</em>. For example, <em>id</em> &mldr;
-  <em>id</em> represents zero or more <em>id</em>s, and <em>expr</em>
-  <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em>
-  <b><tt>,</tt></b><sup>opt</sup> represents one or more comma-separated
-  <em>expr</em>s possibly followed by an extra comma.
+- Terminals are in `monospaced` font.
+- Non-terminals are in *emphasized* font.
+- Alternation is indicated by a vertical bar (`|`).
+- Optional items are indicated by the superscript <sup>opt</sup>.
+- Repetition is specified by ellipses.
+  The notation *X* &mldr; *X*, where *X* is a grammar symbol, represents zero
+  or more occurrences of *X*.
+  The notation *X* `,` &mldr; `,` *X*, where *X* is a grammar symbol and
+  `,` is a literal comma, represents zero or more occurrences of *X*
+  separated by commas.
+  In either case, when the ellipsis is marked with the superscript 1,
+  the notation represents a sequence containing at least one *X*.
+  When such a sequence is followed by *,*<sup>opt</sup>, an optional
+  trailing comma is allowed, but only if there is at least one *X*.
+  For example, *id* &mldr; *id* represents zero or more *id*s, and
+  *expr* `,` &mldr;&sup1; `,` *expr* `,`<sup>opt</sup> represents one
+  or more comma-separated *expr*s possibly followed by an extra comma.
   The rules involving commas apply equally to semicolons, i.e., apply when
-  <b><tt>,</tt></b> is replaced by <b><tt>;</tt></b>.
+  `,` is replaced by `;`.
 
 ## Static and dynamic errors
 
@@ -422,7 +421,7 @@ They can also define structural and nominal aliases for existing types.
 
 #### Structure types
 
-Structure types are defined via a `struct` declaration with the following form:
+Structure types are defined via `struct` declarations with the following form:
 
 <table className="lang-ref-table"><tbody><tr><td><em>struct-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> <em>typed-identifier</em> <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>typed-identifier</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr>
 <tr><td><em>typed-identifier</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
@@ -524,23 +523,14 @@ export circuit doesntWork(s: Even): Odd {
 }
 ```
 
-Values of structure types are created with **structure-creation** expressions.
-These consist of the structure type (specialized if generic),
-followed by a sequence of field values enclosed in curly braces (`{ }`).
-Element values can be given positionally, in the same order as they are declared
-in the `struct` declaration; or they can be named using the element names from
-the declaration.
-Named element values can appear in any order.
-Positional and named element values can be mixed in the same structure creation
-expression, but all the positional ones must come before any of the named ones.
-See [Structure creation](#structure-creation) for the details.
-
-Using the example declarations above, structure values could be created with
-`Thing {[0, 1, 2], true}` or `NumberAnd<Uint<8>> { item: 255, num: 0 }`.
+Values of structure types are created with
+[**structure-creation** expressions](#structure-creation)
+and accessed via
+[**structure-member-access** expressions](#structure-member-access).
 
 #### Enumeration types
 
-Enumeration types are defined via a `enum` declaration with the following form:
+Enumeration types are defined via `enum` declarations with the following form:
 
 <table className="lang-ref-table"><tbody><tr><td><em>enum-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>enum</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>enum-name</em></a>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></tbody></table>
 
@@ -562,9 +552,9 @@ names (in the same order) and distinct otherwise.
 
 #### Contract types
 
-As of this writing, declarations of contracts and the cross-contract calls they
-support are not yet fully implemented, but the keyword `contract` used to
-declare contracts is reserved for this use.
+Compact 1.0 does not fully implement declarations of contracts and the
+cross-contract calls they support, but the keyword `contract` used to declare
+contracts is reserved for this use.
 
 #### Type aliases
 
@@ -576,22 +566,28 @@ Within the scope of a type-alias declaration of *type-name* for *type*, *type-na
 is itself a type.
 Type aliases are either structural or nominal, depending on whether the optional
 `new` modifier is present:
+
 - A type alias *type-name* for *type* declared without the optional `new` modifier
   is a structural type alias, i.e., *type-name* is the same type and is fully
-  interchangeable with `type`.
+  interchangeable with *type*.
 - A type alias *type-name* for *type* declared with the optional `new` modifier is
   a nominal type alias, i.e., *type-name* is a distinct type compatible with *type*
   but neither a subtype of nor a supertype of *type* (or any other type).
 
 Any nominal type alias *type-name* for some type *type* is compatible with
 *type* in the following senses:
+
 - values of type *type-name* have the same representation as values of type *type*
 - values of type *type-name* can be used by primitive operations that require
   a value of type *type*
 - values of type *type-name* can be cast explicitly to *type*, and
 - values of type *type* can be cast explicitly to type *type-name*.
-For example, within the scope of `type V3U16 = Vector<3,
-Uint<16>>`, a value of type `V3U16` can be referenced or sliced just like a vector
+
+For example, within the scope of
+```compact
+new type V3U16 = Vector<3, Uint<16>>
+```
+a value of type `V3U16` can be referenced or sliced just like a vector
 of type `Vector<3, Uint<16>>`, but it cannot, for example, be passed to a function
 that expects a value of type `Vector<3, Uint<16>>` without an explicit cast.
 
@@ -1633,8 +1629,6 @@ type.
 For example, in the following code, the binding for `x` has type `Boolean`, and
 the binding for `y` has type `[Uint<64>, Uint<64>]`:
 
-!!!!!!!! TBD test this
-
 ```compact
 witness w(): [Boolean, [Uint<16>, Uint<32>]];
 circuit foo(): [Uint<64>, Uint<64>] {
@@ -1646,8 +1640,6 @@ circuit foo(): [Uint<64>, Uint<64>] {
 while in the following, `x` still has type `Boolean` but `y` has (the inferred)
 type `[Uint<16>, Uint<64>]`.
 
-!!!!!!!! TBD test this
-
 ```compact
 witness w(): [Boolean, [Uint<16>, Uint<32>]];
 circuit foo(): [Uint<64>, Uint<64>] {
@@ -1664,9 +1656,10 @@ For example, the reference to `x` on the first line of the body in the
 definition of `foo` below is a static error:
 
 ```compact
-circuit foo(x: Uint<16>): Field {
-  return x;
+circuit foo(a: Uint<16>): Field {
+  const y = x + a;
   const x = 7;
+  return y;
 }
 ```
 
@@ -1830,7 +1823,7 @@ The syntax of Compact expressions is summarized by the following grammar snippet
 <tr><td><em>expr<sub>7</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<em>expr<sub>7</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em></td></tr>
 <tr><td><em>expr<sub>8</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>9</sub></em></td></tr>
 <tr><td><em>expr<sub>9</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>map</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>fold</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>slice</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>tuple-arg</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>tuple-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>bytes-arg</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>bytes-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#primitive-types"><em>tref</em></a>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>struct-arg</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>struct-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>assert</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>disclose</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>term</em></td></tr>
-<tr><td><em>tuple-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td><em>bytes-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>tuple-arg</em></td></tr>
+<tr><td><em>tuple-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td><em>bytes-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>tuple-arg</em></td></tr>
 <tr><td><em>struct-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr>
 <tr><td><em>term</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>true</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>false</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>pad</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>default</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr-seq</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></tbody></table>
 
@@ -1961,10 +1954,8 @@ generic module or circuit in which a reference to a generic natural-number param
 occurs in an expression context.
 For example, if `foo` is defined as follows:
 
-!!!!!!!! TBD test this
-
 ```compact
-circuit foo<#N>(): Unsigned<16> {
+circuit foo<#N>(): Uint<16> {
   return N;
 }
 ```
@@ -1972,10 +1963,8 @@ circuit foo<#N>(): Unsigned<16> {
 the call `foo<17>()`, at least in effect, gives rise to a copy of `foo` in
 which `N` has been replaced by `17`.
 
-!!!!!!!! TBD test this
-
 ```compact
-circuit foo(): Unsigned<16> {
+circuit foo(): Uint<16> {
   return 17;
 }
 ```
@@ -2239,8 +2228,6 @@ type with the value cast back to `T`, which can result in a run-time error if
 `T` is a nominal alias for a type `Uint<0..n>` and the value is not less than `n`.
 For example:
 
-!!!!!!!! TBD test this
-
 ```compact
 new type Feet = Uint<32>;
 circuit foo(x: Feet, y: Feet, scale: Uint<32>): Feet {
@@ -2374,10 +2361,8 @@ compile-time constant value of `index` and `k` is the constant value of `size`.
 
 For example, if `getMiddle` is defined as follows:
 
-!!!!!!!! TBD test this
-
 ```compact
-export circuit foo(x: Bytes<5>): Bytes<3> {
+export circuit getMiddle(x: Bytes<5>): Bytes<3> {
   return slice<3>(x, 1);
 }
 ```
@@ -2734,8 +2719,9 @@ Any cast not covered by one of the rules is not allowed.
 
 !!!!!!!! TBD verify all of these claims -- Parisa
 
-In meeting convo: Do we have all the cases for downcast? check the code in analysis pass to see if it does
-what the claims say. the downcast isn't correct, even the example isn't correct.
+!!!!!!!! TBD mention of cast of state-ledger types ?
+
+!!!!!!!! TBD ??? In meeting convo: Do we have all the cases for downcast? check the code in analysis pass to see if it does what the claims say. the downcast isn't correct, even the example isn't correct.
 
 #### Upcasts
 

From 8c23acca90f12e1386a8bca68b99a6a8c7dd946b Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Tue, 10 Mar 2026 15:27:45 +0100
Subject: [PATCH 08/41] latest lang-ref.mdx and compact-grammar.mdx

---
 docs/compact/reference/compact-grammar.mdx | 162 ++++++++++-----------
 docs/compact/reference/lang-ref.mdx        | 125 ++++++++--------
 2 files changed, 143 insertions(+), 144 deletions(-)

diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index 1a49dcc8..66960f59 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -2,7 +2,7 @@
 
 Compact language version 0.21.0.
 
-Notational note: In the grammar below, terminals are in `monospaced` font. Non-terminals are in *emphasized* font. Alternation is indicated by a vertical bar (`|`). Optional items are indicated by the superscript <sup>opt</sup>. Repetition is specified by ellipses. The notation *X* &mldr; *X*, where *X* is a grammar symbol, represents zero or more occurrences of *X*. The notation *X* `,` &mldr; `,` *X*, where *X* is a grammar symbol and `,` is a literal comma, represents zero or more occurrences of *X* separated by commas. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one *X*. When such a sequence is followed by *,*<sup>opt</sup>, an optional trailing comma is allowed, but only if there is at least one *X*. For example, *id* &mldr; *id* represents zero or more *id*s, and *expr* `,` &mldr;&sup1; `,` *expr* `,`<sup>opt</sup> represents one or more comma-separated *expr*s possibly followed by an extra comma. The rules involving commas apply equally to semicolons, i.e., apply when `,` is replaced by `;`.
+Notational note: In the grammar below, terminals are in `monospaced` font. Non-terminals are in *emphasized* font. Alternation is indicated by a vertical bar (`|`). Optional items are indicated by the superscript <sup>opt</sup>. Repetition is specified by ellipses. The notation *X* ⋯ *X*, where *X* is a grammar symbol, represents zero or more occurrences of *X*. The notation *X* `,` ⋯ `,` *X*, where *X* is a grammar symbol and `,` is a literal comma, represents zero or more occurrences of *X* separated by commas. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one *X*. When such a sequence is followed by *,*<sup>opt</sup>, an optional trailing comma is allowed, but only if there is at least one *X*. For example, *id* ⋯ *id* represents zero or more *id*s, and *expr* `,` ⋯¹`,` *expr* `,`<sup>opt</sup> represents one or more comma-separated *expr*s possibly followed by an extra comma. The rules involving commas apply equally to semicolons, i.e., apply when `,` is replaced by `;`.
 
 #### <a name="end-of-file">end-of-file</a> (*eof*)
 
@@ -27,9 +27,9 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Compact">Compact</a> (**program**)
 
 <div className="lang-ref-table">
-|           |         |                                                                                    |
-|-----------|---------|------------------------------------------------------------------------------------|
-| *program* | &xrarr; | [*pelt*](#Program-element) &mldr; [*pelt*](#Program-element) [*eof*](#end-of-file) |
+|           |         |                                                                               |
+|-----------|---------|-------------------------------------------------------------------------------|
+| *program* | &xrarr; | [*pelt*](#Program-element) ⋯ [*pelt*](#Program-element) [*eof*](#end-of-file) |
 </div>
 
 #### <a name="Program-element">Program-element</a> (**pelt**)
@@ -112,17 +112,17 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Module-definition">Module-definition</a> (**module-definition**)
 
 <div className="lang-ref-table">
-|                     |         |                                                                                                                                                                                      |
-|---------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*pelt*](#Program-element) &mldr; [*pelt*](#Program-element) `}` |
+|                     |         |                                                                                                                                                                                 |
+|---------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*pelt*](#Program-element) ⋯ [*pelt*](#Program-element) `}` |
 </div>
 
 #### <a name="Generic-parameter-list">Generic-parameter-list</a> (**gparams**)
 
 <div className="lang-ref-table">
-|           |         |                                                                                                                      |
-|-----------|---------|----------------------------------------------------------------------------------------------------------------------|
-| *gparams* | &xrarr; | `<` [*generic-param*](#Generic-parameter) `,` &mldr; `,` [*generic-param*](#Generic-parameter) `,`<sup>opt</sup> `>` |
+|           |         |                                                                                                                 |
+|-----------|---------|-----------------------------------------------------------------------------------------------------------------|
+| *gparams* | &xrarr; | `<` [*generic-param*](#Generic-parameter) `,` ⋯ `,` [*generic-param*](#Generic-parameter) `,`<sup>opt</sup> `>` |
 </div>
 
 #### <a name="Generic-parameter">Generic-parameter</a> (**generic-param**)
@@ -145,9 +145,9 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Import-selection">Import-selection</a> (**import-selection**)
 
 <div className="lang-ref-table">
-|                    |         |                                                                                                                         |
-|--------------------|---------|-------------------------------------------------------------------------------------------------------------------------|
-| *import-selection* | &xrarr; | `{` [*import-element*](#Import-element) `,` &mldr; `,` [*import-element*](#Import-element) `,`<sup>opt</sup> `}` `from` |
+|                    |         |                                                                                                                    |
+|--------------------|---------|--------------------------------------------------------------------------------------------------------------------|
+| *import-selection* | &xrarr; | `{` [*import-element*](#Import-element) `,` ⋯ `,` [*import-element*](#Import-element) `,`<sup>opt</sup> `}` `from` |
 </div>
 
 #### <a name="Import-element">Import-element</a> (**import-element**)
@@ -179,9 +179,9 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Generic-argument-list">Generic-argument-list</a> (**gargs**)
 
 <div className="lang-ref-table">
-|         |         |                                                                                                  |
-|---------|---------|--------------------------------------------------------------------------------------------------|
-| *gargs* | &xrarr; | `<` [*garg*](#Generic-argument) `,` &mldr; `,` [*garg*](#Generic-argument) `,`<sup>opt</sup> `>` |
+|         |         |                                                                                             |
+|---------|---------|---------------------------------------------------------------------------------------------|
+| *gargs* | &xrarr; | `<` [*garg*](#Generic-argument) `,` ⋯ `,` [*garg*](#Generic-argument) `,`<sup>opt</sup> `>` |
 </div>
 
 #### <a name="Generic-argument">Generic-argument</a> (**garg**)
@@ -196,9 +196,9 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Export-declaration">Export-declaration</a> (**export-form**)
 
 <div className="lang-ref-table">
-|               |         |                                                                                                             |
-|---------------|---------|-------------------------------------------------------------------------------------------------------------|
-| *export-form* | &xrarr; | `export` `{` [*id*](#identifier) `,` &mldr; `,` [*id*](#identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|               |         |                                                                                                        |
+|---------------|---------|--------------------------------------------------------------------------------------------------------|
+| *export-form* | &xrarr; | `export` `{` [*id*](#identifier) `,` ⋯ `,` [*id*](#identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
 #### <a name="Ledger-declaration">Ledger-declaration</a> (**ledger-declaration**)
@@ -236,27 +236,27 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Structure-declaration">Structure-declaration</a> (**struct-declaration**)
 
 <div className="lang-ref-table">
-|                      |         |                                                                                                                                                                                                                                                            |
-|----------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *struct-declaration* | &xrarr; | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-identifier*](#Typed-identifier) `;` &mldr; `;` [*typed-identifier*](#Typed-identifier) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
-|                      | \|      | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-identifier*](#Typed-identifier) `,` &mldr; `,` [*typed-identifier*](#Typed-identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                      |         |                                                                                                                                                                                                                                                       |
+|----------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *struct-declaration* | &xrarr; | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-identifier*](#Typed-identifier) `;` ⋯ `;` [*typed-identifier*](#Typed-identifier) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                      | \|      | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-identifier*](#Typed-identifier) `,` ⋯ `,` [*typed-identifier*](#Typed-identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
 #### <a name="Enum-declaration">Enum-declaration</a> (**enum-declaration**)
 
 <div className="lang-ref-table">
-|                    |         |                                                                                                                                                                   |
-|--------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *enum-declaration* | &xrarr; | `export`<sup>opt</sup> `enum` [*enum-name*](#identifier) `{` [*id*](#identifier) `,` &mldr;&sup1; `,` [*id*](#identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                    |         |                                                                                                                                                         |
+|--------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *enum-declaration* | &xrarr; | `export`<sup>opt</sup> `enum` [*enum-name*](#identifier) `{` [*id*](#identifier) `,` ⋯¹ `,` [*id*](#identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
 #### <a name="External-contract-declaration">External-contract-declaration</a> (**contract-declaration**)
 
 <div className="lang-ref-table">
-|                        |         |                                                                                                                                                                                                                                     |
-|------------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *contract-declaration* | &xrarr; | `export`<sup>opt</sup> `contract` [*contract-name*](#identifier) `{` [*circuit-declaration*](#External-contract-circuit) `;` &mldr; `;` [*circuit-declaration*](#External-contract-circuit) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
-|                        | \|      | `export`<sup>opt</sup> `contract` [*contract-name*](#identifier) `{` [*circuit-declaration*](#External-contract-circuit) `,` &mldr; `,` [*circuit-declaration*](#External-contract-circuit) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                        |         |                                                                                                                                                                                                                                |
+|------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *contract-declaration* | &xrarr; | `export`<sup>opt</sup> `contract` [*contract-name*](#identifier) `{` [*circuit-declaration*](#External-contract-circuit) `;` ⋯ `;` [*circuit-declaration*](#External-contract-circuit) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                        | \|      | `export`<sup>opt</sup> `contract` [*contract-name*](#identifier) `{` [*circuit-declaration*](#External-contract-circuit) `,` ⋯ `,` [*circuit-declaration*](#External-contract-circuit) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
 #### <a name="External-contract-circuit">External-contract-circuit</a> (**circuit-declaration**)
@@ -286,9 +286,9 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Simple-parameter-list">Simple-parameter-list</a> (**simple-parameter-list**)
 
 <div className="lang-ref-table">
-|                         |         |                                                                                                                          |
-|-------------------------|---------|--------------------------------------------------------------------------------------------------------------------------|
-| *simple-parameter-list* | &xrarr; | `(` [*typed-identifier*](#Typed-identifier) `,` &mldr; `,` [*typed-identifier*](#Typed-identifier) `,`<sup>opt</sup> `)` |
+|                         |         |                                                                                                                     |
+|-------------------------|---------|---------------------------------------------------------------------------------------------------------------------|
+| *simple-parameter-list* | &xrarr; | `(` [*typed-identifier*](#Typed-identifier) `,` ⋯ `,` [*typed-identifier*](#Typed-identifier) `,`<sup>opt</sup> `)` |
 </div>
 
 #### <a name="Typed-pattern">Typed-pattern</a> (**typed-pattern**)
@@ -302,25 +302,25 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Pattern-parameter-list">Pattern-parameter-list</a> (**pattern-parameter-list**)
 
 <div className="lang-ref-table">
-|                          |         |                                                                                                              |
-|--------------------------|---------|--------------------------------------------------------------------------------------------------------------|
-| *pattern-parameter-list* | &xrarr; | `(` [*typed-pattern*](#Typed-pattern) `,` &mldr; `,` [*typed-pattern*](#Typed-pattern) `,`<sup>opt</sup> `)` |
+|                          |         |                                                                                                         |
+|--------------------------|---------|---------------------------------------------------------------------------------------------------------|
+| *pattern-parameter-list* | &xrarr; | `(` [*typed-pattern*](#Typed-pattern) `,` ⋯ `,` [*typed-pattern*](#Typed-pattern) `,`<sup>opt</sup> `)` |
 </div>
 
 #### <a name="Type">Type</a> (**type**)
 
 <div className="lang-ref-table">
-|        |         |                                                                          |
-|--------|---------|--------------------------------------------------------------------------|
-| *type* | &xrarr; | [*tref*](#Type-reference)                                                |
-|        | \|      | `Boolean`                                                                |
-|        | \|      | `Field`                                                                  |
-|        | \|      | `Uint` `<` [*tsize*](#Type-size) `>`                                     |
-|        | \|      | `Uint` `<` [*tsize*](#Type-size) `..` [*tsize*](#Type-size) `>`          |
-|        | \|      | `Bytes` `<` [*tsize*](#Type-size) `>`                                    |
-|        | \|      | `Opaque` `<` [*str*](#string-literal) `>`                                |
-|        | \|      | `Vector` `<` [*tsize*](#Type-size) `,` [*type*](#Type) `>`               |
-|        | \|      | `[` [*type*](#Type) `,` &mldr; `,` [*type*](#Type) `,`<sup>opt</sup> `]` |
+|        |         |                                                                     |
+|--------|---------|---------------------------------------------------------------------|
+| *type* | &xrarr; | [*tref*](#Type-reference)                                           |
+|        | \|      | `Boolean`                                                           |
+|        | \|      | `Field`                                                             |
+|        | \|      | `Uint` `<` [*tsize*](#Type-size) `>`                                |
+|        | \|      | `Uint` `<` [*tsize*](#Type-size) `..` [*tsize*](#Type-size) `>`     |
+|        | \|      | `Bytes` `<` [*tsize*](#Type-size) `>`                               |
+|        | \|      | `Opaque` `<` [*str*](#string-literal) `>`                           |
+|        | \|      | `Vector` `<` [*tsize*](#Type-size) `,` [*type*](#Type) `>`          |
+|        | \|      | `[` [*type*](#Type) `,` ⋯ `,` [*type*](#Type) `,`<sup>opt</sup> `]` |
 </div>
 
 #### <a name="Type-reference">Type-reference</a> (**tref**)
@@ -343,9 +343,9 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Block">Block</a> (**block**)
 
 <div className="lang-ref-table">
-|         |         |                                                          |
-|---------|---------|----------------------------------------------------------|
-| *block* | &xrarr; | `{` [*stmt*](#Statement) &mldr; [*stmt*](#Statement) `}` |
+|         |         |                                                     |
+|---------|---------|-----------------------------------------------------|
+| *block* | &xrarr; | `{` [*stmt*](#Statement) ⋯ [*stmt*](#Statement) `}` |
 </div>
 
 #### <a name="Statement">Statement</a> (**stmt**)
@@ -363,7 +363,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    |         |                                                                                                                          |
 |--------------------|---------|--------------------------------------------------------------------------------------------------------------------------|
 | *stmt<sub>0</sub>* | &xrarr; | [*expr-seq*](#Expression-sequence) `;`                                                                                   |
-|                    | \|      | `const` [*cbinding*](#Const-Binding) `,` &mldr;&sup1; `,` [*cbinding*](#Const-Binding)  `;`                              |
+|                    | \|      | `const` [*cbinding*](#Const-Binding) `,` ⋯¹ `,` [*cbinding*](#Const-Binding)  `;`                                        |
 |                    | \|      | `if` `(` [*expr-seq*](#Expression-sequence) `)` [*stmt<sub>0</sub>*](#Statement0) `else` [*stmt*](#Statement)            |
 |                    | \|      | `for` `(` `const` [*id*](#identifier) `of` [*nat*](#field-literal) `..` [*nat*](#field-literal) `)` [*stmt*](#Statement) |
 |                    | \|      | `for` `(` `const` [*id*](#identifier) `of` [*expr-seq*](#Expression-sequence) `)` [*stmt*](#Statement)                   |
@@ -375,11 +375,11 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Pattern">Pattern</a> (**pattern**)
 
 <div className="lang-ref-table">
-|           |         |                                                                                                                                          |
-|-----------|---------|------------------------------------------------------------------------------------------------------------------------------------------|
-| *pattern* | &xrarr; | [*id*](#identifier)                                                                                                                      |
-|           | \|      | `[` [*pattern*](#Pattern)<sup>opt</sup> `,` &mldr; `,` [*pattern*](#Pattern)<sup>opt</sup> `,`<sup>opt</sup> `]`                         |
-|           | \|      | `{` [*pattern-struct-elt*](#Pattern-struct-element) `,` &mldr; `,` [*pattern-struct-elt*](#Pattern-struct-element) `,`<sup>opt</sup> `}` |
+|           |         |                                                                                                                                     |
+|-----------|---------|-------------------------------------------------------------------------------------------------------------------------------------|
+| *pattern* | &xrarr; | [*id*](#identifier)                                                                                                                 |
+|           | \|      | `[` [*pattern*](#Pattern)<sup>opt</sup> `,` ⋯ `,` [*pattern*](#Pattern)<sup>opt</sup> `,`<sup>opt</sup> `]`                         |
+|           | \|      | `{` [*pattern-struct-elt*](#Pattern-struct-element) `,` ⋯ `,` [*pattern-struct-elt*](#Pattern-struct-element) `,`<sup>opt</sup> `}` |
 </div>
 
 #### <a name="Pattern-struct-element">Pattern-struct-element</a> (**pattern-struct-elt**)
@@ -394,10 +394,10 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Expression-sequence">Expression-sequence</a> (**expr-seq**)
 
 <div className="lang-ref-table">
-|            |         |                                                                                             |
-|------------|---------|---------------------------------------------------------------------------------------------|
-| *expr-seq* | &xrarr; | [*expr*](#Expression)                                                                       |
-|            | \|      | [*expr*](#Expression) `,` &mldr;&sup1; `,` [*expr*](#Expression)  `,` [*expr*](#Expression) |
+|            |         |                                                                                   |
+|------------|---------|-----------------------------------------------------------------------------------|
+| *expr-seq* | &xrarr; | [*expr*](#Expression)                                                             |
+|            | \|      | [*expr*](#Expression) `,` ⋯¹ `,` [*expr*](#Expression)  `,` [*expr*](#Expression) |
 </div>
 
 #### <a name="Expression">Expression</a> (**expr**)
@@ -492,29 +492,29 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Expression8">Expression<sub>8</sub></a> (**expr<sub>8</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                                                                                                                                 |
-|--------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------|
-| *expr<sub>8</sub>* | &xrarr; | [*expr<sub>8</sub>*](#Expression8) `[` [*expr*](#Expression) `]`                                                                                |
-|                    | \|      | [*expr<sub>8</sub>*](#Expression8) `.` [*id*](#identifier)                                                                                      |
-|                    | \|      | [*expr<sub>8</sub>*](#Expression8) `.` [*id*](#identifier) `(` [*expr*](#Expression) `,` &mldr; `,` [*expr*](#Expression) `,`<sup>opt</sup> `)` |
-|                    | \|      | [*expr<sub>9</sub>*](#Expression9)                                                                                                              |
+|                    |         |                                                                                                                                            |
+|--------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------|
+| *expr<sub>8</sub>* | &xrarr; | [*expr<sub>8</sub>*](#Expression8) `[` [*expr*](#Expression) `]`                                                                           |
+|                    | \|      | [*expr<sub>8</sub>*](#Expression8) `.` [*id*](#identifier)                                                                                 |
+|                    | \|      | [*expr<sub>8</sub>*](#Expression8) `.` [*id*](#identifier) `(` [*expr*](#Expression) `,` ⋯ `,` [*expr*](#Expression) `,`<sup>opt</sup> `)` |
+|                    | \|      | [*expr<sub>9</sub>*](#Expression9)                                                                                                         |
 </div>
 
 #### <a name="Expression9">Expression<sub>9</sub></a> (**expr<sub>9</sub>**)
 
 <div className="lang-ref-table">
-|                    |         |                                                                                                                                                    |
-|--------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------|
-| *expr<sub>9</sub>* | &xrarr; | [*fun*](#Function) `(` [*expr*](#Expression) `,` &mldr; `,` [*expr*](#Expression) `,`<sup>opt</sup> `)`                                            |
-|                    | \|      | `map` `(` [*fun*](#Function) `,` [*expr*](#Expression) `,` &mldr;&sup1; `,` [*expr*](#Expression) `,`<sup>opt</sup> `)`                            |
-|                    | \|      | `fold` `(` [*fun*](#Function) `,` [*expr*](#Expression) `,` [*expr*](#Expression) `,` &mldr;&sup1; `,` [*expr*](#Expression) `,`<sup>opt</sup> `)` |
-|                    | \|      | `slice` `<` [*tsize*](#Type-size) `>` `(` [*expr*](#Expression) `,` [*expr*](#Expression) `)`                                                      |
-|                    | \|      | `[` [*tuple-arg*](#Tuple-argument) `,` &mldr; `,` [*tuple-arg*](#Tuple-argument) `,`<sup>opt</sup> `]`                                             |
-|                    | \|      | `Bytes` `[` [*tuple-arg*](#Tuple-argument) `,` &mldr; `,` [*tuple-arg*](#Tuple-argument) `,`<sup>opt</sup> `]`                                     |
-|                    | \|      | [*tref*](#Type-reference) `{` [*struct-arg*](#Structure-argument) `,` &mldr; `,` [*struct-arg*](#Structure-argument) `,`<sup>opt</sup> `}`         |
-|                    | \|      | `assert` `(` [*expr*](#Expression) `,` [*str*](#string-literal) `)`                                                                                |
-|                    | \|      | `disclose` `(` [*expr*](#Expression) `)`                                                                                                           |
-|                    | \|      | [*term*](#Term)                                                                                                                                    |
+|                    |         |                                                                                                                                          |
+|--------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------|
+| *expr<sub>9</sub>* | &xrarr; | [*fun*](#Function) `(` [*expr*](#Expression) `,` ⋯ `,` [*expr*](#Expression) `,`<sup>opt</sup> `)`                                       |
+|                    | \|      | `map` `(` [*fun*](#Function) `,` [*expr*](#Expression) `,` ⋯¹ `,` [*expr*](#Expression) `,`<sup>opt</sup> `)`                            |
+|                    | \|      | `fold` `(` [*fun*](#Function) `,` [*expr*](#Expression) `,` [*expr*](#Expression) `,` ⋯¹ `,` [*expr*](#Expression) `,`<sup>opt</sup> `)` |
+|                    | \|      | `slice` `<` [*tsize*](#Type-size) `>` `(` [*expr*](#Expression) `,` [*expr*](#Expression) `)`                                            |
+|                    | \|      | `[` [*tuple-arg*](#Tuple-argument) `,` ⋯ `,` [*tuple-arg*](#Tuple-argument) `,`<sup>opt</sup> `]`                                        |
+|                    | \|      | `Bytes` `[` [*tuple-arg*](#Tuple-argument) `,` ⋯ `,` [*tuple-arg*](#Tuple-argument) `,`<sup>opt</sup> `]`                                |
+|                    | \|      | [*tref*](#Type-reference) `{` [*struct-arg*](#Structure-argument) `,` ⋯ `,` [*struct-arg*](#Structure-argument) `,`<sup>opt</sup> `}`    |
+|                    | \|      | `assert` `(` [*expr*](#Expression) `,` [*str*](#string-literal) `)`                                                                      |
+|                    | \|      | `disclose` `(` [*expr*](#Expression) `)`                                                                                                 |
+|                    | \|      | [*term*](#Term)                                                                                                                          |
 </div>
 
 #### <a name="Term">Term</a> (**term**)
@@ -591,8 +591,8 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Arrow-parameter-list">Arrow-parameter-list</a> (**arrow-parameter-list**)
 
 <div className="lang-ref-table">
-|                        |         |                                                                                                                                                          |
-|------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *arrow-parameter-list* | &xrarr; | `(` [*optionally-typed-pattern*](#Optionally-typed-pattern) `,` &mldr; `,` [*optionally-typed-pattern*](#Optionally-typed-pattern) `,`<sup>opt</sup> `)` |
+|                        |         |                                                                                                                                                     |
+|------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------|
+| *arrow-parameter-list* | &xrarr; | `(` [*optionally-typed-pattern*](#Optionally-typed-pattern) `,` ⋯ `,` [*optionally-typed-pattern*](#Optionally-typed-pattern) `,`<sup>opt</sup> `)` |
 </div>
 
diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index d32b5f2e..7f281641 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -93,17 +93,17 @@ following notational conventions in the grammar:
 - Alternation is indicated by a vertical bar (`|`).
 - Optional items are indicated by the superscript <sup>opt</sup>.
 - Repetition is specified by ellipses.
-  The notation *X* &mldr; *X*, where *X* is a grammar symbol, represents zero
+  The notation *X* ⋯ *X*, where *X* is a grammar symbol, represents zero
   or more occurrences of *X*.
-  The notation *X* `,` &mldr; `,` *X*, where *X* is a grammar symbol and
+  The notation *X* `,` ⋯ `,` *X*, where *X* is a grammar symbol and
   `,` is a literal comma, represents zero or more occurrences of *X*
   separated by commas.
   In either case, when the ellipsis is marked with the superscript 1,
-  the notation represents a sequence containing at least one *X*.
-  When such a sequence is followed by *,*<sup>opt</sup>, an optional
+  i.e., ⋯¹, the notation represents a sequence containing at least one *X*.
+  When such a sequence is followed by `,`<sup>opt</sup>, an optional
   trailing comma is allowed, but only if there is at least one *X*.
-  For example, *id* &mldr; *id* represents zero or more *id*s, and
-  *expr* `,` &mldr;&sup1; `,` *expr* `,`<sup>opt</sup> represents one
+  For example, *id* ⋯ *id* represents zero or more *id*s, and
+  *expr* `,` ⋯¹ `,` *expr* `,`<sup>opt</sup> represents one
   or more comma-separated *expr*s possibly followed by an extra comma.
   The rules involving commas apply equally to semicolons, i.e., apply when
   `,` is replaced by `;`.
@@ -261,7 +261,7 @@ Each parameter is either a type name (e.g., `T`) or a hash-prefixed natural-numb
 Generic natural-number parameters are prefixed by `#` to distingish them from
 generic type parameters.
 
-<table className="lang-ref-table"><tbody><tr><td><em>gparams</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>generic-param</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>generic-param</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr>
+<table className="lang-ref-table"><tbody><tr><td><em>gparams</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>generic-param</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>generic-param</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr>
 <tr><td><em>generic-param</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>#</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr></tbody></table>
 
 Generic entities must be *specialized* at the point of use to produce non-generic
@@ -271,7 +271,7 @@ Generic arguments are also enclosed in angle brackets.
 Each generic argument must be a type, a natural number literal, or the type or
 numeric value of a generic parameter.
 
-<table className="lang-ref-table"><tbody><tr><td><em>gargs</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>garg</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>garg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr>
+<table className="lang-ref-table"><tbody><tr><td><em>gargs</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>garg</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>garg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr>
 <tr><td><em>garg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
 
 The syntax of types allows for type references, including references to generic
@@ -344,7 +344,7 @@ As with any other generic entity, it must be specialized at the point of use.
 
 The following are the primitive types of Compact:
 
-<table className="lang-ref-table"><tbody><tr><td><em>type</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>tref</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Boolean</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Field</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Opaque</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Vector</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>type</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>type</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>type</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr>
+<table className="lang-ref-table"><tbody><tr><td><em>type</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>tref</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Boolean</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Field</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Opaque</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Vector</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>type</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>type</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>type</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr>
 <tr><td><em>tref</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gargs</em></a><sup>opt</sup></td></tr>
 <tr><td><em>tsize</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></tbody></table>
 
@@ -382,8 +382,8 @@ The following are the primitive types of Compact:
   The current maximum field value is given in
   [Implementation-specific limits](#implementation-specific-limits).
 
-- `[T, ...]`, where `T, ...` are zero or more comma-separated types, is the type
-  of *tuple* values with element types `T, ...`.
+- `[T, ⋯]`, where `T, ⋯` are zero or more comma-separated types, is the type
+  of *tuple* values with element types `T, ⋯`.
   Tuples are heterogeneous: any element type can differ from any of the others.
   The *length* of a tuple type is the number of element types.
   Two tuple types with different lengths are different types.
@@ -393,7 +393,7 @@ The following are the primitive types of Compact:
 
 - `Vector<n, T>`, where `n` is a natural number literal or generic natural-number
   parameter and `T` is a type, is a shorthand notation for the tuple type
-  `[T, ...]` with `n` occurrences of the type `T`.
+  `[T, ⋯]` with `n` occurrences of the type `T`.
   Note that a vector type and the corresponding tuple type are two different ways
   of writing exactly the same type.
   Unless otherwise specified, type rules for vector types are derived from the
@@ -423,7 +423,7 @@ They can also define structural and nominal aliases for existing types.
 
 Structure types are defined via `struct` declarations with the following form:
 
-<table className="lang-ref-table"><tbody><tr><td><em>struct-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>;</tt></b> &mldr; <b><tt>;</tt></b> <em>typed-identifier</em> <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>typed-identifier</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr>
+<table className="lang-ref-table"><tbody><tr><td><em>struct-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>;</tt></b> ⋯ <b><tt>;</tt></b> <em>typed-identifier</em> <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>typed-identifier</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr>
 <tr><td><em>typed-identifier</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
 
 A structure declaration has a sequence of named fields which must be separated
@@ -532,7 +532,7 @@ and accessed via
 
 Enumeration types are defined via `enum` declarations with the following form:
 
-<table className="lang-ref-table"><tbody><tr><td><em>enum-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>enum</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>enum-name</em></a>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></tbody></table>
+<table className="lang-ref-table"><tbody><tr><td><em>enum-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>enum</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>enum-name</em></a>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> ⋯¹ <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></tbody></table>
 
 An enumeration declaration has a non-empty sequence of named elements separated by commas.
 A trailing comma is allowed but not required.
@@ -614,10 +614,10 @@ When a generic nominal type is specialized, the specialized type is a nominal ty
 
 ### Subtyping and least upper bounds
 
-Some Compact types are related to other types via subtyping.
+Some Compact types are *related* to other types via subtyping.
 Informally, if a type `T` is a *subtype* of a type `S` (equivalently, `S` is a
 *supertype* of type `T`), then every value of type `T` is also a value of type `S`,
-i.e., any value of type `T` can be used where a value of type `S` expected without
+i.e., any value of type `T` can be used where a value of type `S` is expected without
 the need for an explicit cast.
 For example, a circuit or witness can be called with argument expressions whose
 types are subtypes of the corresponding parameter type annotations, and
@@ -627,34 +627,33 @@ expression whose type is a subtype of the type annotation.
 Subtyping is defined by the following rules:
 
 - Any type `T` is a subtype of itself (subtyping is reflexive)
-- `Uint<0..n>` is a subtype of `Uint<0..m>` if `n` is less than `m`
+- `Uint<0..n>` is a subtype of `Uint<0..m>` if `n` is less than (or equal to) `m`
 - `Uint<0..n>` is a subtype of `Field` for all `n`
-- The tuple type `[T, ...]` is a subtype of the tuple type `[S, ...]`
+- The tuple type `[T, ⋯]` is a subtype of the tuple type `[S, ⋯]`
   if they have the same length and each type `T` is a subtype of the
   corresponding type `S`.
 
 The *least upper bound* (with respect to subtyping) of a non-empty set of types
-\{`T0`, ..., `Tn`} is a type `S` such that:
+\{`T1`, ⋯, `Tn`} is a type `S` such that:
 
 - **`S` is an upper bound:** `Ti` is a subtype of `S` for all `i` in
-    the range 0..`n`, and
+    the range 1..`n`, and
 - **`S` is the least upper bound:** for all upper bounds `R` of the set of types
-    \{`T0`, ..., `Tn`}, `S` is a subtype of `R`.
+    \{`T1`, ⋯, `Tn`}, `S` is a subtype of `R`.
 
 Note that least upper bounds do not exist for all sets of types, because
 some types (such as `Boolean` and `Field`) are not related.
 
 **Tuple and vector types:** Every vector type has an equivalent tuple type:
-`Vector<n, T>` is equivalent to (in fact, the same type as) `[T1, ..., Tn]`.
+`Vector<n, T>` is equivalent to (in fact, the same type as) `[T1, ⋯, Tn]`.
 The converse is not always true.
 For example, neither `[Boolean, Field]` nor `[Uint<8>, Uint<16>]` have an
 equivalent vector type.
 
-We say, however, that a tuple type `[T, ...]` with possibly distinct types `T, ...`
-"*has a vector type*" if the least upper bound `S` of the set of types \{`T`, ...}
+We say, however, that a tuple type <tt>[T1, ⋯, Tn]</tt> with possibly distinct types `T1, ⋯, Tn`
+"*has a vector type*" if the least upper bound `S` of the set of types \{`T1`, ⋯, `Tn`}
 exists.
-In that case, the tuple type has the vector type `Vector<n, S>` where `n` is the
-length of the tuple.
+In that case, the tuple type has the vector type `Vector<n, S>`.
 Some operations over tuples (such as mapping and folding) require the tuple type
 to have a vector type.
 
@@ -666,8 +665,8 @@ vector type `Vector<2, Uint<16>>`, but the types are not equivalent.
 
 Every vector type is a subtype of the equivalent tuple type and possibly of some
 other tuple types.
-In general, a vector type `Vector<n, T>` is a subtype of a tuple type `[S, ...]`
-if the tuple has length `n` and `T` is a subtype of each of the types `S, ...`.
+In general, a vector type `Vector<n, T>` is a subtype of a tuple type `[S1, ⋯, Sn]`
+if `T` is a subtype of each of the types `S1`, ⋯, `Sn`.
 The means, for instance, that a vector can often be passed to a circuit where a
 tuple is expected.
 
@@ -676,7 +675,7 @@ tuple is expected.
 The parameters of a circuit or constructor and the target of a `const` binding
 are specified via patterns:
 
-<table className="lang-ref-table"><tbody><tr><td><em>pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
+<table className="lang-ref-table"><tbody><tr><td><em>pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
 <tr><td><em>pattern-struct-elt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>pattern</em></td></tr></tbody></table>
 
 In its simplest form, a pattern is just an identifier.
@@ -819,7 +818,7 @@ circuit sumSomeYs([{y: b1,}, , {y: b3,},]: [S, S, S]): Field {
 A compact program is a sequence of zero or more program elements.
 
 <table className="lang-ref-table"><tbody>
-<tr><td><em>program</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pelt</em> &mldr; <em>pelt</em></td></tr>
+<tr><td><em>program</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pelt</em> ⋯ <em>pelt</em></td></tr>
 <tr><td><em>pelt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#pragmas"><em>pragma-form</em></a></td></tr>
 <tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#modules-exports-and-imports"><em>module-definition</em></a></td></tr>
 <tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#exports"><em>export-form</em></a></td></tr>
@@ -900,7 +899,7 @@ Any identifier defined at or imported into the top level of a module can be expo
 from the module in one of two ways: (1) by prefixing the definition with the
 `export` keyword, or by listing the identifier in a separate `export` declaration:
 
-<table className="lang-ref-table"><tbody><tr><td><em>export-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></tbody></table>
+<table className="lang-ref-table"><tbody><tr><td><em>export-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></tbody></table>
 
 For example, the following module exports `G` and `S` but not `F`.
 
@@ -925,7 +924,7 @@ A module can be imported into another module or into the program top level, maki
 some or all of its exported bindings visible there, potentially with a prefix.
 
 <table className="lang-ref-table"><tbody><tr><td><em>import-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>import</tt></b>&nbsp;&nbsp;<em>import-selection</em><sup>opt</sup>&nbsp;&nbsp;<em>import-name</em>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gargs</em></a><sup>opt</sup>&nbsp;&nbsp;<em>import-prefix</em><sup>opt</sup>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr>
-<tr><td><em>import-selection</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>import-element</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>import-element</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>from</tt></b></td></tr>
+<tr><td><em>import-selection</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>import-element</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>import-element</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>from</tt></b></td></tr>
 <tr><td><em>import-element</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr>
 <tr><td><em>import-name</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#string-literal"><em>file</em></a></td></tr>
 <tr><td><em>import-prefix</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>prefix</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></tbody></table>
@@ -1148,7 +1147,7 @@ provided by the TypeScript driver.
 
 <table className="lang-ref-table"><tbody>
 <tr><td><em>witness-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>witness</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<em>simple-parameter-list</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr>
-<tr><td><em>simple-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>typed-identifier</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
+<tr><td><em>simple-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>typed-identifier</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
 <tr><td><em>typed-identifier</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr>
 </tbody></table>
 
@@ -1216,7 +1215,7 @@ The following *ledger-state types* are supported.
 Each ledger type supports a set of operations, which can be invoked with
 
 ```compact
-<field name>.<operation>(<arguments ...>)
+<field name>.<operation>(<arguments ⋯>)
 ```
 
 A ledger field that is declared with a Compact type `T` implicitly has the type
@@ -1402,7 +1401,7 @@ reachable from an exported circuit.
 A contract can be initialized via a contract constructor defined at the
 program's top level.
 
-<table className="lang-ref-table"><tbody><tr><td><em>constructor-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>constructor</tt></b>&nbsp;&nbsp;<em>pattern-parameter-list</em>&nbsp;&nbsp;<a href="#statements"><em>block</em></a></td></tr><tr><td><em>pattern-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-pattern</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
+<table className="lang-ref-table"><tbody><tr><td><em>constructor-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>constructor</tt></b>&nbsp;&nbsp;<em>pattern-parameter-list</em>&nbsp;&nbsp;<a href="#statements"><em>block</em></a></td></tr><tr><td><em>pattern-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-pattern</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
 <tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
 
 The constructor, if any, is typically used to initialize public state
@@ -1457,7 +1456,7 @@ in [Circuits and witness calls](#circuits-and-witness-calls).
 Named circuit definitions have the following syntax:
 
 <table className="lang-ref-table"><tbody><tr><td><em>circuit-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>function-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<em>pattern-parameter-list</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<a href="#statements"><em>block</em></a></td></tr>
-<tr><td><em>pattern-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-pattern</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
+<tr><td><em>pattern-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-pattern</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
 <tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
 
 A circuit definition binds `function-name` to a circuit with the given parameters,
@@ -1521,11 +1520,11 @@ if present, e.g.:
 
 ```compact
 pure circuit c(a: Field): Field {
-  ...
+  ⋯
 }
 
 export pure circuit c(a: Field): Field {
-  ...
+  ⋯
 }
 ```
 
@@ -1540,7 +1539,7 @@ Compact program by the Compact compiler.
 
 A `block` is a group of statements enclosed in braces:
 
-<table className="lang-ref-table"><tbody><tr><td><em>block</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>stmt</em> &mldr; <em>stmt</em>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></tbody></table>
+<table className="lang-ref-table"><tbody><tr><td><em>block</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>stmt</em> ⋯ <em>stmt</em>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></tbody></table>
 
 A block can be used in place of a single statement anywhere a single statement
 is allowed, which is useful for allowing multiple statements to be evaluated by the
@@ -1564,7 +1563,7 @@ A block is evaluated by evaluating the statements in sequence.
 The syntax of Compact statements is summarized by the following grammar snippet:
 
 <table className="lang-ref-table"><tbody><tr><td><em>stmt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>stmt<sub>0</sub></em></td></tr>
-<tr><td><em>stmt<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#const-binding-statement"><em>cbinding</em></a> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <a href="#const-binding-statement"><em>cbinding</em></a> &nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt<sub>0</sub></em>&nbsp;&nbsp;<b><tt>else</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>block</em></td></tr></tbody></table>
+<tr><td><em>stmt<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#const-binding-statement"><em>cbinding</em></a> <b><tt>,</tt></b> ⋯¹ <b><tt>,</tt></b> <a href="#const-binding-statement"><em>cbinding</em></a> &nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt<sub>0</sub></em>&nbsp;&nbsp;<b><tt>else</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>block</em></td></tr></tbody></table>
 
 The snippet shows that a statement (`stmt`) is either a one-armed `if` expression
 or some other kinf of statement (`stmt0`).
@@ -1607,7 +1606,7 @@ in the syntax specified by the following grammar snippet:
 <table className="lang-ref-table"><tbody>
 <tr><td><em>cbinding</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>optionally-typed-pattern</em>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<a href="#expressions"><em>expr</em></a></td></tr>
 <tr><td><em>optionally-typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>typed-pattern</em></td></tr>
-<tr><td><a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
+<tr><td><a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
 <tr><td><a href="#patterns-and-destructuring"><em>pattern-struct-elt</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>pattern</em></td></tr>
 <tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr>
 </tbody></table>
@@ -1811,7 +1810,7 @@ subsequent statements, and it returns to the caller the value of `expr-seq` or
 
 The syntax of Compact expressions is summarized by the following grammar snippet:
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr-seq</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> &nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr>
+<table className="lang-ref-table"><tbody><tr><td><em>expr-seq</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> ⋯¹ <b><tt>,</tt></b> <em>expr</em> &nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr>
 <tr><td><em>expr</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>?</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>+=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>-=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em></td></tr>
 <tr><td><em>expr<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>||</tt></b>&nbsp;&nbsp;<em>expr<sub>1</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>1</sub></em></td></tr>
 <tr><td><em>expr<sub>1</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>1</sub></em>&nbsp;&nbsp;<b><tt>&&</tt></b>&nbsp;&nbsp;<em>expr<sub>2</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>2</sub></em></td></tr>
@@ -1821,8 +1820,8 @@ The syntax of Compact expressions is summarized by the following grammar snippet
 <tr><td><em>expr<sub>5</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>5</sub></em>&nbsp;&nbsp;<b><tt>+</tt></b>&nbsp;&nbsp;<em>expr<sub>6</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>5</sub></em>&nbsp;&nbsp;<b><tt>-</tt></b>&nbsp;&nbsp;<em>expr<sub>6</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>6</sub></em></td></tr>
 <tr><td><em>expr<sub>6</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>6</sub></em>&nbsp;&nbsp;<b><tt>*</tt></b>&nbsp;&nbsp;<em>expr<sub>7</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>7</sub></em></td></tr>
 <tr><td><em>expr<sub>7</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<em>expr<sub>7</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em></td></tr>
-<tr><td><em>expr<sub>8</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>9</sub></em></td></tr>
-<tr><td><em>expr<sub>9</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>map</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>fold</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> &mldr;&sup1; <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>slice</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>tuple-arg</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>tuple-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>bytes-arg</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>bytes-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#primitive-types"><em>tref</em></a>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>struct-arg</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>struct-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>assert</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>disclose</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>term</em></td></tr>
+<tr><td><em>expr<sub>8</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>9</sub></em></td></tr>
+<tr><td><em>expr<sub>9</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>map</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> ⋯¹ <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>fold</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> ⋯¹ <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>slice</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>tuple-arg</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>tuple-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>bytes-arg</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>bytes-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#primitive-types"><em>tref</em></a>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>struct-arg</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>struct-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>assert</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>disclose</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>term</em></td></tr>
 <tr><td><em>tuple-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td><em>bytes-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>tuple-arg</em></td></tr>
 <tr><td><em>struct-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr>
 <tr><td><em>term</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>true</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>false</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>pad</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>default</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr-seq</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></tbody></table>
@@ -1910,7 +1909,7 @@ An expression sequence (`expr-seq` in the grammar above) is a comma-separated
 sequence of one or more expressions.
 
 ```compact
-expression, ..., expression
+expression, ⋯, expression
 ```
 
 Expression sequences can appear only in a few contexts.
@@ -1918,7 +1917,7 @@ When an expression sequence is required in a context where only a single express
 is permitted, the expression sequence can be wrapped in parentheses:
 
 ```compact
-(expression, ..., expression)
+(expression, ⋯, expression)
 ```
 
 The type of an expression sequence is the type of its last subexpression.
@@ -2017,7 +2016,7 @@ are as follows:
 - `Boolean`: the value of the literal `false`
 - `Uint<0..n>` and `Uint<n>`: `0`
 - `Field`: `0`
-- `[T, ...]` where `T, ...` is a sequence of zero or more types: the tuple with
+- `[T, ⋯]` where `T, ⋯` is a sequence of zero or more types: the tuple with
   the corresponding length, each of the default value of the corresponding type
 - `Bytes<n>`: the byte vector of length `n` with all zero bytes
 - `Opaque<"string">`: an empty string, i.e., `""`
@@ -2242,8 +2241,8 @@ message indicating that the cast of the value to `Feet` failed.
 
 ### Tuple creation
 
-New tuple values are created with expressions of the form `[tuple-arg, ...]` where
-`tuple-arg, ...` is a sequence of zero or more comma-separated tuple
+New tuple values are created with expressions of the form `[tuple-arg, ⋯]` where
+`tuple-arg, ⋯` is a sequence of zero or more comma-separated tuple
 arguments.
 A non-empty sequence can have an optional trailing comma.
 Each tuple argument is either an expression or a *spread*.
@@ -2255,8 +2254,8 @@ If a tuple argument is a spread `... expr`, the type `T` of `expr` must be
 a tuple type, a Vector type, or a Bytes type.
 Otherwise, it is a static error.
 
-If `expr` has a tuple type `[U, ...]` of length *n*, the spread contributes
-`n` new elements of type `U, ...` to to the new tuple, i.e., the elements
+If `expr` has a tuple type `[U, ⋯]` of length *n*, the spread contributes
+`n` new elements of type `U, ⋯` to to the new tuple, i.e., the elements
 of the tuple value of `expr`.
 If `expr` has a Vector type `Vector<n, U>`, the spread contributes
 `n` new elements of type `U` to to the new tuple, i.e., the elements
@@ -2277,7 +2276,7 @@ which can be less than or greater than number of tuple arguments.
 ### Byte-vector creation
 
 New byte vectors are created with expressions of the form
-`Bytes [tuple-arg, ...]`.
+`Bytes [tuple-arg, ⋯]`.
 Bytes creation is essentially the same as [tuple creation](#tuple-creation)
 except that the types of the contributed elements must all be subtypes of `Uint<8>`
 (if not, it is static error), and the result is a new byte vector of type
@@ -2322,10 +2321,10 @@ via the following rules, or it is a static error.
 
 The type of a byte-vector reference is `Uint<8>`.
 The type of a vector reference where the vector has type `Vector<n, T>` is `T`.
-The type of a tuple reference where the tuple has type `[T1, ..., Tn]` is
+The type of a tuple reference where the tuple has type `[T1, ⋯, Tn]` is
 `Ti` if `index` is the constant `i` or the value `i` of a generic natural-number
 parameter.
-Otherwise, `[T1, ..., Tn]` must have a vector type `Vector<n, T>` and the
+Otherwise, `[T1, ⋯, Tn]` must have a vector type `Vector<n, T>` and the
 type of the tuple reference is `T`.
 
 The value of a sequence reference is element `i` (zero-based) of the result
@@ -2348,10 +2347,10 @@ references](#tuple-vector-and-byte-vector-references).
 
 The type of a byte-vector slice is `Bytes<k>` where `k` is the constant value of `size`.
 The type of a vector slice where the vector has type `Vector<n, T>` is `Vector<k, T>`.
-The type of a tuple slice where the tuple has type `[T1, ..., Tn]` is the subsequence
-`[Ti, ..., Tj]` starting with element `i` (zero-based) and ending with element
-`j = i + k - 1` of `[T1, ..., Tn]`.
-Otherwise, `[T1, ..., Tn]` must have a vector type `Vector<n, T>` and the
+The type of a tuple slice where the tuple has type `[T1, ⋯, Tn]` is the subsequence
+`[Ti, ⋯, Tj]` starting with element `i` (zero-based) and ending with element
+`j = i + k - 1` of `[T1, ⋯, Tn]`.
+Otherwise, `[T1, ⋯, Tn]` must have a vector type `Vector<n, T>` and the
 type of the tuple reference is `Vector<k, T>`.
 
 The value of a `slice` expression is subsequence of the original tuple, vector,
@@ -2382,9 +2381,9 @@ Bytes[18, 19, 20]
 ### Structure creation
 
 Structure values are created with structure creation expressions.  The
-expression `T {f, ...}` is a structure creation expression, where `T` is a
-structure type name `S` or specialized generic structure type name `S<garg, ...>`,
-and `f, ...` is a sequence of zero or more comma-separated field-value specifiers.
+expression `T {f, ⋯}` is a structure creation expression, where `T` is a
+structure type name `S` or specialized generic structure type name `S<garg, ⋯>`,
+and `f, ⋯` is a sequence of zero or more comma-separated field-value specifiers.
 
 A field-value specifier can be one of three things:
 
@@ -2510,9 +2509,9 @@ type of `e` is an enumeration type.
 ### Circuit and witness calls
 
 <table className="lang-ref-table"><tbody><tr><td><em>fun</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gargs</em></a><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>arrow-parameter-list</em>&nbsp;&nbsp;<em>return-type</em><sup>opt</sup>&nbsp;&nbsp;<b><tt>=></tt></b>&nbsp;&nbsp;<a href="#statements"><em>block</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>arrow-parameter-list</em>&nbsp;&nbsp;<em>return-type</em><sup>opt</sup>&nbsp;&nbsp;<b><tt>=></tt></b>&nbsp;&nbsp;<a href="#expressions"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>fun</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
-<tr><td><em>arrow-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>optionally-typed-pattern</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>optionally-typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
+<tr><td><em>arrow-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>optionally-typed-pattern</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>optionally-typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
 <tr><td><em>optionally-typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>typed-pattern</em></td></tr>
-<tr><td><a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> &mldr; <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
+<tr><td><a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
 <tr><td><a href="#patterns-and-destructuring"><em>pattern-struct-elt</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>pattern</em></td></tr>
 <tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr>
 <tr><td><em>return-type</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>

From 4130811c992993d25c8565efd330e1e8171d2b6e Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Tue, 10 Mar 2026 16:25:44 +0100
Subject: [PATCH 09/41] latest compact reference, grammar, and keywords mdx
 files

---
 docs/compact/reference/compact-grammar.mdx  |  8 +++++++-
 docs/compact/reference/compact-keywords.mdx |  6 ++++++
 docs/compact/reference/lang-ref.mdx         | 22 +++++++++------------
 3 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index 66960f59..8a7ba085 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -1,6 +1,12 @@
+---
+SPDX-License-Identifier: Apache-2.0
+copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+title: Compact grammar
+---
+
 # Compact grammar
 
-Compact language version 0.21.0.
+Compact language version 0.21.101.
 
 Notational note: In the grammar below, terminals are in `monospaced` font. Non-terminals are in *emphasized* font. Alternation is indicated by a vertical bar (`|`). Optional items are indicated by the superscript <sup>opt</sup>. Repetition is specified by ellipses. The notation *X* ⋯ *X*, where *X* is a grammar symbol, represents zero or more occurrences of *X*. The notation *X* `,` ⋯ `,` *X*, where *X* is a grammar symbol and `,` is a literal comma, represents zero or more occurrences of *X* separated by commas. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one *X*. When such a sequence is followed by *,*<sup>opt</sup>, an optional trailing comma is allowed, but only if there is at least one *X*. For example, *id* ⋯ *id* represents zero or more *id*s, and *expr* `,` ⋯¹`,` *expr* `,`<sup>opt</sup> represents one or more comma-separated *expr*s possibly followed by an extra comma. The rules involving commas apply equally to semicolons, i.e., apply when `,` is replaced by `;`.
 
diff --git a/docs/compact/reference/compact-keywords.mdx b/docs/compact/reference/compact-keywords.mdx
index bdc7c3c9..02e10527 100644
--- a/docs/compact/reference/compact-keywords.mdx
+++ b/docs/compact/reference/compact-keywords.mdx
@@ -1,3 +1,9 @@
+---
+SPDX-License-Identifier: Apache-2.0
+copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+title: Compact keywords
+---
+
 # Compact keywords
 
 ## Module-related keywords
diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 7f281641..317d7de3 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -1,3 +1,9 @@
+---
+SPDX-License-Identifier: Apache-2.0
+copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+title: Compact reference
+---
+
 # Compact reference
 
 ## Overview
@@ -244,7 +250,7 @@ Various entities, specifically
 [type-alias declarations](#type-aliases),
 [circuit definitions](#circuits),
 and
-[witness declarations](#declaring-witnesses-for-private-state),
+[witness declarations](#declaring-witnesses-for-private-state-management),
 can have *generic parameters*, i.e., compile-time type and numeric (natural-number)
 parameters whose values are given at the use site rather than fixed at the point
 of declaration.
@@ -1451,7 +1457,7 @@ that circuits cannot be recursive, either directly or indirectly.
 
 Compact supports two kinds of circuits: named circuits and anonymous circuits.
 Named circuits are described here, and anonymous circuits are described
-in [Circuits and witness calls](#circuits-and-witness-calls).
+in [Circuit and witness calls](#circuit-and-witness-calls).
 
 Named circuit definitions have the following syntax:
 
@@ -1681,7 +1687,7 @@ expression as described earlier in
 (Patterns and destructuring)[patterns-and-destructuring].
 
 Any variable bound by `const` may not be reused within a block, although a
-`const` binding in a nested block might [shadow it](#scope-and-binding).
+`const` binding in a nested block might [shadow it](#identifiers-bindings-and-scope).
 Variables are immutable, although the same variable might take on different values
 at different times if is contined within a block of code that is evaluated more
 than once, such as would be the case for the body of a `circuit` that is called
@@ -2716,12 +2722,6 @@ The following rules govern when casts are allowed, when casts might cause run-ti
 errors, and casts might require run-time conversions.
 Any cast not covered by one of the rules is not allowed.
 
-!!!!!!!! TBD verify all of these claims -- Parisa
-
-!!!!!!!! TBD mention of cast of state-ledger types ?
-
-!!!!!!!! TBD ??? In meeting convo: Do we have all the cases for downcast? check the code in analysis pass to see if it does what the claims say. the downcast isn't correct, even the example isn't correct.
-
 #### Upcasts
 
 - Upcasts, i.e., casts from a type to a (supertype)[subtyping-and-least-upper-bounds]
@@ -2729,8 +2729,6 @@ Any cast not covered by one of the rules is not allowed.
   (but never required), never result in run-time errors, and, except in the case
   where the type and the supertype are the same, might require run-time conversions.
 
-!!!!!!!! TBD Might want to mention other impliciations of this rule, such as rules for casting tuples to vectors and back
-
 #### Downcasts of `Field` and `Uint` types
 
 - `Uint` downcasts, i.e., casts from `Uint<m>` to `Uint<n>`, `m > n`, are always
@@ -3032,8 +3030,6 @@ representation length in bytes (almost always 1).
 
 ## TypeScript target
 
-!!!!!!!! TBD Parisa should check this section to verify it matches reality
- 
 When compiled, a contract generates several artifacts. Key to these
 are the exported circuits from the contract's top level. These are
 divided into two categories: [pure circuits and impure circuits](#pure-and-impure-circuits).

From ad442c350930a39deedc8928a168f03e4f7c3c1f Mon Sep 17 00:00:00 2001
From: pataei <paris.ataei@gmail.com>
Date: Tue, 10 Mar 2026 11:21:45 -0400
Subject: [PATCH 10/41] fix links

---
 docs/compact/reference/lang-ref.mdx      | 18 +++++++++---------
 docs/compact/{ => reference}/writing.mdx |  0
 2 files changed, 9 insertions(+), 9 deletions(-)
 rename docs/compact/{ => reference}/writing.mdx (100%)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 317d7de3..08a1a176 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -1878,7 +1878,7 @@ addition, since the left operand can be at the same level while the right
 operand is at a higher level.
 This means that `x + y - z` can be treated only as the subtraction of `z`
 from `x + y` rather than as the addition of `x` and `y - z`.
-Right-associativity is expressed in the opposite manner, e.g., 
+Right-associativity is expressed in the opposite manner, e.g.,
 `expr_0 ? expr : expr` enforces the right-associativity of the
 ternary `?:` operator.
 Non-associative operators such as the relational operators `<`, `<=`, `>=`, `>` have
@@ -2126,7 +2126,7 @@ has a specific structure type, so does the other.
   The values are equal if the corresponding members are equal.
 - **Enumeration types:**
   The values are equal if they are the same enumeration member.
-- **`Opaque types:`** 
+- **`Opaque types:`**
   The values are equal if the runtime values are equal according to JavaScript's
   strict equalty (`===`) operator.
 
@@ -2153,12 +2153,12 @@ expression as follows:
 
 - For `||`, if the value of the left subexpression is `true` the right
   subexpression is *not* evaluated, i.e., short-circuited, and the value
-  of the entire expression is `true`.  
+  of the entire expression is `true`.
   Otherwise, the right subexpression *is* evaluated, and its value is the
   value of the entire expression.
 - For `&&`, if the value of the left subexpression is `false` the right
   subexpression is *not* evaluated, i.e., short-circuited, and the value
-  of the entire expression is `false`.  
+  of the entire expression is `false`.
   Otherwise, the right subexpression *is* evaluated, and its value is the
   value of the entire expression.
 
@@ -2489,7 +2489,7 @@ The value of any structure member access `e.id` is the result of evaluating the
 subexpression `e` and extracting the value of the resulting structure's
 `id` member.
 
-Some expressions of the form `e.id` can also be 
+Some expressions of the form `e.id` can also be
 [enumeration member accesses](#enumeration-member-access) or
 [ledger `read` operations](#ledger-state-operations).
 `e.id` is recognized as a structure member access only when the
@@ -2506,7 +2506,7 @@ The type of any enumeration member access `E.id` is `E`.
 `E.id` is a constant.
 That is, the value of any enumeration member access `E.id` is `E.id`.
 
-Some expressions of the form `e.id` can also be 
+Some expressions of the form `e.id` can also be
 [structure member accesses](#enumeration-member-access) or
 [ledger `read` operations](#ledger-state-operations).
 `e.id` is recognized as an enumeration member access only when the
@@ -2965,7 +2965,7 @@ scope of this document, but a few things are worth noting:
   the actual disclosure site as possible.
 - When disclosing a hashed or otherwise obfuscated variant of witness data,
   place the disclosure somewhere on the path between input and disclosure
-  *after* the obfuscation to help prevent disclosure of the unobfuscated 
+  *after* the obfuscation to help prevent disclosure of the unobfuscated
   input.
 
 More details are given in
@@ -3112,7 +3112,7 @@ Note that other `Opaque` types are currently not supported.
 
 Compact compiler version 1.0 limits certain datatype values and sizes:
 
-- The maximum value of a `Field` value is 
+- The maximum value of a `Field` value is
 52435875175126190479447740508185965837690552500527637822603658699938581184512.
 This value is dictated by the scalar field size of the ZK proving system.
 - The maximum value of a `Uint` value is
@@ -3154,4 +3154,4 @@ See [here](explicit-disclosure).
 
 ### Writing a contract in Compact
 
-See [here](../writing).
+See [here](writing).
diff --git a/docs/compact/writing.mdx b/docs/compact/reference/writing.mdx
similarity index 100%
rename from docs/compact/writing.mdx
rename to docs/compact/reference/writing.mdx

From 082713548c924fc156679c249dd5596b7def2ec6 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Wed, 11 Mar 2026 07:06:48 +0100
Subject: [PATCH 11/41] updated lang ref

---
 docs/compact/reference/lang-ref.mdx | 58 +++++++++++++----------------
 1 file changed, 25 insertions(+), 33 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 317d7de3..60f58313 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -388,8 +388,8 @@ The following are the primitive types of Compact:
   The current maximum field value is given in
   [Implementation-specific limits](#implementation-specific-limits).
 
-- `[T, ⋯]`, where `T, ⋯` are zero or more comma-separated types, is the type
-  of *tuple* values with element types `T, ⋯`.
+- `[T, `⋯`]`, where `T`, ⋯ are zero or more comma-separated types, is the type
+  of *tuple* values with element types `T`, ⋯.
   Tuples are heterogeneous: any element type can differ from any of the others.
   The *length* of a tuple type is the number of element types.
   Two tuple types with different lengths are different types.
@@ -399,7 +399,7 @@ The following are the primitive types of Compact:
 
 - `Vector<n, T>`, where `n` is a natural number literal or generic natural-number
   parameter and `T` is a type, is a shorthand notation for the tuple type
-  `[T, ⋯]` with `n` occurrences of the type `T`.
+  `[T, `⋯`]` with `n` occurrences of the type `T`.
   Note that a vector type and the corresponding tuple type are two different ways
   of writing exactly the same type.
   Unless otherwise specified, type rules for vector types are derived from the
@@ -635,7 +635,7 @@ Subtyping is defined by the following rules:
 - Any type `T` is a subtype of itself (subtyping is reflexive)
 - `Uint<0..n>` is a subtype of `Uint<0..m>` if `n` is less than (or equal to) `m`
 - `Uint<0..n>` is a subtype of `Field` for all `n`
-- The tuple type `[T, ⋯]` is a subtype of the tuple type `[S, ⋯]`
+- The tuple type `[T, `⋯`]` is a subtype of the tuple type `[S, `⋯`]`
   if they have the same length and each type `T` is a subtype of the
   corresponding type `S`.
 
@@ -651,12 +651,12 @@ Note that least upper bounds do not exist for all sets of types, because
 some types (such as `Boolean` and `Field`) are not related.
 
 **Tuple and vector types:** Every vector type has an equivalent tuple type:
-`Vector<n, T>` is equivalent to (in fact, the same type as) `[T1, ⋯, Tn]`.
+`Vector<n, T>` is equivalent to (in fact, the same type as) `[T1, `⋯`, Tn]`.
 The converse is not always true.
 For example, neither `[Boolean, Field]` nor `[Uint<8>, Uint<16>]` have an
 equivalent vector type.
 
-We say, however, that a tuple type <tt>[T1, ⋯, Tn]</tt> with possibly distinct types `T1, ⋯, Tn`
+We say, however, that a tuple type `[T1, `⋯`, Tn]` with possibly distinct types `T1`, ⋯, `Tn`
 "*has a vector type*" if the least upper bound `S` of the set of types \{`T1`, ⋯, `Tn`}
 exists.
 In that case, the tuple type has the vector type `Vector<n, S>`.
@@ -671,7 +671,7 @@ vector type `Vector<2, Uint<16>>`, but the types are not equivalent.
 
 Every vector type is a subtype of the equivalent tuple type and possibly of some
 other tuple types.
-In general, a vector type `Vector<n, T>` is a subtype of a tuple type `[S1, ⋯, Sn]`
+In general, a vector type `Vector<n, T>` is a subtype of a tuple type `[S1, `⋯`, Sn]`
 if `T` is a subtype of each of the types `S1`, ⋯, `Sn`.
 The means, for instance, that a vector can often be passed to a circuit where a
 tuple is expected.
@@ -1220,9 +1220,7 @@ The following *ledger-state types* are supported.
 
 Each ledger type supports a set of operations, which can be invoked with
 
-```compact
-<field name>.<operation>(<arguments ⋯>)
-```
+`<field name>.<operation>(<arguments `⋯`>)`
 
 A ledger field that is declared with a Compact type `T` implicitly has the type
 `Cell<T>`, which supports several operations, including `read`, `write`, and
@@ -1524,15 +1522,9 @@ A Compact program can declare a circuit to be pure by prefixing the circuit
 definition with the `pure` modifier, which must follow the `export` modifier,
 if present, e.g.:
 
-```compact
-pure circuit c(a: Field): Field {
-  ⋯
-}
+`pure circuit c(a: Field): Field { `⋯` }`
 
-export pure circuit c(a: Field): Field {
-  ⋯
-}
-```
+`export pure circuit c(a: Field): Field { `⋯` }`
 
 The only effect of the `pure` modifier is that the compiler flags the
 declaration as an error if its own analysis determines that the circuit is
@@ -2022,7 +2014,7 @@ are as follows:
 - `Boolean`: the value of the literal `false`
 - `Uint<0..n>` and `Uint<n>`: `0`
 - `Field`: `0`
-- `[T, ⋯]` where `T, ⋯` is a sequence of zero or more types: the tuple with
+- `[T, `⋯`]` where `T`, ⋯ is a sequence of zero or more types: the tuple with
   the corresponding length, each of the default value of the corresponding type
 - `Bytes<n>`: the byte vector of length `n` with all zero bytes
 - `Opaque<"string">`: an empty string, i.e., `""`
@@ -2247,8 +2239,8 @@ message indicating that the cast of the value to `Feet` failed.
 
 ### Tuple creation
 
-New tuple values are created with expressions of the form `[tuple-arg, ⋯]` where
-`tuple-arg, ⋯` is a sequence of zero or more comma-separated tuple
+New tuple values are created with expressions of the form `[tuple-arg, `⋯`]` where
+`tuple-arg`, ⋯ is a sequence of zero or more comma-separated tuple
 arguments.
 A non-empty sequence can have an optional trailing comma.
 Each tuple argument is either an expression or a *spread*.
@@ -2260,8 +2252,8 @@ If a tuple argument is a spread `... expr`, the type `T` of `expr` must be
 a tuple type, a Vector type, or a Bytes type.
 Otherwise, it is a static error.
 
-If `expr` has a tuple type `[U, ⋯]` of length *n*, the spread contributes
-`n` new elements of type `U, ⋯` to to the new tuple, i.e., the elements
+If `expr` has a tuple type `[U, `⋯`]` of length *n*, the spread contributes
+`n` new elements of type `U`, ⋯ to to the new tuple, i.e., the elements
 of the tuple value of `expr`.
 If `expr` has a Vector type `Vector<n, U>`, the spread contributes
 `n` new elements of type `U` to to the new tuple, i.e., the elements
@@ -2282,7 +2274,7 @@ which can be less than or greater than number of tuple arguments.
 ### Byte-vector creation
 
 New byte vectors are created with expressions of the form
-`Bytes [tuple-arg, ⋯]`.
+`Bytes [tuple-arg, `⋯`]`.
 Bytes creation is essentially the same as [tuple creation](#tuple-creation)
 except that the types of the contributed elements must all be subtypes of `Uint<8>`
 (if not, it is static error), and the result is a new byte vector of type
@@ -2327,10 +2319,10 @@ via the following rules, or it is a static error.
 
 The type of a byte-vector reference is `Uint<8>`.
 The type of a vector reference where the vector has type `Vector<n, T>` is `T`.
-The type of a tuple reference where the tuple has type `[T1, ⋯, Tn]` is
+The type of a tuple reference where the tuple has type `[T1, `⋯`, Tn]` is
 `Ti` if `index` is the constant `i` or the value `i` of a generic natural-number
 parameter.
-Otherwise, `[T1, ⋯, Tn]` must have a vector type `Vector<n, T>` and the
+Otherwise, `[T1, `⋯`, Tn]` must have a vector type `Vector<n, T>` and the
 type of the tuple reference is `T`.
 
 The value of a sequence reference is element `i` (zero-based) of the result
@@ -2353,10 +2345,10 @@ references](#tuple-vector-and-byte-vector-references).
 
 The type of a byte-vector slice is `Bytes<k>` where `k` is the constant value of `size`.
 The type of a vector slice where the vector has type `Vector<n, T>` is `Vector<k, T>`.
-The type of a tuple slice where the tuple has type `[T1, ⋯, Tn]` is the subsequence
-`[Ti, ⋯, Tj]` starting with element `i` (zero-based) and ending with element
-`j = i + k - 1` of `[T1, ⋯, Tn]`.
-Otherwise, `[T1, ⋯, Tn]` must have a vector type `Vector<n, T>` and the
+The type of a tuple slice where the tuple has type `[T1, `⋯`, Tn]` is the subsequence
+`[Ti, `⋯`, Tj]` starting with element `i` (zero-based) and ending with element
+`j = i + k - 1` of `[T1, `⋯`, Tn]`.
+Otherwise, `[T1, `⋯`, Tn]` must have a vector type `Vector<n, T>` and the
 type of the tuple reference is `Vector<k, T>`.
 
 The value of a `slice` expression is subsequence of the original tuple, vector,
@@ -2387,9 +2379,9 @@ Bytes[18, 19, 20]
 ### Structure creation
 
 Structure values are created with structure creation expressions.  The
-expression `T {f, ⋯}` is a structure creation expression, where `T` is a
-structure type name `S` or specialized generic structure type name `S<garg, ⋯>`,
-and `f, ⋯` is a sequence of zero or more comma-separated field-value specifiers.
+expression `T {f, `⋯`}` is a structure creation expression, where `T` is a
+structure type name `S` or specialized generic structure type name `S<garg, `⋯`>`,
+and `f, `⋯ is a sequence of zero or more comma-separated field-value specifiers.
 
 A field-value specifier can be one of three things:
 

From 290eabc9b26c2e6023d43d51838b44f02081198c Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Wed, 11 Mar 2026 11:00:52 +0100
Subject: [PATCH 12/41] latest compact-reference.mdx and compact-grammar.mdx

---
 docs/compact/reference/compact-grammar.mdx |  4 +-
 docs/compact/reference/lang-ref.mdx        | 64 +++++++++++++++++++---
 2 files changed, 59 insertions(+), 9 deletions(-)

diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index 8a7ba085..6eeda71a 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -6,9 +6,9 @@ title: Compact grammar
 
 # Compact grammar
 
-Compact language version 0.21.101.
+Compact language version 0.22.0.
 
-Notational note: In the grammar below, terminals are in `monospaced` font. Non-terminals are in *emphasized* font. Alternation is indicated by a vertical bar (`|`). Optional items are indicated by the superscript <sup>opt</sup>. Repetition is specified by ellipses. The notation *X* ⋯ *X*, where *X* is a grammar symbol, represents zero or more occurrences of *X*. The notation *X* `,` ⋯ `,` *X*, where *X* is a grammar symbol and `,` is a literal comma, represents zero or more occurrences of *X* separated by commas. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one *X*. When such a sequence is followed by *,*<sup>opt</sup>, an optional trailing comma is allowed, but only if there is at least one *X*. For example, *id* ⋯ *id* represents zero or more *id*s, and *expr* `,` ⋯¹`,` *expr* `,`<sup>opt</sup> represents one or more comma-separated *expr*s possibly followed by an extra comma. The rules involving commas apply equally to semicolons, i.e., apply when `,` is replaced by `;`.
+Notational note: In the grammar below, keywords and punctuation are in `monospaced` font. Terminal and nonterminal names are in *emphasized* font. Alternation is indicated by a vertical bar (`|`). Optional items are indicated by the superscript <sup>opt</sup>. Repetition is specified by ellipses. The notation *X* ⋯ *X*, where *X* is a grammar symbol, represents zero or more occurrences of *X*. The notation *X* `,` ⋯ `,` *X*, where *X* is a grammar symbol and `,` is a literal comma, represents zero or more occurrences of *X* separated by commas. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one *X*. When such a sequence is followed by *,*<sup>opt</sup>, an optional trailing comma is allowed, but only if there is at least one *X*. For example, *id* ⋯ *id* represents zero or more *id*s, and *expr* `,` ⋯¹`,` *expr* `,`<sup>opt</sup> represents one or more comma-separated *expr*s possibly followed by an extra comma. The rules involving commas apply equally to semicolons, i.e., apply when `,` is replaced by `;`.
 
 #### <a name="end-of-file">end-of-file</a> (*eof*)
 
diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 3808e3f0..6fa10551 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -91,11 +91,11 @@ separately.
 
 ## Notation
 
-The syntax of Compact programs is given by an EBNF grammar.  We use the
-following notational conventions in the grammar:
+The syntax of Compact programs is given by EBNF grammar snippets that
+use the following notational conventions:
 
-- Terminals are in `monospaced` font.
-- Non-terminals are in *emphasized* font.
+- Keywords and punctuation are in `monospaced` font.
+- Terminal and nonterminal names are in *emphasized* font.
 - Alternation is indicated by a vertical bar (`|`).
 - Optional items are indicated by the superscript <sup>opt</sup>.
 - Repetition is specified by ellipses.
@@ -114,6 +114,54 @@ following notational conventions in the grammar:
   The rules involving commas apply equally to semicolons, i.e., apply when
   `,` is replaced by `;`.
 
+Every program is formed of characters that are organized into atomic
+sequences of characters known as *tokens*.
+Each keyword and punctionation symbol appearing in the grammar snippets
+represents itself exactly, i.e., represents the token consisting of
+the same sequence of characters.
+For example, when the keyword `circuit` appears in a grammar snippet,
+it matches only the token `circuit`, and when the punctuation symbol
+`:` appears, it matches only the token `:`.
+
+Each terminal name appearing in the grammar snippets represents a set
+of possible tokens.
+For example, the terminal name *id* represents the set of all
+identifiers: when *id* appears in a grammar snippet, it matches any
+identifier.
+The sets of tokens represented by the terminal names appearing in
+the grammar snippets are described in
+[Terminal names](#terminal-names) below.
+
+Each nonterminal name appearing in the grammar snippets represents a
+sequence of tokens that comprise some structured piece of a program.
+For example, the terminal name *expr* matches any sequence of tokens
+that can be interpreted as an expression, such as `3 + x` or
+`a ? b : c`.
+The set of structures represented by each nonterminal name is given
+in the various sections of this reference manual along with typing
+and evaluation rules where appropriate.
+For example, the structure of a *circuit-definition* is described
+in [Circuits definitions](#circuit-definitions).
+
+## Terminal names
+
+The following terminal names appear in the grammar snippets.
+
+- *id*, *module-name*, *function-name*, *struct-name*, *enum-name*,
+*contract-name*, *tvar-name*, and *type-name*
+all represent identifier tokens.
+
+- *nat* represents natural-number literals.
+
+- *str* and *file* represent string literals.
+
+- *version* represents version literals (in pragmas).
+
+While identifiers and string literals are each represented by more than one name,
+each representes the entire set of possible identifier or string-literal tokens.
+The grammar snippets use different terminal names only to suggest their use, e.g,
+*module-name* for module names versus *tvar-name* for type variable names.
+
 ## Static and dynamic errors
 
 The compiler detects various kinds of *static errors*, e.g., malformed syntax,
@@ -248,7 +296,7 @@ Various entities, specifically
 [module declarations](#modules-exports-and-imports),
 [structure declarations](#structure-types),
 [type-alias declarations](#type-aliases),
-[circuit definitions](#circuits),
+[circuit definitions](#circuit-definitions),
 and
 [witness declarations](#declaring-witnesses-for-private-state-management),
 can have *generic parameters*, i.e., compile-time type and numeric (natural-number)
@@ -855,7 +903,7 @@ Briefly:
 - A [witness declaration](#declaring-witnesses-for-private-state-management) declare a witness, which is a function provided by the Dapp.
 - A [ledger declaration](#declaring-and-maintaining-public-state) declares one field of the contract's public state.
 - A [constructor definition](#contract-constructor) defines the contract's constructor, if any.
-- A [circuit definition](#circuits) defines a circuit.
+- A [circuit definition](#circuit-definitions) defines a circuit.
 
 The order of program elements in a program or module is unimportant, except that
 any module must be defined before any import of the module, and any program-defined
@@ -1085,6 +1133,8 @@ TypeScript driver for the smart contract.
 
 The circuits exported at the top level of a contract (i.e., not merely exported
 from a module) are the entry points of the contract.
+(A Compact program has no "main" entry point, but is more similar to a library
+containing multiple entry points that share a common store.)
 Although multiple circuits with the same name are allowed generally to support
 [function overloading](#circuit-and-witness-calls), it is a static error if more
 than one circuit with the same name is exported from the top level.
@@ -1445,7 +1495,7 @@ The return type of the constructor is always `[]`.
 Any attempt to return another type of value using `return expression;` where the
 type of `expression` is something other than `[]`, is a static error.
 
-## Circuits
+## Circuit definitions
 
 The basic operational element in Compact is the `circuit`.
 This corresponds closely to a function in most languages but is designed

From 5854c37ec99cfd2eeb97617ab8b5d67a41430c44 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Wed, 11 Mar 2026 15:27:10 +0100
Subject: [PATCH 13/41] latest lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 32 +++++++++++++++++++++--------
 1 file changed, 23 insertions(+), 9 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 6fa10551..e502cf3d 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -116,7 +116,7 @@ use the following notational conventions:
 
 Every program is formed of characters that are organized into atomic
 sequences of characters known as *tokens*.
-Each keyword and punctionation symbol appearing in the grammar snippets
+Each keyword and punctuation symbol appearing in the grammar snippets
 represents itself exactly, i.e., represents the token consisting of
 the same sequence of characters.
 For example, when the keyword `circuit` appears in a grammar snippet,
@@ -178,7 +178,7 @@ These errors are reported when the generated code is run.
 
 Identifiers are used in Compact, as in most other programming languages, to
 name things.
-Syntactally, an *identifier* is a *token* (atomic sequence of characters), beginning
+Syntactically, an *identifier* is a *token* (atomic sequence of characters), beginning
 with with an alphabetic character, a dollar sign (`$`), or an underscore (`_`)
 followed by one or more alphabetic characters, digits (`0` - `9`), dollar signs,
 or underscores.
@@ -895,12 +895,12 @@ Briefly:
   contains a sequence of program elements in its own nested scope.
 - An [export form](#exports) exports bindings from a module or from [the program itself](#top-level-exports).
 - An [import form](#imports) imports bindings from a Compact module.
-- An [include form](#include-files) allows program elements to be included from other Compact programs
+- An [include form](#include-files) allows program elements to be included from other files.
 - A [structure definition](#structure-types) defines a structure type.
 - An [enumeration definition](#enumeration-types) define an enumeration type.
 - A [contract declaration](#contract-types) declares a contract type.
-- A [type alias definition](#type-aliases) defines a type alias, possibly creating a distinct type.
-- A [witness declaration](#declaring-witnesses-for-private-state-management) declare a witness, which is a function provided by the Dapp.
+- A [type-alias definition](#type-aliases) defines a type alias, possibly creating a distinct type.
+- A [witness declaration](#declaring-witnesses-for-private-state-management) declare a witness, which is a callback function provided by the Dapp.
 - A [ledger declaration](#declaring-and-maintaining-public-state) declares one field of the contract's public state.
 - A [constructor definition](#contract-constructor) defines the contract's constructor, if any.
 - A [circuit definition](#circuit-definitions) defines a circuit.
@@ -917,9 +917,8 @@ section.
 
 ## Pragmas
 
-A pragma declares a constraint on either the compiler version or the language
-version. The valid identifiers for the language and compiler versions are
-`language_version` and `compiler_version`, respectively.
+A pragma takes the following form and declares a constraint on either the compiler
+version (*id* = `compiler_version`) or the language version (*id* = `language_version`)
 
 <table className="lang-ref-table"><tbody><tr><td><em>pragma-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>pragma</tt></b>&nbsp;&nbsp;<a href="#to-be-filled-in"><em>id</em></a>&nbsp;&nbsp;<em>version-expr</em>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr>
 <tr><td><em>version-expr</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>version-expr</em>&nbsp;&nbsp;<b><tt>||</tt></b>&nbsp;&nbsp;<em>version-expr<sub>0</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>version-expr<sub>0</sub></em></td></tr>
@@ -927,13 +926,28 @@ version. The valid identifiers for the language and compiler versions are
 <tr><td><em>version-term</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\<=</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>>=</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>version-expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
 <tr><td><em>version-atom</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#constants"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#constants"><em>version</em></a></td></tr></tbody></table>
 
+*version* is a dot-separated pair or trio of natural numbers, so along
+with *nat* this allows *version* to be either a single natural number,
+a pair of natural numbers separated by a `.`, or a trio of natural numbers
+separate by a `.`, e.g., `1`, `1.2`, or `1.2.7`.
+
+For example, if a program includes the following pragma form:
+
+```compact
+pragma compiler_version >= 1.0.0 && !1.0.5;
+```
+
+All versions of the compiler from 1.0.0 up except for 1.0.5 will accept
+the pragma and compile the program, and all other versions will print an
+appropriate message and discontinue compilation of the program.
+
 ## Modules, exports, and imports
 
 Modules in Compact are used for namespace management and also possibly to split
 programs into multiple files.
 A module is a named collection of program elements created via a `module definition`:
 
-<table className="lang-ref-table"><tbody><tr><td><em>module-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>module</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>module-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#programs"><em>pelt</em></a> &hellip; <a href="#programs"><em>pelt</em></a>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></tbody></table>
+<table className="lang-ref-table"><tbody><tr><td><em>module-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>module</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>module-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#programs"><em>pelt</em></a> ⋯ <a href="#programs"><em>pelt</em></a>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></tbody></table>
 
 A module definition makes a binding from `module-name` to the module visible in
 the program or module containing the module definition.

From 5b5c57672e81a7960adba2288b22a22473f2a7bd Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Wed, 11 Mar 2026 16:21:53 +0100
Subject: [PATCH 14/41] current lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index e502cf3d..b7173359 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -945,7 +945,8 @@ appropriate message and discontinue compilation of the program.
 
 Modules in Compact are used for namespace management and also possibly to split
 programs into multiple files.
-A module is a named collection of program elements created via a `module definition`:
+A module is a named collection of program elements created via a module definition,
+which takes the following form:
 
 <table className="lang-ref-table"><tbody><tr><td><em>module-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>module</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>module-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#programs"><em>pelt</em></a> ⋯ <a href="#programs"><em>pelt</em></a>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></tbody></table>
 
@@ -1039,7 +1040,7 @@ the file `M.compact` in the same directory as the importing file or in one of th
 directories in the compact path.
 If *M* is a string `"{prefix/}M"`, where `{prefix/}` is either empty or is
 a pathname ending in a directory separator, a definition for a module named
-`M` must be contained within a file `M.compact` that is:
+`M` must be contained within a file `M.compact` that is either:
 - (a) if `{prefix/}M.compact` is an absolute pathname, then exactly at
   `{prefix/}M.compact`, otherwise
 - (b) at `{prefix/}M.compact` relative to the directory of the importing

From 0d3144f98f44bb5f0bb4ce2b1f43168566b08624 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Wed, 11 Mar 2026 21:48:33 +0100
Subject: [PATCH 15/41] added border: none; to custom.css code {} section to
 eliminate the faint border when using the dark on white mode.

---
 src/css/custom.css | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/css/custom.css b/src/css/custom.css
index d62d44fb..4af76798 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -528,6 +528,7 @@ code {
   background-color: transparent;
   padding: 0;
   border-radius: 0;
+  border: none;
 }
 
 pre {

From 0141f2e96d5d37aa13cacfce3927f4461245a397 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Thu, 12 Mar 2026 16:04:41 +0100
Subject: [PATCH 16/41] latest lang-ref.mdx and compact-grammar.mdx

---
 docs/compact/reference/compact-grammar.mdx | 140 ++++----
 docs/compact/reference/lang-ref.mdx        | 376 ++++++++++++++++-----
 2 files changed, 361 insertions(+), 155 deletions(-)

diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index 6eeda71a..088806f3 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -30,7 +30,7 @@ A string literal has the same syntax as a Typescript string.
 
 A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2.3, representing major, minor, and bugfix versions.
 
-#### <a name="Compact">Compact</a> (**program**)
+#### <a name="Compact">Compact</a> (*program*)
 
 <div className="lang-ref-table">
 |           |         |                                                                               |
@@ -38,7 +38,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *program* | &xrarr; | [*pelt*](#Program-element) ⋯ [*pelt*](#Program-element) [*eof*](#end-of-file) |
 </div>
 
-#### <a name="Program-element">Program-element</a> (**pelt**)
+#### <a name="Program-element">Program-element</a> (*pelt*)
 
 <div className="lang-ref-table">
 |        |         |                                                          |
@@ -58,7 +58,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |        | \|      | [*circuit-definition*](#Circuit-definition)              |
 </div>
 
-#### <a name="Pragma">Pragma</a> (**pragma-form**)
+#### <a name="Pragma">Pragma</a> (*pragma-form*)
 
 <div className="lang-ref-table">
 |               |         |                                                                        |
@@ -66,7 +66,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *pragma-form* | &xrarr; | `pragma` [*id*](#identifier) [*version-expr*](#Version-expression) `;` |
 </div>
 
-#### <a name="Version-expression">Version-expression</a> (**version-expr**)
+#### <a name="Version-expression">Version-expression</a> (*version-expr*)
 
 <div className="lang-ref-table">
 |                |         |                                                                                                 |
@@ -75,7 +75,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                | \|      | [*version-expr<sub>0</sub>*](#Version-expression0)                                              |
 </div>
 
-#### <a name="Version-expression0">Version-expression<sub>0</sub></a> (**version-expr<sub>0</sub>**)
+#### <a name="Version-expression0">Version-expression<sub>0</sub></a> (*version-expr<sub>0</sub>*)
 
 <div className="lang-ref-table">
 |                            |         |                                                                                         |
@@ -84,7 +84,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                            | \|      | [*version-term*](#Version-Term)                                                         |
 </div>
 
-#### <a name="Version-Term">Version-Term</a> (**version-term**)
+#### <a name="Version-Term">Version-Term</a> (*version-term*)
 
 <div className="lang-ref-table">
 |                |         |                                               |
@@ -98,7 +98,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                | \|      | `(` [*version-expr*](#Version-expression) `)` |
 </div>
 
-#### <a name="Version-atom">Version-atom</a> (**version-atom**)
+#### <a name="Version-atom">Version-atom</a> (*version-atom*)
 
 <div className="lang-ref-table">
 |                |         |                               |
@@ -107,7 +107,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                | \|      | [*version*](#version-literal) |
 </div>
 
-#### <a name="Include">Include</a> (**include-form**)
+#### <a name="Include">Include</a> (*include-form*)
 
 <div className="lang-ref-table">
 |                |         |                                         |
@@ -115,7 +115,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *include-form* | &xrarr; | `include` [*file*](#string-literal) `;` |
 </div>
 
-#### <a name="Module-definition">Module-definition</a> (**module-definition**)
+#### <a name="Module-definition">Module-definition</a> (*module-definition*)
 
 <div className="lang-ref-table">
 |                     |         |                                                                                                                                                                                 |
@@ -123,7 +123,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*pelt*](#Program-element) ⋯ [*pelt*](#Program-element) `}` |
 </div>
 
-#### <a name="Generic-parameter-list">Generic-parameter-list</a> (**gparams**)
+#### <a name="Generic-parameter-list">Generic-parameter-list</a> (*gparams*)
 
 <div className="lang-ref-table">
 |           |         |                                                                                                                 |
@@ -131,7 +131,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *gparams* | &xrarr; | `<` [*generic-param*](#Generic-parameter) `,` ⋯ `,` [*generic-param*](#Generic-parameter) `,`<sup>opt</sup> `>` |
 </div>
 
-#### <a name="Generic-parameter">Generic-parameter</a> (**generic-param**)
+#### <a name="Generic-parameter">Generic-parameter</a> (*generic-param*)
 
 <div className="lang-ref-table">
 |                 |         |                                |
@@ -140,7 +140,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                 | \|      | [*tvar-name*](#identifier)     |
 </div>
 
-#### <a name="Import-declaration">Import-declaration</a> (**import-form**)
+#### <a name="Import-declaration">Import-declaration</a> (*import-form*)
 
 <div className="lang-ref-table">
 |               |         |                                                                                                                                                                                                  |
@@ -148,7 +148,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *import-form* | &xrarr; | `import` [*import-selection*](#Import-selection)<sup>opt</sup> [*import-name*](#Import-name) [*gargs*](#Generic-argument-list)<sup>opt</sup> [*import-prefix*](#Import-prefix)<sup>opt</sup> `;` |
 </div>
 
-#### <a name="Import-selection">Import-selection</a> (**import-selection**)
+#### <a name="Import-selection">Import-selection</a> (*import-selection*)
 
 <div className="lang-ref-table">
 |                    |         |                                                                                                                    |
@@ -156,7 +156,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *import-selection* | &xrarr; | `{` [*import-element*](#Import-element) `,` ⋯ `,` [*import-element*](#Import-element) `,`<sup>opt</sup> `}` `from` |
 </div>
 
-#### <a name="Import-element">Import-element</a> (**import-element**)
+#### <a name="Import-element">Import-element</a> (*import-element*)
 
 <div className="lang-ref-table">
 |                  |         |                                              |
@@ -165,7 +165,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                  | \|      | [*id*](#identifier) `as` [*id*](#identifier) |
 </div>
 
-#### <a name="Import-name">Import-name</a> (**import-name**)
+#### <a name="Import-name">Import-name</a> (*import-name*)
 
 <div className="lang-ref-table">
 |               |         |                           |
@@ -174,7 +174,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |               | \|      | [*file*](#string-literal) |
 </div>
 
-#### <a name="Import-prefix">Import-prefix</a> (**import-prefix**)
+#### <a name="Import-prefix">Import-prefix</a> (*import-prefix*)
 
 <div className="lang-ref-table">
 |                 |         |                              |
@@ -182,7 +182,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *import-prefix* | &xrarr; | `prefix` [*id*](#identifier) |
 </div>
 
-#### <a name="Generic-argument-list">Generic-argument-list</a> (**gargs**)
+#### <a name="Generic-argument-list">Generic-argument-list</a> (*gargs*)
 
 <div className="lang-ref-table">
 |         |         |                                                                                             |
@@ -190,7 +190,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *gargs* | &xrarr; | `<` [*garg*](#Generic-argument) `,` ⋯ `,` [*garg*](#Generic-argument) `,`<sup>opt</sup> `>` |
 </div>
 
-#### <a name="Generic-argument">Generic-argument</a> (**garg**)
+#### <a name="Generic-argument">Generic-argument</a> (*garg*)
 
 <div className="lang-ref-table">
 |        |         |                         |
@@ -199,7 +199,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |        | \|      | [*type*](#Type)         |
 </div>
 
-#### <a name="Export-declaration">Export-declaration</a> (**export-form**)
+#### <a name="Export-declaration">Export-declaration</a> (*export-form*)
 
 <div className="lang-ref-table">
 |               |         |                                                                                                        |
@@ -207,7 +207,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *export-form* | &xrarr; | `export` `{` [*id*](#identifier) `,` ⋯ `,` [*id*](#identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### <a name="Ledger-declaration">Ledger-declaration</a> (**ledger-declaration**)
+#### <a name="Ledger-declaration">Ledger-declaration</a> (*ledger-declaration*)
 
 <div className="lang-ref-table">
 |                      |         |                                                                                                    |
@@ -215,7 +215,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *ledger-declaration* | &xrarr; | `export`<sup>opt</sup> `sealed`<sup>opt</sup> `ledger` [*id*](#identifier) `:` [*type*](#Type) `;` |
 </div>
 
-#### <a name="Witness-declaration">Witness-declaration</a> (**witness-declaration**)
+#### <a name="Witness-declaration">Witness-declaration</a> (*witness-declaration*)
 
 <div className="lang-ref-table">
 |                       |         |                                                                                                                                                                                   |
@@ -223,7 +223,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *witness-declaration* | &xrarr; | `export`<sup>opt</sup> `witness` [*id*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> [*simple-parameter-list*](#Simple-parameter-list) `:` [*type*](#Type) `;` |
 </div>
 
-#### <a name="Constructor">Constructor</a> (**constructor-definition**)
+#### <a name="Constructor">Constructor</a> (*constructor-definition*)
 
 <div className="lang-ref-table">
 |                          |         |                                                                                     |
@@ -231,7 +231,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *constructor-definition* | &xrarr; | `constructor` [*pattern-parameter-list*](#Pattern-parameter-list) [*block*](#Block) |
 </div>
 
-#### <a name="Circuit-definition">Circuit-definition</a> (**circuit-definition**)
+#### <a name="Circuit-definition">Circuit-definition</a> (*circuit-definition*)
 
 <div className="lang-ref-table">
 |                      |         |                                                                                                                                                                                                                                   |
@@ -239,16 +239,16 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *circuit-definition* | &xrarr; | `export`<sup>opt</sup> `pure`<sup>opt</sup> `circuit` [*function-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> [*pattern-parameter-list*](#Pattern-parameter-list) `:` [*type*](#Type) [*block*](#Block) |
 </div>
 
-#### <a name="Structure-declaration">Structure-declaration</a> (**struct-declaration**)
+#### <a name="Structure-declaration">Structure-declaration</a> (*struct-declaration*)
 
 <div className="lang-ref-table">
-|                      |         |                                                                                                                                                                                                                                                       |
-|----------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *struct-declaration* | &xrarr; | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-identifier*](#Typed-identifier) `;` ⋯ `;` [*typed-identifier*](#Typed-identifier) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
-|                      | \|      | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-identifier*](#Typed-identifier) `,` ⋯ `,` [*typed-identifier*](#Typed-identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                      |         |                                                                                                                                                                                                                                       |
+|----------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *struct-declaration* | &xrarr; | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-id*](#Typed-identifier) `;` ⋯ `;` [*typed-id*](#Typed-identifier) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                      | \|      | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-id*](#Typed-identifier) `,` ⋯ `,` [*typed-id*](#Typed-identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### <a name="Enum-declaration">Enum-declaration</a> (**enum-declaration**)
+#### <a name="Enum-declaration">Enum-declaration</a> (*enum-declaration*)
 
 <div className="lang-ref-table">
 |                    |         |                                                                                                                                                         |
@@ -256,7 +256,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *enum-declaration* | &xrarr; | `export`<sup>opt</sup> `enum` [*enum-name*](#identifier) `{` [*id*](#identifier) `,` ⋯¹ `,` [*id*](#identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### <a name="External-contract-declaration">External-contract-declaration</a> (**contract-declaration**)
+#### <a name="External-contract-declaration">External-contract-declaration</a> (*contract-declaration*)
 
 <div className="lang-ref-table">
 |                        |         |                                                                                                                                                                                                                                |
@@ -265,7 +265,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                        | \|      | `export`<sup>opt</sup> `contract` [*contract-name*](#identifier) `{` [*circuit-declaration*](#External-contract-circuit) `,` ⋯ `,` [*circuit-declaration*](#External-contract-circuit) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### <a name="External-contract-circuit">External-contract-circuit</a> (**circuit-declaration**)
+#### <a name="External-contract-circuit">External-contract-circuit</a> (*circuit-declaration*)
 
 <div className="lang-ref-table">
 |                       |         |                                                                                                                          |
@@ -273,7 +273,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *circuit-declaration* | &xrarr; | `pure`<sup>opt</sup> `circuit` [*id*](#identifier) [*simple-parameter-list*](#Simple-parameter-list) `:` [*type*](#Type) |
 </div>
 
-#### <a name="Type-declaration">Type-declaration</a> (**type-alias-declaration**)
+#### <a name="Type-declaration">Type-declaration</a> (*type-alias-declaration*)
 
 <div className="lang-ref-table">
 |                          |         |                                                                                                                                                         |
@@ -281,23 +281,23 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *type-alias-declaration* | &xrarr; | `export`<sup>opt</sup> `new`<sup>opt</sup> `type` [*type-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `=` [*type*](#Type) `;` |
 </div>
 
-#### <a name="Typed-identifier">Typed-identifier</a> (**typed-identifier**)
+#### <a name="Typed-identifier">Typed-identifier</a> (*typed-id*)
 
 <div className="lang-ref-table">
-|                    |         |                                         |
-|--------------------|---------|-----------------------------------------|
-| *typed-identifier* | &xrarr; | [*id*](#identifier) `:` [*type*](#Type) |
+|            |         |                                         |
+|------------|---------|-----------------------------------------|
+| *typed-id* | &xrarr; | [*id*](#identifier) `:` [*type*](#Type) |
 </div>
 
-#### <a name="Simple-parameter-list">Simple-parameter-list</a> (**simple-parameter-list**)
+#### <a name="Simple-parameter-list">Simple-parameter-list</a> (*simple-parameter-list*)
 
 <div className="lang-ref-table">
-|                         |         |                                                                                                                     |
-|-------------------------|---------|---------------------------------------------------------------------------------------------------------------------|
-| *simple-parameter-list* | &xrarr; | `(` [*typed-identifier*](#Typed-identifier) `,` ⋯ `,` [*typed-identifier*](#Typed-identifier) `,`<sup>opt</sup> `)` |
+|                         |         |                                                                                                     |
+|-------------------------|---------|-----------------------------------------------------------------------------------------------------|
+| *simple-parameter-list* | &xrarr; | `(` [*typed-id*](#Typed-identifier) `,` ⋯ `,` [*typed-id*](#Typed-identifier) `,`<sup>opt</sup> `)` |
 </div>
 
-#### <a name="Typed-pattern">Typed-pattern</a> (**typed-pattern**)
+#### <a name="Typed-pattern">Typed-pattern</a> (*typed-pattern*)
 
 <div className="lang-ref-table">
 |                 |         |                                           |
@@ -305,7 +305,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *typed-pattern* | &xrarr; | [*pattern*](#Pattern) `:` [*type*](#Type) |
 </div>
 
-#### <a name="Pattern-parameter-list">Pattern-parameter-list</a> (**pattern-parameter-list**)
+#### <a name="Pattern-parameter-list">Pattern-parameter-list</a> (*pattern-parameter-list*)
 
 <div className="lang-ref-table">
 |                          |         |                                                                                                         |
@@ -313,7 +313,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *pattern-parameter-list* | &xrarr; | `(` [*typed-pattern*](#Typed-pattern) `,` ⋯ `,` [*typed-pattern*](#Typed-pattern) `,`<sup>opt</sup> `)` |
 </div>
 
-#### <a name="Type">Type</a> (**type**)
+#### <a name="Type">Type</a> (*type*)
 
 <div className="lang-ref-table">
 |        |         |                                                                     |
@@ -329,7 +329,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |        | \|      | `[` [*type*](#Type) `,` ⋯ `,` [*type*](#Type) `,`<sup>opt</sup> `]` |
 </div>
 
-#### <a name="Type-reference">Type-reference</a> (**tref**)
+#### <a name="Type-reference">Type-reference</a> (*tref*)
 
 <div className="lang-ref-table">
 |        |         |                                                                     |
@@ -337,7 +337,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *tref* | &xrarr; | [*id*](#identifier) [*gargs*](#Generic-argument-list)<sup>opt</sup> |
 </div>
 
-#### <a name="Type-size">Type-size</a> (**tsize**)
+#### <a name="Type-size">Type-size</a> (*tsize*)
 
 <div className="lang-ref-table">
 |         |         |                         |
@@ -346,7 +346,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |         | \|      | [*id*](#identifier)     |
 </div>
 
-#### <a name="Block">Block</a> (**block**)
+#### <a name="Block">Block</a> (*block*)
 
 <div className="lang-ref-table">
 |         |         |                                                     |
@@ -354,7 +354,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *block* | &xrarr; | `{` [*stmt*](#Statement) ⋯ [*stmt*](#Statement) `}` |
 </div>
 
-#### <a name="Statement">Statement</a> (**stmt**)
+#### <a name="Statement">Statement</a> (*stmt*)
 
 <div className="lang-ref-table">
 |        |         |                                                                      |
@@ -363,7 +363,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |        | \|      | [*stmt<sub>0</sub>*](#Statement0)                                    |
 </div>
 
-#### <a name="Statement0">Statement<sub>0</sub></a> (**stmt<sub>0</sub>**)
+#### <a name="Statement0">Statement<sub>0</sub></a> (*stmt<sub>0</sub>*)
 
 <div className="lang-ref-table">
 |                    |         |                                                                                                                          |
@@ -378,7 +378,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    | \|      | [*block*](#Block)                                                                                                        |
 </div>
 
-#### <a name="Pattern">Pattern</a> (**pattern**)
+#### <a name="Pattern">Pattern</a> (*pattern*)
 
 <div className="lang-ref-table">
 |           |         |                                                                                                                                     |
@@ -388,7 +388,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |           | \|      | `{` [*pattern-struct-elt*](#Pattern-struct-element) `,` ⋯ `,` [*pattern-struct-elt*](#Pattern-struct-element) `,`<sup>opt</sup> `}` |
 </div>
 
-#### <a name="Pattern-struct-element">Pattern-struct-element</a> (**pattern-struct-elt**)
+#### <a name="Pattern-struct-element">Pattern-struct-element</a> (*pattern-struct-elt*)
 
 <div className="lang-ref-table">
 |                      |         |                                               |
@@ -397,7 +397,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                      | \|      | [*id*](#identifier) `:` [*pattern*](#Pattern) |
 </div>
 
-#### <a name="Expression-sequence">Expression-sequence</a> (**expr-seq**)
+#### <a name="Expression-sequence">Expression-sequence</a> (*expr-seq*)
 
 <div className="lang-ref-table">
 |            |         |                                                                                   |
@@ -406,7 +406,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |            | \|      | [*expr*](#Expression) `,` ⋯¹ `,` [*expr*](#Expression)  `,` [*expr*](#Expression) |
 </div>
 
-#### <a name="Expression">Expression</a> (**expr**)
+#### <a name="Expression">Expression</a> (*expr*)
 
 <div className="lang-ref-table">
 |        |         |                                                                                        |
@@ -418,7 +418,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |        | \|      | [*expr<sub>0</sub>*](#Expression0)                                                     |
 </div>
 
-#### <a name="Expression0">Expression<sub>0</sub></a> (**expr<sub>0</sub>**)
+#### <a name="Expression0">Expression<sub>0</sub></a> (*expr<sub>0</sub>*)
 
 <div className="lang-ref-table">
 |                    |         |                                                                              |
@@ -427,7 +427,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    | \|      | [*expr<sub>1</sub>*](#Expression1)                                           |
 </div>
 
-#### <a name="Expression1">Expression<sub>1</sub></a> (**expr<sub>1</sub>**)
+#### <a name="Expression1">Expression<sub>1</sub></a> (*expr<sub>1</sub>*)
 
 <div className="lang-ref-table">
 |                    |         |                                                                            |
@@ -436,7 +436,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    | \|      | [*expr<sub>2</sub>*](#Expression2)                                         |
 </div>
 
-#### <a name="Expression2">Expression<sub>2</sub></a> (**expr<sub>2</sub>**)
+#### <a name="Expression2">Expression<sub>2</sub></a> (*expr<sub>2</sub>*)
 
 <div className="lang-ref-table">
 |                    |         |                                                                            |
@@ -446,7 +446,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    | \|      | [*expr<sub>3</sub>*](#Expression3)                                         |
 </div>
 
-#### <a name="Expression3">Expression<sub>3</sub></a> (**expr<sub>3</sub>**)
+#### <a name="Expression3">Expression<sub>3</sub></a> (*expr<sub>3</sub>*)
 
 <div className="lang-ref-table">
 |                    |         |                                                                            |
@@ -458,7 +458,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    | \|      | [*expr<sub>4</sub>*](#Expression4)                                         |
 </div>
 
-#### <a name="Expression4">Expression<sub>4</sub></a> (**expr<sub>4</sub>**)
+#### <a name="Expression4">Expression<sub>4</sub></a> (*expr<sub>4</sub>*)
 
 <div className="lang-ref-table">
 |                    |         |                                                         |
@@ -467,7 +467,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    | \|      | [*expr<sub>5</sub>*](#Expression5)                      |
 </div>
 
-#### <a name="Expression5">Expression<sub>5</sub></a> (**expr<sub>5</sub>**)
+#### <a name="Expression5">Expression<sub>5</sub></a> (*expr<sub>5</sub>*)
 
 <div className="lang-ref-table">
 |                    |         |                                                                           |
@@ -477,7 +477,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    | \|      | [*expr<sub>6</sub>*](#Expression6)                                        |
 </div>
 
-#### <a name="Expression6">Expression<sub>6</sub></a> (**expr<sub>6</sub>**)
+#### <a name="Expression6">Expression<sub>6</sub></a> (*expr<sub>6</sub>*)
 
 <div className="lang-ref-table">
 |                    |         |                                                                           |
@@ -486,7 +486,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    | \|      | [*expr<sub>7</sub>*](#Expression7)                                        |
 </div>
 
-#### <a name="Expression7">Expression<sub>7</sub></a> (**expr<sub>7</sub>**)
+#### <a name="Expression7">Expression<sub>7</sub></a> (*expr<sub>7</sub>*)
 
 <div className="lang-ref-table">
 |                    |         |                                        |
@@ -495,7 +495,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    | \|      | [*expr<sub>8</sub>*](#Expression8)     |
 </div>
 
-#### <a name="Expression8">Expression<sub>8</sub></a> (**expr<sub>8</sub>**)
+#### <a name="Expression8">Expression<sub>8</sub></a> (*expr<sub>8</sub>*)
 
 <div className="lang-ref-table">
 |                    |         |                                                                                                                                            |
@@ -506,7 +506,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    | \|      | [*expr<sub>9</sub>*](#Expression9)                                                                                                         |
 </div>
 
-#### <a name="Expression9">Expression<sub>9</sub></a> (**expr<sub>9</sub>**)
+#### <a name="Expression9">Expression<sub>9</sub></a> (*expr<sub>9</sub>*)
 
 <div className="lang-ref-table">
 |                    |         |                                                                                                                                          |
@@ -523,7 +523,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                    | \|      | [*term*](#Term)                                                                                                                          |
 </div>
 
-#### <a name="Term">Term</a> (**term**)
+#### <a name="Term">Term</a> (*term*)
 
 <div className="lang-ref-table">
 |        |         |                                                                    |
@@ -538,7 +538,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |        | \|      | `(` [*expr-seq*](#Expression-sequence) `)`                         |
 </div>
 
-#### <a name="Tuple-argument">Tuple-argument</a> (**tuple-arg**, **bytes-arg**)
+#### <a name="Tuple-argument">Tuple-argument</a> (*tuple-arg*, *bytes-arg*)
 
 <div className="lang-ref-table">
 |             |         |                             |
@@ -548,7 +548,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *bytes-arg* | &xrarr; | *tuple-arg*                 |
 </div>
 
-#### <a name="Structure-argument">Structure-argument</a> (**struct-arg**)
+#### <a name="Structure-argument">Structure-argument</a> (*struct-arg*)
 
 <div className="lang-ref-table">
 |              |         |                                               |
@@ -558,7 +558,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |              | \|      | `...` [*expr*](#Expression)                   |
 </div>
 
-#### <a name="Function">Function</a> (**fun**)
+#### <a name="Function">Function</a> (*fun*)
 
 <div className="lang-ref-table">
 |       |         |                                                                                                                        |
@@ -569,7 +569,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |       | \|      | `(` [*fun*](#Function) `)`                                                                                             |
 </div>
 
-#### <a name="Return-type">Return-type</a> (**return-type**)
+#### <a name="Return-type">Return-type</a> (*return-type*)
 
 <div className="lang-ref-table">
 |               |         |                     |
@@ -577,7 +577,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *return-type* | &xrarr; | `:` [*type*](#Type) |
 </div>
 
-#### <a name="Optionally-typed-pattern">Optionally-typed-pattern</a> (**optionally-typed-pattern**)
+#### <a name="Optionally-typed-pattern">Optionally-typed-pattern</a> (*optionally-typed-pattern*)
 
 <div className="lang-ref-table">
 |                            |         |                                   |
@@ -586,7 +586,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                            | \|      | [*typed-pattern*](#Typed-pattern) |
 </div>
 
-#### <a name="Const-Binding">Const-Binding</a> (**cbinding**)
+#### <a name="Const-Binding">Const-Binding</a> (*cbinding*)
 
 <div className="lang-ref-table">
 |            |         |                                                                                   |
@@ -594,7 +594,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *cbinding* | &xrarr; | [*optionally-typed-pattern*](#Optionally-typed-pattern) `=` [*expr*](#Expression) |
 </div>
 
-#### <a name="Arrow-parameter-list">Arrow-parameter-list</a> (**arrow-parameter-list**)
+#### <a name="Arrow-parameter-list">Arrow-parameter-list</a> (*arrow-parameter-list*)
 
 <div className="lang-ref-table">
 |                        |         |                                                                                                                                                     |
diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index b7173359..305cdf21 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -315,8 +315,14 @@ Each parameter is either a type name (e.g., `T`) or a hash-prefixed natural-numb
 Generic natural-number parameters are prefixed by `#` to distingish them from
 generic type parameters.
 
-<table className="lang-ref-table"><tbody><tr><td><em>gparams</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>generic-param</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>generic-param</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr>
-<tr><td><em>generic-param</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>#</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>tvar-name</em></a></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                 |         |                                                                                                                                               |
+|-----------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------|
+| *gparams*       | &xrarr; | `<` [*generic-param*](#generic-parameters-and-arguments) `,` ⋯ `,` [*generic-param*](#generic-parameters-and-arguments) `,`<sup>opt</sup> `>` |
+| *generic-param* | &xrarr; | `#` [*tvar-name*](#terminal-names)                                                                                                            |
+|                 | \|      | [*tvar-name*](#terminal-names)                                                                                                                |
+</div>
+
 
 Generic entities must be *specialized* at the point of use to produce non-generic
 entities at compile time by supplying them with *generic arguments*.
@@ -325,8 +331,14 @@ Generic arguments are also enclosed in angle brackets.
 Each generic argument must be a type, a natural number literal, or the type or
 numeric value of a generic parameter.
 
-<table className="lang-ref-table"><tbody><tr><td><em>gargs</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>garg</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>garg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>></tt></b></td></tr>
-<tr><td><em>garg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
+<div className="lang-ref-table">
+|         |         |                                                                                                                             |
+|---------|---------|-----------------------------------------------------------------------------------------------------------------------------|
+| *gargs* | &xrarr; | `<` [*garg*](#generic-parameters-and-arguments) `,` ⋯ `,` [*garg*](#generic-parameters-and-arguments) `,`<sup>opt</sup> `>` |
+| *garg*  | &xrarr; | [*nat*](#terminal-names)                                                                                                    |
+|         | \|      | [*type*](#primitive-types)                                                                                                  |
+</div>
+
 
 The syntax of types allows for type references, including references to generic
 parameters, so any generic argument can pass along the value of a generic type
@@ -398,9 +410,23 @@ As with any other generic entity, it must be specialized at the point of use.
 
 The following are the primitive types of Compact:
 
-<table className="lang-ref-table"><tbody><tr><td><em>type</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>tref</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Boolean</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Field</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Uint</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Opaque</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Vector</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>tsize</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>type</em>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>type</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>type</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr>
-<tr><td><em>tref</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gargs</em></a><sup>opt</sup></td></tr>
-<tr><td><em>tsize</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></tbody></table>
+<div className="lang-ref-table">
+|         |         |                                                                                           |
+|---------|---------|-------------------------------------------------------------------------------------------|
+| *type*  | &xrarr; | [*tref*](#primitive-types)                                                                |
+|         | \|      | `Boolean`                                                                                 |
+|         | \|      | `Field`                                                                                   |
+|         | \|      | `Uint` `<` [*tsize*](#primitive-types) `>`                                                |
+|         | \|      | `Uint` `<` [*tsize*](#primitive-types) `..` [*tsize*](#primitive-types) `>`               |
+|         | \|      | `Bytes` `<` [*tsize*](#primitive-types) `>`                                               |
+|         | \|      | `Opaque` `<` [*str*](#terminal-names) `>`                                                 |
+|         | \|      | `Vector` `<` [*tsize*](#primitive-types) `,` [*type*](#primitive-types) `>`               |
+|         | \|      | `[` [*type*](#primitive-types) `,` ⋯ `,` [*type*](#primitive-types) `,`<sup>opt</sup> `]` |
+| *tref*  | &xrarr; | [*id*](#terminal-names) [*gargs*](#generic-parameters-and-arguments)<sup>opt</sup>        |
+| *tsize* | &xrarr; | [*nat*](#terminal-names)                                                                  |
+|         | \|      | [*id*](#terminal-names)                                                                   |
+</div>
+
 
 - `Boolean` is the type of *Boolean* values.  There are only two values of
   `Boolean` type.  They are the values of the expressions `true` and `false`.
@@ -477,8 +503,14 @@ They can also define structural and nominal aliases for existing types.
 
 Structure types are defined via `struct` declarations with the following form:
 
-<table className="lang-ref-table"><tbody><tr><td><em>struct-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>;</tt></b> ⋯ <b><tt>;</tt></b> <em>typed-identifier</em> <b><tt>;</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>struct</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>struct-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>typed-identifier</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr>
-<tr><td><em>typed-identifier</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                      |         |                                                                                                                                                                                                                                                   |
+|----------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *struct-declaration* | &xrarr; | `export`<sup>opt</sup> `struct` [*struct-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> `{` [*typed-id*](#structure-types) `;` ⋯ `;` [*typed-id*](#structure-types) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                      | \|      | `export`<sup>opt</sup> `struct` [*struct-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> `{` [*typed-id*](#structure-types) `,` ⋯ `,` [*typed-id*](#structure-types) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+| *typed-id*           | &xrarr; | [*id*](#terminal-names) `:` [*type*](#primitive-types)                                                                                                                                                                                            |
+</div>
+
 
 A structure declaration has a sequence of named fields which must be separated
 either by commas or by semicolons.  Comma and semicolon separators cannot be
@@ -586,7 +618,12 @@ and accessed via
 
 Enumeration types are defined via `enum` declarations with the following form:
 
-<table className="lang-ref-table"><tbody><tr><td><em>enum-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>enum</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>enum-name</em></a>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> ⋯¹ <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                    |         |                                                                                                                                                                     |
+|--------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *enum-declaration* | &xrarr; | `export`<sup>opt</sup> `enum` [*enum-name*](#terminal-names) `{` [*id*](#terminal-names) `,` ⋯¹ `,` [*id*](#terminal-names) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+</div>
+
 
 An enumeration declaration has a non-empty sequence of named elements separated by commas.
 A trailing comma is allowed but not required.
@@ -614,7 +651,12 @@ contracts is reserved for this use.
 
 Type aliases can be created via `type` declarations of the form:
 
-<table className="lang-ref-table"><tbody><tr><td><em>type-alias-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>new</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>type</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>type-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                          |         |                                                                                                                                                                                  |
+|--------------------------|---------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *type-alias-declaration* | &xrarr; | `export`<sup>opt</sup> `new`<sup>opt</sup> `type` [*type-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> `=` [*type*](#primitive-types) `;` |
+</div>
+
 
 Within the scope of a type-alias declaration of *type-name* for *type*, *type-name*
 is itself a type.
@@ -729,8 +771,16 @@ tuple is expected.
 The parameters of a circuit or constructor and the target of a `const` binding
 are specified via patterns:
 
-<table className="lang-ref-table"><tbody><tr><td><em>pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
-<tr><td><em>pattern-struct-elt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>pattern</em></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                      |         |                                                                                                                                                   |
+|----------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------|
+| *pattern*            | &xrarr; | [*id*](#terminal-names)                                                                                                                           |
+|                      | \|      | `[` [*pattern*](#patterns-and-destructuring)<sup>opt</sup> `,` ⋯ `,` [*pattern*](#patterns-and-destructuring)<sup>opt</sup> `,`<sup>opt</sup> `]` |
+|                      | \|      | `{` [*pattern-struct-elt*](#patterns-and-destructuring) `,` ⋯ `,` [*pattern-struct-elt*](#patterns-and-destructuring) `,`<sup>opt</sup> `}`       |
+| *pattern-struct-elt* | &xrarr; | [*id*](#terminal-names)                                                                                                                           |
+|                      | \|      | [*id*](#terminal-names) `:` [*pattern*](#patterns-and-destructuring)                                                                              |
+</div>
+
 
 In its simplest form, a pattern is just an identifier.
 For example, in the code below, the parameter of `sumTuple` is the identifier
@@ -871,22 +921,25 @@ circuit sumSomeYs([{y: b1,}, , {y: b3,},]: [S, S, S]): Field {
 
 A compact program is a sequence of zero or more program elements.
 
-<table className="lang-ref-table"><tbody>
-<tr><td><em>program</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pelt</em> ⋯ <em>pelt</em></td></tr>
-<tr><td><em>pelt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#pragmas"><em>pragma-form</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#modules-exports-and-imports"><em>module-definition</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#exports"><em>export-form</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#imports"><em>import-form</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#include-files"><em>include-form</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#structure-types"><em>struct-declaration</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#enumeration-types"><em>enum-declaration</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#contract-types"><em>contract-declaration</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#type-aliases"><em>type-alias-declaration</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#declaring-witnesses-for-private-state-management"><em>witness-declaration</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#declaring-and-maintaining-public-state"><em>ledger-declaration</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#contract-constructor"><em>constructor-definition</em></a></td></tr>
-<tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#circuits"><em>circuit-definition</em></a></td></tr>
-</tbody></table>
+<div className="lang-ref-table">
+|           |         |                                                                            |
+|-----------|---------|----------------------------------------------------------------------------|
+| *program* | &xrarr; | [*pelt*](#programs) ⋯ [*pelt*](#programs) [*eof*](#dummy)                  |
+| *pelt*    | &xrarr; | [*pragma-form*](#pragmas)                                                  |
+|           | \|      | [*module-definition*](#modules-exports-and-imports)                        |
+|           | \|      | [*import-form*](#imports)                                                  |
+|           | \|      | [*export-form*](#exports)                                                  |
+|           | \|      | [*include-form*](#include-files)                                           |
+|           | \|      | [*struct-declaration*](#structure-types)                                   |
+|           | \|      | [*enum-declaration*](#enumeration-types)                                   |
+|           | \|      | [*contract-declaration*](#dummy)                                           |
+|           | \|      | [*type-alias-declaration*](#type-aliases)                                  |
+|           | \|      | [*ledger-declaration*](#declaring-and-maintaining-public-state)            |
+|           | \|      | [*witness-declaration*](#declaring-witnesses-for-private-state-management) |
+|           | \|      | [*constructor-definition*](#contract-constructor)                          |
+|           | \|      | [*circuit-definition*](#circuit-definitions)                               |
+</div>
+
 
 Briefly:
 
@@ -920,11 +973,25 @@ section.
 A pragma takes the following form and declares a constraint on either the compiler
 version (*id* = `compiler_version`) or the language version (*id* = `language_version`)
 
-<table className="lang-ref-table"><tbody><tr><td><em>pragma-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>pragma</tt></b>&nbsp;&nbsp;<a href="#to-be-filled-in"><em>id</em></a>&nbsp;&nbsp;<em>version-expr</em>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr>
-<tr><td><em>version-expr</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>version-expr</em>&nbsp;&nbsp;<b><tt>||</tt></b>&nbsp;&nbsp;<em>version-expr<sub>0</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>version-expr<sub>0</sub></em></td></tr>
-<tr><td><em>version-expr<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>version-expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>&&</tt></b>&nbsp;&nbsp;<em>version-term</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>version-term</em></td></tr>
-<tr><td><em>version-term</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\<=</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>>=</tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<em>version-atom</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>version-expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
-<tr><td><em>version-atom</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#constants"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#constants"><em>version</em></a></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                            |         |                                                                          |
+|----------------------------|---------|--------------------------------------------------------------------------|
+| *pragma-form*              | &xrarr; | `pragma` [*id*](#terminal-names) [*version-expr*](#pragmas) `;`          |
+| *version-expr*             | &xrarr; | [*version-expr*](#pragmas) `\|\|` [*version-expr<sub>0</sub>*](#pragmas) |
+|                            | \|      | [*version-expr<sub>0</sub>*](#pragmas)                                   |
+| *version-expr<sub>0</sub>* | &xrarr; | [*version-expr<sub>0</sub>*](#pragmas) `&&` [*version-term*](#pragmas)   |
+|                            | \|      | [*version-term*](#pragmas)                                               |
+| *version-term*             | &xrarr; | [*version-atom*](#pragmas)                                               |
+|                            | \|      | `!` [*version-atom*](#pragmas)                                           |
+|                            | \|      | `<` [*version-atom*](#pragmas)                                           |
+|                            | \|      | `<=` [*version-atom*](#pragmas)                                          |
+|                            | \|      | `>=` [*version-atom*](#pragmas)                                          |
+|                            | \|      | `>` [*version-atom*](#pragmas)                                           |
+|                            | \|      | `(` [*version-expr*](#pragmas) `)`                                       |
+| *version-atom*             | &xrarr; | [*nat*](#terminal-names)                                                 |
+|                            | \|      | [*version*](#terminal-names)                                             |
+</div>
+
 
 *version* is a dot-separated pair or trio of natural numbers, so along
 with *nat* this allows *version* to be either a single natural number,
@@ -948,7 +1015,12 @@ programs into multiple files.
 A module is a named collection of program elements created via a module definition,
 which takes the following form:
 
-<table className="lang-ref-table"><tbody><tr><td><em>module-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>module</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>module-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#programs"><em>pelt</em></a> ⋯ <a href="#programs"><em>pelt</em></a>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                     |         |                                                                                                                                                                                 |
+|---------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> `{` [*pelt*](#programs) ⋯ [*pelt*](#programs) `}` |
+</div>
+
 
 A module definition makes a binding from `module-name` to the module visible in
 the program or module containing the module definition.
@@ -968,7 +1040,12 @@ Any identifier defined at or imported into the top level of a module can be expo
 from the module in one of two ways: (1) by prefixing the definition with the
 `export` keyword, or by listing the identifier in a separate `export` declaration:
 
-<table className="lang-ref-table"><tbody><tr><td><em>export-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <a href="#identifier"><em>id</em></a> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b><sup>opt</sup></td></tr></tbody></table>
+<div className="lang-ref-table">
+|               |         |                                                                                                                |
+|---------------|---------|----------------------------------------------------------------------------------------------------------------|
+| *export-form* | &xrarr; | `export` `{` [*id*](#terminal-names) `,` ⋯ `,` [*id*](#terminal-names) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+</div>
+
 
 For example, the following module exports `G` and `S` but not `F`.
 
@@ -992,11 +1069,18 @@ Exporting a binding from a module has no effect unless the module is imported.
 A module can be imported into another module or into the program top level, making
 some or all of its exported bindings visible there, potentially with a prefix.
 
-<table className="lang-ref-table"><tbody><tr><td><em>import-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>import</tt></b>&nbsp;&nbsp;<em>import-selection</em><sup>opt</sup>&nbsp;&nbsp;<em>import-name</em>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gargs</em></a><sup>opt</sup>&nbsp;&nbsp;<em>import-prefix</em><sup>opt</sup>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr>
-<tr><td><em>import-selection</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>import-element</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>import-element</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b>&nbsp;&nbsp;<b><tt>from</tt></b></td></tr>
-<tr><td><em>import-element</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr>
-<tr><td><em>import-name</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#string-literal"><em>file</em></a></td></tr>
-<tr><td><em>import-prefix</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>prefix</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                    |         |                                                                                                                                                                                          |
+|--------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *import-form*      | &xrarr; | `import` [*import-selection*](#imports)<sup>opt</sup> [*import-name*](#imports) [*gargs*](#generic-parameters-and-arguments)<sup>opt</sup> [*import-prefix*](#imports)<sup>opt</sup> `;` |
+| *import-selection* | &xrarr; | `{` [*import-element*](#imports) `,` ⋯ `,` [*import-element*](#imports) `,`<sup>opt</sup> `}` `from`                                                                                     |
+| *import-element*   | &xrarr; | [*id*](#terminal-names)                                                                                                                                                                  |
+|                    | \|      | [*id*](#terminal-names) `as` [*id*](#terminal-names)                                                                                                                                     |
+| *import-name*      | &xrarr; | [*id*](#terminal-names)                                                                                                                                                                  |
+|                    | \|      | [*file*](#terminal-names)                                                                                                                                                                |
+| *import-prefix*    | &xrarr; | `prefix` [*id*](#terminal-names)                                                                                                                                                         |
+</div>
+
 
 For example:
 
@@ -1184,7 +1268,12 @@ Compact allows programs and modules to be split into multiple files and spliced
 togther via `include` forms, which have the following syntax, where `file` is a
 string literal specifying a filesystem pathname for file to be included:
 
-<table className="lang-ref-table"><tbody><tr><td><em>include-form</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>include</tt></b>&nbsp;&nbsp;<a href="#constants"><em>file</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                |         |                                         |
+|----------------|---------|-----------------------------------------|
+| *include-form* | &xrarr; | `include` [*file*](#terminal-names) `;` |
+</div>
+
 
 `file` can be an absolute pathname, one that is relative to the directory
 of the including file, or one that is relative to one of the directories in the
@@ -1216,11 +1305,14 @@ Witnesses must be declared to make them visible to the circuits of a contract.
 A witness declaration does not include a body, because the implementation is
 provided by the TypeScript driver.
 
-<table className="lang-ref-table"><tbody>
-<tr><td><em>witness-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>witness</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<em>simple-parameter-list</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr>
-<tr><td><em>simple-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-identifier</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>typed-identifier</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
-<tr><td><em>typed-identifier</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr>
-</tbody></table>
+<div className="lang-ref-table">
+|                         |         |                                                                                                                                                                                                                                       |
+|-------------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *witness-declaration*   | &xrarr; | `export`<sup>opt</sup> `witness` [*id*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> [*simple-parameter-list*](#declaring-witnesses-for-private-state-management) `:` [*type*](#primitive-types) `;` |
+| *simple-parameter-list* | &xrarr; | `(` [*typed-id*](#structure-types) `,` ⋯ `,` [*typed-id*](#structure-types) `,`<sup>opt</sup> `)`                                                                                                                                     |
+| *typed-id*              | &xrarr; | [*id*](#terminal-names) `:` [*type*](#primitive-types)                                                                                                                                                                                |
+</div>
+
 
 Witness declarations can appear anywhere among the program elements of
 a module or the contract's top level.
@@ -1253,7 +1345,12 @@ Multiple ledger declarations can appear in a program, or none.
 They can appear anywhere among the program elements of a module or the contract's
 top level.
 
-<table className="lang-ref-table"><tbody><tr><td><em>ledger-declaration</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>sealed</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>ledger</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                      |         |                                                                                                                   |
+|----------------------|---------|-------------------------------------------------------------------------------------------------------------------|
+| *ledger-declaration* | &xrarr; | `export`<sup>opt</sup> `sealed`<sup>opt</sup> `ledger` [*id*](#terminal-names) `:` [*type*](#primitive-types) `;` |
+</div>
+
 
 A ledger declaration binds a ledger field name to one of a
 set of predefined [ledger-state types](#ledger-state-types).
@@ -1470,8 +1567,14 @@ reachable from an exported circuit.
 A contract can be initialized via a contract constructor defined at the
 program's top level.
 
-<table className="lang-ref-table"><tbody><tr><td><em>constructor-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>constructor</tt></b>&nbsp;&nbsp;<em>pattern-parameter-list</em>&nbsp;&nbsp;<a href="#statements"><em>block</em></a></td></tr><tr><td><em>pattern-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-pattern</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
-<tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                          |         |                                                                                                                       |
+|--------------------------|---------|-----------------------------------------------------------------------------------------------------------------------|
+| *constructor-definition* | &xrarr; | `constructor` [*pattern-parameter-list*](#contract-constructor) [*block*](#blocks)                                    |
+| *pattern-parameter-list* | &xrarr; | `(` [*typed-pattern*](#contract-constructor) `,` ⋯ `,` [*typed-pattern*](#contract-constructor) `,`<sup>opt</sup> `)` |
+| *typed-pattern*          | &xrarr; | [*pattern*](#patterns-and-destructuring) `:` [*type*](#primitive-types)                                               |
+</div>
+
 
 The constructor, if any, is typically used to initialize public state
 and can also be used to initialize private state through witness
@@ -1524,9 +1627,14 @@ in [Circuit and witness calls](#circuit-and-witness-calls).
 
 Named circuit definitions have the following syntax:
 
-<table className="lang-ref-table"><tbody><tr><td><em>circuit-definition</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>export</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>pure</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>circuit</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>function-name</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gparams</em></a><sup>opt</sup>&nbsp;&nbsp;<em>pattern-parameter-list</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<a href="#statements"><em>block</em></a></td></tr>
-<tr><td><em>pattern-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>typed-pattern</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
-<tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                          |         |                                                                                                                                                                                                                                                           |
+|--------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *circuit-definition*     | &xrarr; | `export`<sup>opt</sup> `pure`<sup>opt</sup> `circuit` [*function-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> [*pattern-parameter-list*](#contract-constructor) `:` [*type*](#primitive-types) [*block*](#blocks) |
+| *pattern-parameter-list* | &xrarr; | `(` [*typed-pattern*](#contract-constructor) `,` ⋯ `,` [*typed-pattern*](#contract-constructor) `,`<sup>opt</sup> `)`                                                                                                                                     |
+| *typed-pattern*          | &xrarr; | [*pattern*](#patterns-and-destructuring) `:` [*type*](#primitive-types)                                                                                                                                                                                   |
+</div>
+
 
 A circuit definition binds `function-name` to a circuit with the given parameters,
 type, and body.
@@ -1602,7 +1710,12 @@ Compact program by the Compact compiler.
 
 A `block` is a group of statements enclosed in braces:
 
-<table className="lang-ref-table"><tbody><tr><td><em>block</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>stmt</em> ⋯ <em>stmt</em>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr></tbody></table>
+<div className="lang-ref-table">
+|         |         |                                                       |
+|---------|---------|-------------------------------------------------------|
+| *block* | &xrarr; | `{` [*stmt*](#statements) ⋯ [*stmt*](#statements) `}` |
+</div>
+
 
 A block can be used in place of a single statement anywhere a single statement
 is allowed, which is useful for allowing multiple statements to be evaluated by the
@@ -1625,8 +1738,21 @@ A block is evaluated by evaluating the statements in sequence.
 
 The syntax of Compact statements is summarized by the following grammar snippet:
 
-<table className="lang-ref-table"><tbody><tr><td><em>stmt</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>stmt<sub>0</sub></em></td></tr>
-<tr><td><em>stmt<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#const-binding-statement"><em>cbinding</em></a> <b><tt>,</tt></b> ⋯¹ <b><tt>,</tt></b> <a href="#const-binding-statement"><em>cbinding</em></a> &nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>if</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt<sub>0</sub></em>&nbsp;&nbsp;<b><tt>else</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>..</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>for</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<b><tt>const</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>of</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>)</tt></b>&nbsp;&nbsp;<em>stmt</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<a href="#expression-sequence"><em>expr-seq</em></a>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>return</tt></b>&nbsp;&nbsp;<b><tt>;</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>block</em></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                    |         |                                                                                                                                 |
+|--------------------|---------|---------------------------------------------------------------------------------------------------------------------------------|
+| *stmt*             | &xrarr; | `if` `(` [*expr-seq*](#expressions) `)` [*stmt*](#statements)                                                                   |
+|                    | \|      | [*stmt<sub>0</sub>*](#statements)                                                                                               |
+| *stmt<sub>0</sub>* | &xrarr; | [*expr-seq*](#expressions) `;`                                                                                                  |
+|                    | \|      | `const` [*cbinding*](#const-statements) `,` ⋯¹ `,` [*cbinding*](#const-statements)  `;`                                         |
+|                    | \|      | `if` `(` [*expr-seq*](#expressions) `)` [*stmt<sub>0</sub>*](#statements) `else` [*stmt*](#statements)                          |
+|                    | \|      | `for` `(` `const` [*id*](#terminal-names) `of` [*nat*](#terminal-names) `..` [*nat*](#terminal-names) `)` [*stmt*](#statements) |
+|                    | \|      | `for` `(` `const` [*id*](#terminal-names) `of` [*expr-seq*](#expressions) `)` [*stmt*](#statements)                             |
+|                    | \|      | `return` [*expr-seq*](#expressions) `;`                                                                                         |
+|                    | \|      | `return` `;`                                                                                                                    |
+|                    | \|      | [*block*](#blocks)                                                                                                              |
+</div>
+
 
 The snippet shows that a statement (`stmt`) is either a one-armed `if` expression
 or some other kinf of statement (`stmt0`).
@@ -1666,13 +1792,16 @@ const cbindings
 where `cbindings` is a comma-separated sequence of one or more `cbinding` subforms
 in the syntax specified by the following grammar snippet:
 
-<table className="lang-ref-table"><tbody>
-<tr><td><em>cbinding</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>optionally-typed-pattern</em>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<a href="#expressions"><em>expr</em></a></td></tr>
-<tr><td><em>optionally-typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>typed-pattern</em></td></tr>
-<tr><td><a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
-<tr><td><a href="#patterns-and-destructuring"><em>pattern-struct-elt</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>pattern</em></td></tr>
-<tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr>
-</tbody></table>
+<div className="lang-ref-table">
+|                            |         |                                                                            |
+|----------------------------|---------|----------------------------------------------------------------------------|
+| *cbinding*                 | &xrarr; | [*optionally-typed-pattern*](#const-statements) `=` [*expr*](#expressions) |
+| *optionally-typed-pattern* | &xrarr; | [*pattern*](#patterns-and-destructuring)                                   |
+|                            | \|      | [*typed-pattern*](#contract-constructor)                                   |
+| *pattern-struct-elt*       | &xrarr; | [*id*](#terminal-names)                                                    |
+|                            | \|      | [*id*](#terminal-names) `:` [*pattern*](#patterns-and-destructuring)       |
+</div>
+
 
 A `const` statement is typed by typing each of its `cbinding` subforms.
 A `cbinding` subform is typed by typing the expression on the right-hand side
@@ -1873,21 +2002,67 @@ subsequent statements, and it returns to the caller the value of `expr-seq` or
 
 The syntax of Compact expressions is summarized by the following grammar snippet:
 
-<table className="lang-ref-table"><tbody><tr><td><em>expr-seq</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> ⋯¹ <b><tt>,</tt></b> <em>expr</em> &nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr>
-<tr><td><em>expr</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>?</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>+=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>-=</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em></td></tr>
-<tr><td><em>expr<sub>0</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>0</sub></em>&nbsp;&nbsp;<b><tt>||</tt></b>&nbsp;&nbsp;<em>expr<sub>1</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>1</sub></em></td></tr>
-<tr><td><em>expr<sub>1</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>1</sub></em>&nbsp;&nbsp;<b><tt>&&</tt></b>&nbsp;&nbsp;<em>expr<sub>2</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>2</sub></em></td></tr>
-<tr><td><em>expr<sub>2</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>2</sub></em>&nbsp;&nbsp;<b><tt>==</tt></b>&nbsp;&nbsp;<em>expr<sub>3</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>2</sub></em>&nbsp;&nbsp;<b><tt>!=</tt></b>&nbsp;&nbsp;<em>expr<sub>3</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>3</sub></em></td></tr>
-<tr><td><em>expr<sub>3</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<em>expr<sub>4</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em>&nbsp;&nbsp;<b><tt>\<=</tt></b>&nbsp;&nbsp;<em>expr<sub>4</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em>&nbsp;&nbsp;<b><tt>>=</tt></b>&nbsp;&nbsp;<em>expr<sub>4</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<em>expr<sub>4</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em></td></tr>
-<tr><td><em>expr<sub>4</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>4</sub></em>&nbsp;&nbsp;<b><tt>as</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>5</sub></em></td></tr>
-<tr><td><em>expr<sub>5</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>5</sub></em>&nbsp;&nbsp;<b><tt>+</tt></b>&nbsp;&nbsp;<em>expr<sub>6</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>5</sub></em>&nbsp;&nbsp;<b><tt>-</tt></b>&nbsp;&nbsp;<em>expr<sub>6</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>6</sub></em></td></tr>
-<tr><td><em>expr<sub>6</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>6</sub></em>&nbsp;&nbsp;<b><tt>*</tt></b>&nbsp;&nbsp;<em>expr<sub>7</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>7</sub></em></td></tr>
-<tr><td><em>expr<sub>7</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>!</tt></b>&nbsp;&nbsp;<em>expr<sub>7</sub></em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em></td></tr>
-<tr><td><em>expr<sub>8</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>8</sub></em>&nbsp;&nbsp;<b><tt>.</tt></b>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>expr<sub>9</sub></em></td></tr>
-<tr><td><em>expr<sub>9</sub></em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>map</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> ⋯¹ <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>fold</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#circuit-and-witness-calls"><em>fun</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em> <b><tt>,</tt></b> ⋯¹ <b><tt>,</tt></b> <em>expr</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>slice</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>tsize</em></a>&nbsp;&nbsp;<b><tt>></tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>tuple-arg</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>tuple-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>Bytes</tt></b>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>bytes-arg</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>bytes-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#primitive-types"><em>tref</em></a>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>struct-arg</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>struct-arg</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>assert</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>disclose</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>term</em></td></tr>
-<tr><td><em>tuple-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td><em>bytes-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>tuple-arg</em></td></tr>
-<tr><td><em>struct-arg</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>...</tt></b>&nbsp;&nbsp;<em>expr</em></td></tr>
-<tr><td><em>term</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>true</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>false</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>pad</tt></b>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<a href="#field-literal"><em>nat</em></a>&nbsp;&nbsp;<b><tt>,</tt></b>&nbsp;&nbsp;<a href="#string-literal"><em>str</em></a>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>default</tt></b>&nbsp;&nbsp;<b><tt>\<</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a>&nbsp;&nbsp;<b><tt>></tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>expr-seq</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                    |         |                                                                                                                                                              |
+|--------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *expr-seq*         | &xrarr; | [*expr*](#expressions)                                                                                                                                       |
+|                    | \|      | [*expr*](#expressions) `,` ⋯¹ `,` [*expr*](#expressions)  `,` [*expr*](#expressions)                                                                         |
+| *expr*             | &xrarr; | [*expr<sub>0</sub>*](#expressions) `?` [*expr*](#expressions) `:` [*expr*](#expressions)                                                                     |
+|                    | \|      | [*expr<sub>0</sub>*](#expressions) `=` [*expr*](#expressions)                                                                                                |
+|                    | \|      | [*expr<sub>0</sub>*](#expressions) `+=` [*expr*](#expressions)                                                                                               |
+|                    | \|      | [*expr<sub>0</sub>*](#expressions) `-=` [*expr*](#expressions)                                                                                               |
+|                    | \|      | [*expr<sub>0</sub>*](#expressions)                                                                                                                           |
+| *expr<sub>0</sub>* | &xrarr; | [*expr<sub>0</sub>*](#expressions) `\|\|` [*expr<sub>1</sub>*](#expressions)                                                                                 |
+|                    | \|      | [*expr<sub>1</sub>*](#expressions)                                                                                                                           |
+| *expr<sub>1</sub>* | &xrarr; | [*expr<sub>1</sub>*](#expressions) `&&` [*expr<sub>2</sub>*](#expressions)                                                                                   |
+|                    | \|      | [*expr<sub>2</sub>*](#expressions)                                                                                                                           |
+| *expr<sub>2</sub>* | &xrarr; | [*expr<sub>2</sub>*](#expressions) `==` [*expr<sub>3</sub>*](#expressions)                                                                                   |
+|                    | \|      | [*expr<sub>2</sub>*](#expressions) `!=` [*expr<sub>3</sub>*](#expressions)                                                                                   |
+|                    | \|      | [*expr<sub>3</sub>*](#expressions)                                                                                                                           |
+| *expr<sub>3</sub>* | &xrarr; | [*expr<sub>4</sub>*](#expressions) `<` [*expr<sub>4</sub>*](#expressions)                                                                                    |
+|                    | \|      | [*expr<sub>4</sub>*](#expressions) `<=` [*expr<sub>4</sub>*](#expressions)                                                                                   |
+|                    | \|      | [*expr<sub>4</sub>*](#expressions) `>=` [*expr<sub>4</sub>*](#expressions)                                                                                   |
+|                    | \|      | [*expr<sub>4</sub>*](#expressions) `>` [*expr<sub>4</sub>*](#expressions)                                                                                    |
+|                    | \|      | [*expr<sub>4</sub>*](#expressions)                                                                                                                           |
+| *expr<sub>4</sub>* | &xrarr; | [*expr<sub>4</sub>*](#expressions) `as` [*type*](#primitive-types)                                                                                           |
+|                    | \|      | [*expr<sub>5</sub>*](#expressions)                                                                                                                           |
+| *expr<sub>5</sub>* | &xrarr; | [*expr<sub>5</sub>*](#expressions) `+` [*expr<sub>6</sub>*](#expressions)                                                                                    |
+|                    | \|      | [*expr<sub>5</sub>*](#expressions) `-` [*expr<sub>6</sub>*](#expressions)                                                                                    |
+|                    | \|      | [*expr<sub>6</sub>*](#expressions)                                                                                                                           |
+| *expr<sub>6</sub>* | &xrarr; | [*expr<sub>6</sub>*](#expressions) `*` [*expr<sub>7</sub>*](#expressions)                                                                                    |
+|                    | \|      | [*expr<sub>7</sub>*](#expressions)                                                                                                                           |
+| *expr<sub>7</sub>* | &xrarr; | `!` [*expr<sub>7</sub>*](#expressions)                                                                                                                       |
+|                    | \|      | [*expr<sub>8</sub>*](#expressions)                                                                                                                           |
+| *expr<sub>8</sub>* | &xrarr; | [*expr<sub>8</sub>*](#expressions) `[` [*expr*](#expressions) `]`                                                                                            |
+|                    | \|      | [*expr<sub>8</sub>*](#expressions) `.` [*id*](#terminal-names)                                                                                               |
+|                    | \|      | [*expr<sub>8</sub>*](#expressions) `.` [*id*](#terminal-names) `(` [*expr*](#expressions) `,` ⋯ `,` [*expr*](#expressions) `,`<sup>opt</sup> `)`             |
+|                    | \|      | [*expr<sub>9</sub>*](#expressions)                                                                                                                           |
+| *expr<sub>9</sub>* | &xrarr; | [*fun*](#circuit-and-witness-calls) `(` [*expr*](#expressions) `,` ⋯ `,` [*expr*](#expressions) `,`<sup>opt</sup> `)`                                        |
+|                    | \|      | `map` `(` [*fun*](#circuit-and-witness-calls) `,` [*expr*](#expressions) `,` ⋯¹ `,` [*expr*](#expressions) `,`<sup>opt</sup> `)`                             |
+|                    | \|      | `fold` `(` [*fun*](#circuit-and-witness-calls) `,` [*expr*](#expressions) `,` [*expr*](#expressions) `,` ⋯¹ `,` [*expr*](#expressions) `,`<sup>opt</sup> `)` |
+|                    | \|      | `slice` `<` [*tsize*](#primitive-types) `>` `(` [*expr*](#expressions) `,` [*expr*](#expressions) `)`                                                        |
+|                    | \|      | `[` [*tuple-arg*](#expressions) `,` ⋯ `,` [*tuple-arg*](#expressions) `,`<sup>opt</sup> `]`                                                                  |
+|                    | \|      | `Bytes` `[` [*tuple-arg*](#expressions) `,` ⋯ `,` [*tuple-arg*](#expressions) `,`<sup>opt</sup> `]`                                                          |
+|                    | \|      | [*tref*](#primitive-types) `{` [*struct-arg*](#expressions) `,` ⋯ `,` [*struct-arg*](#expressions) `,`<sup>opt</sup> `}`                                     |
+|                    | \|      | `assert` `(` [*expr*](#expressions) `,` [*str*](#terminal-names) `)`                                                                                         |
+|                    | \|      | `disclose` `(` [*expr*](#expressions) `)`                                                                                                                    |
+|                    | \|      | [*term*](#expressions)                                                                                                                                       |
+| *tuple-arg*        | &xrarr; | [*expr*](#expressions)                                                                                                                                       |
+|                    | \|      | `...` [*expr*](#expressions)                                                                                                                                 |
+| *bytes-arg*        | &xrarr; | [*tuple-arg*](#expressions)                                                                                                                                  |
+| *struct-arg*       | &xrarr; | [*expr*](#expressions)                                                                                                                                       |
+|                    | \|      | [*id*](#terminal-names) `:` [*expr*](#expressions)                                                                                                           |
+|                    | \|      | `...` [*expr*](#expressions)                                                                                                                                 |
+| *term*             | &xrarr; | [*id*](#terminal-names)                                                                                                                                      |
+|                    | \|      | `true`                                                                                                                                                       |
+|                    | \|      | `false`                                                                                                                                                      |
+|                    | \|      | [*nat*](#terminal-names)                                                                                                                                     |
+|                    | \|      | [*str*](#terminal-names)                                                                                                                                     |
+|                    | \|      | `pad` `(` [*nat*](#terminal-names) `,` [*str*](#terminal-names) `)`                                                                                          |
+|                    | \|      | `default` `<` [*type*](#primitive-types) `>`                                                                                                                 |
+|                    | \|      | `(` [*expr-seq*](#expressions) `)`                                                                                                                           |
+</div>
+
 
 Every Compact expression must be well-typed (free from static type errors).
 If any expression within a program contains a static type error, it is a static
@@ -2571,13 +2746,24 @@ type of `e` is an enumeration type.
 
 ### Circuit and witness calls
 
-<table className="lang-ref-table"><tbody><tr><td><em>fun</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<a href="#generic-parameters-and-arguments"><em>gargs</em></a><sup>opt</sup></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>arrow-parameter-list</em>&nbsp;&nbsp;<em>return-type</em><sup>opt</sup>&nbsp;&nbsp;<b><tt>=></tt></b>&nbsp;&nbsp;<a href="#statements"><em>block</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>arrow-parameter-list</em>&nbsp;&nbsp;<em>return-type</em><sup>opt</sup>&nbsp;&nbsp;<b><tt>=></tt></b>&nbsp;&nbsp;<a href="#expressions"><em>expr</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>fun</em>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
-<tr><td><em>arrow-parameter-list</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>(</tt></b>&nbsp;&nbsp;<em>optionally-typed-pattern</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>optionally-typed-pattern</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>)</tt></b></td></tr>
-<tr><td><em>optionally-typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<em>typed-pattern</em></td></tr>
-<tr><td><a href="#patterns-and-destructuring"><em>pattern</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>[</tt></b>&nbsp;&nbsp;<em>pattern</em><sup>opt</sup> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern</em><sup>opt</sup> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>]</tt></b></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<b><tt>\{</tt></b>&nbsp;&nbsp;<em>pattern-struct-elt</em> <b><tt>,</tt></b> ⋯ <b><tt>,</tt></b> <em>pattern-struct-elt</em> <b><tt>,</tt></b><sup>opt</sup>&nbsp;&nbsp;<b><tt>}</tt></b></td></tr>
-<tr><td><a href="#patterns-and-destructuring"><em>pattern-struct-elt</em></a>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a></td></tr><tr><td>&nbsp;</td><td>|</td><td>&nbsp;&nbsp;<a href="#identifier"><em>id</em></a>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<em>pattern</em></td></tr>
-<tr><td><em>typed-pattern</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<em>pattern</em>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr>
-<tr><td><em>return-type</em>&nbsp;</td><td>&rarr;</td><td>&nbsp;&nbsp;<b><tt>:</tt></b>&nbsp;&nbsp;<a href="#primitive-types"><em>type</em></a></td></tr></tbody></table>
+<div className="lang-ref-table">
+|                            |         |                                                                                                                                                   |
+|----------------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------|
+| *fun*                      | &xrarr; | [*id*](#terminal-names) [*gargs*](#generic-parameters-and-arguments)<sup>opt</sup>                                                                |
+|                            | \|      | [*arrow-parameter-list*](#circuit-and-witness-calls) [*return-type*](#circuit-and-witness-calls)<sup>opt</sup> `=>` [*block*](#blocks)            |
+|                            | \|      | [*arrow-parameter-list*](#circuit-and-witness-calls) [*return-type*](#circuit-and-witness-calls)<sup>opt</sup> `=>` [*expr*](#expressions)        |
+|                            | \|      | `(` [*fun*](#circuit-and-witness-calls) `)`                                                                                                       |
+| *arrow-parameter-list*     | &xrarr; | `(` [*optionally-typed-pattern*](#const-statements) `,` ⋯ `,` [*optionally-typed-pattern*](#const-statements) `,`<sup>opt</sup> `)`               |
+| *optionally-typed-pattern* | &xrarr; | [*pattern*](#patterns-and-destructuring)                                                                                                          |
+|                            | \|      | [*typed-pattern*](#contract-constructor)                                                                                                          |
+| *pattern*                  | &xrarr; | [*id*](#terminal-names)                                                                                                                           |
+|                            | \|      | `[` [*pattern*](#patterns-and-destructuring)<sup>opt</sup> `,` ⋯ `,` [*pattern*](#patterns-and-destructuring)<sup>opt</sup> `,`<sup>opt</sup> `]` |
+|                            | \|      | `{` [*pattern-struct-elt*](#patterns-and-destructuring) `,` ⋯ `,` [*pattern-struct-elt*](#patterns-and-destructuring) `,`<sup>opt</sup> `}`       |
+| *pattern-struct-elt*       | &xrarr; | [*id*](#terminal-names)                                                                                                                           |
+|                            | \|      | [*id*](#terminal-names) `:` [*pattern*](#patterns-and-destructuring)                                                                              |
+| *return-type*              | &xrarr; | `:` [*type*](#primitive-types)                                                                                                                    |
+</div>
+
 
 Circuits and witnesses, collectively referred to as functions, are called via an
 expression of the form `f(e, ...)`, where `f` is a function and `e, ...` is a
@@ -2756,6 +2942,11 @@ input vectors.
 Values of one type can be cast to another, when allowed, via a *cast*, which
 takes the following form:
 
+```compact
+e as T
+```
+
+where `e` is an expression and `T` is a type.
 The effects of casting an expression `e` of type `T` to another type `U` depend
 on the specific types involved.
 For some types `T` and `U`, the cast is not allowed, which is a static error.
@@ -2786,6 +2977,21 @@ Any cast not covered by one of the rules is not allowed.
   (but never required), never result in run-time errors, and, except in the case
   where the type and the supertype are the same, might require run-time conversions.
 
+This rule has three implications:
+
+- Tuple-to-vector upcasts: if a tuple type `[T, ...]` has a vector type `Vector<n, S>`
+  (i.e., `S` is the least upper bound of the element types), then the tuple is a subtype
+  of that vector type and can be used where the vector type is expected without an
+  explicit cast. For example, values of type `[Uint<8>, Uint<16>]` can be used where a
+  value of type `Vector<2, Uint<16>>` are required.
+- Vector-to-tuple upcasts: a vector type `Vector<n, T>` is a subtype of any tuple type
+  `[S, ...]` of length `n` where `T` is a subtype of each `S`, so a vector can be used where
+  such a tuple is expected without an explicit cast. For example, values of type
+  `Vector<2, Uint<8>>` can be used where values of type `[Uint<16>, Uint<16>]` are required.
+- Since `Vector<n, T>` is the same type as the tuple `[T, ..., T]` with `n` occurrences of `T`,
+  casts between a vector type and its equivalent tuple type are always upcasts in both
+  directions.
+
 #### Downcasts of `Field` and `Uint` types
 
 - `Uint` downcasts, i.e., casts from `Uint<m>` to `Uint<n>`, `m > n`, are always

From 980a2d380286e544c4321387ddbd000a021d5a7c Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Thu, 12 Mar 2026 22:20:54 +0100
Subject: [PATCH 17/41] latest lang-ref.mdx and compact-grammar.mdx

---
 docs/compact/reference/compact-grammar.mdx | 48 ++++++++++------------
 docs/compact/reference/lang-ref.mdx        | 38 ++++++++---------
 2 files changed, 41 insertions(+), 45 deletions(-)

diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index 088806f3..495cff5e 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -10,10 +10,6 @@ Compact language version 0.22.0.
 
 Notational note: In the grammar below, keywords and punctuation are in `monospaced` font. Terminal and nonterminal names are in *emphasized* font. Alternation is indicated by a vertical bar (`|`). Optional items are indicated by the superscript <sup>opt</sup>. Repetition is specified by ellipses. The notation *X* ⋯ *X*, where *X* is a grammar symbol, represents zero or more occurrences of *X*. The notation *X* `,` ⋯ `,` *X*, where *X* is a grammar symbol and `,` is a literal comma, represents zero or more occurrences of *X* separated by commas. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one *X*. When such a sequence is followed by *,*<sup>opt</sup>, an optional trailing comma is allowed, but only if there is at least one *X*. For example, *id* ⋯ *id* represents zero or more *id*s, and *expr* `,` ⋯¹`,` *expr* `,`<sup>opt</sup> represents one or more comma-separated *expr*s possibly followed by an extra comma. The rules involving commas apply equally to semicolons, i.e., apply when `,` is replaced by `;`.
 
-#### <a name="end-of-file">end-of-file</a> (*eof*)
-
-End of file.
-
 #### <a name="identifier">identifier</a> (*id*, *module-name*, *function-name*, *struct-name*, *enum-name*, *contract-name*, *tvar-name*, *type-name*)
 
 Identifiers have the same syntax as Typescript identifiers.
@@ -33,29 +29,29 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Compact">Compact</a> (*program*)
 
 <div className="lang-ref-table">
-|           |         |                                                                               |
-|-----------|---------|-------------------------------------------------------------------------------|
-| *program* | &xrarr; | [*pelt*](#Program-element) ⋯ [*pelt*](#Program-element) [*eof*](#end-of-file) |
+|           |         |                                                                                |
+|-----------|---------|--------------------------------------------------------------------------------|
+| *program* | &xrarr; | [*program-element*](#Program-element) ⋯ [*program-element*](#Program-element)  |
 </div>
 
-#### <a name="Program-element">Program-element</a> (*pelt*)
+#### <a name="Program-element">Program-element</a> (*program-element*)
 
 <div className="lang-ref-table">
-|        |         |                                                          |
-|--------|---------|----------------------------------------------------------|
-| *pelt* | &xrarr; | [*pragma-form*](#Pragma)                                 |
-|        | \|      | [*module-definition*](#Module-definition)                |
-|        | \|      | [*import-form*](#Import-declaration)                     |
-|        | \|      | [*export-form*](#Export-declaration)                     |
-|        | \|      | [*include-form*](#Include)                               |
-|        | \|      | [*struct-declaration*](#Structure-declaration)           |
-|        | \|      | [*enum-declaration*](#Enum-declaration)                  |
-|        | \|      | [*contract-declaration*](#External-contract-declaration) |
-|        | \|      | [*type-alias-declaration*](#Type-declaration)            |
-|        | \|      | [*ledger-declaration*](#Ledger-declaration)              |
-|        | \|      | [*witness-declaration*](#Witness-declaration)            |
-|        | \|      | [*constructor-definition*](#Constructor)                 |
-|        | \|      | [*circuit-definition*](#Circuit-definition)              |
+|                   |         |                                                          |
+|-------------------|---------|----------------------------------------------------------|
+| *program-element* | &xrarr; | [*pragma-form*](#Pragma)                                 |
+|                   | \|      | [*module-definition*](#Module-definition)                |
+|                   | \|      | [*import-form*](#Import-declaration)                     |
+|                   | \|      | [*export-form*](#Export-declaration)                     |
+|                   | \|      | [*include-form*](#Include)                               |
+|                   | \|      | [*struct-declaration*](#Structure-declaration)           |
+|                   | \|      | [*enum-declaration*](#Enum-declaration)                  |
+|                   | \|      | [*contract-declaration*](#External-contract-declaration) |
+|                   | \|      | [*type-alias-declaration*](#Type-declaration)            |
+|                   | \|      | [*ledger-declaration*](#Ledger-declaration)              |
+|                   | \|      | [*witness-declaration*](#Witness-declaration)            |
+|                   | \|      | [*constructor-definition*](#Constructor)                 |
+|                   | \|      | [*circuit-definition*](#Circuit-definition)              |
 </div>
 
 #### <a name="Pragma">Pragma</a> (*pragma-form*)
@@ -118,9 +114,9 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 #### <a name="Module-definition">Module-definition</a> (*module-definition*)
 
 <div className="lang-ref-table">
-|                     |         |                                                                                                                                                                                 |
-|---------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*pelt*](#Program-element) ⋯ [*pelt*](#Program-element) `}` |
+|                     |         |                                                                                                                                                                                                       |
+|---------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*program-element*](#Program-element) ⋯ [*program-element*](#Program-element) `}` |
 </div>
 
 #### <a name="Generic-parameter-list">Generic-parameter-list</a> (*gparams*)
diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 305cdf21..97ca6d50 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -922,22 +922,22 @@ circuit sumSomeYs([{y: b1,}, , {y: b3,},]: [S, S, S]): Field {
 A compact program is a sequence of zero or more program elements.
 
 <div className="lang-ref-table">
-|           |         |                                                                            |
-|-----------|---------|----------------------------------------------------------------------------|
-| *program* | &xrarr; | [*pelt*](#programs) ⋯ [*pelt*](#programs) [*eof*](#dummy)                  |
-| *pelt*    | &xrarr; | [*pragma-form*](#pragmas)                                                  |
-|           | \|      | [*module-definition*](#modules-exports-and-imports)                        |
-|           | \|      | [*import-form*](#imports)                                                  |
-|           | \|      | [*export-form*](#exports)                                                  |
-|           | \|      | [*include-form*](#include-files)                                           |
-|           | \|      | [*struct-declaration*](#structure-types)                                   |
-|           | \|      | [*enum-declaration*](#enumeration-types)                                   |
-|           | \|      | [*contract-declaration*](#dummy)                                           |
-|           | \|      | [*type-alias-declaration*](#type-aliases)                                  |
-|           | \|      | [*ledger-declaration*](#declaring-and-maintaining-public-state)            |
-|           | \|      | [*witness-declaration*](#declaring-witnesses-for-private-state-management) |
-|           | \|      | [*constructor-definition*](#contract-constructor)                          |
-|           | \|      | [*circuit-definition*](#circuit-definitions)                               |
+|                   |         |                                                                            |
+|-------------------|---------|----------------------------------------------------------------------------|
+| *program*         | &xrarr; | [*program-element*](#programs) ⋯ [*program-element*](#programs)            |
+| *program-element* | &xrarr; | [*pragma-form*](#pragmas)                                                  |
+|                   | \|      | [*module-definition*](#modules-exports-and-imports)                        |
+|                   | \|      | [*import-form*](#imports)                                                  |
+|                   | \|      | [*export-form*](#exports)                                                  |
+|                   | \|      | [*include-form*](#include-files)                                           |
+|                   | \|      | [*struct-declaration*](#structure-types)                                   |
+|                   | \|      | [*enum-declaration*](#enumeration-types)                                   |
+|                   | \|      | [*contract-declaration*](#contract-types)                                  |
+|                   | \|      | [*type-alias-declaration*](#type-aliases)                                  |
+|                   | \|      | [*ledger-declaration*](#declaring-and-maintaining-public-state)            |
+|                   | \|      | [*witness-declaration*](#declaring-witnesses-for-private-state-management) |
+|                   | \|      | [*constructor-definition*](#contract-constructor)                          |
+|                   | \|      | [*circuit-definition*](#circuit-definitions)                               |
 </div>
 
 
@@ -1016,9 +1016,9 @@ A module is a named collection of program elements created via a module definiti
 which takes the following form:
 
 <div className="lang-ref-table">
-|                     |         |                                                                                                                                                                                 |
-|---------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> `{` [*pelt*](#programs) ⋯ [*pelt*](#programs) `}` |
+|                     |         |                                                                                                                                                                                                       |
+|---------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> `{` [*program-element*](#programs) ⋯ [*program-element*](#programs) `}` |
 </div>
 
 

From 55a0fc5d43bbba1c2fb3cc7dc2b26a391109b24e Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Fri, 13 Mar 2026 22:14:34 +0100
Subject: [PATCH 18/41] latest lang-ref.mdx and compact-grammar.mdx

---
 docs/compact/reference/compact-grammar.mdx | 388 +++++++++++----------
 docs/compact/reference/lang-ref.mdx        |  57 ++-
 2 files changed, 219 insertions(+), 226 deletions(-)

diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index 495cff5e..1052c2c7 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -10,91 +10,95 @@ Compact language version 0.22.0.
 
 Notational note: In the grammar below, keywords and punctuation are in `monospaced` font. Terminal and nonterminal names are in *emphasized* font. Alternation is indicated by a vertical bar (`|`). Optional items are indicated by the superscript <sup>opt</sup>. Repetition is specified by ellipses. The notation *X* ⋯ *X*, where *X* is a grammar symbol, represents zero or more occurrences of *X*. The notation *X* `,` ⋯ `,` *X*, where *X* is a grammar symbol and `,` is a literal comma, represents zero or more occurrences of *X* separated by commas. In either case, when the ellipsis is marked with the superscript 1, the notation represents a sequence containing at least one *X*. When such a sequence is followed by *,*<sup>opt</sup>, an optional trailing comma is allowed, but only if there is at least one *X*. For example, *id* ⋯ *id* represents zero or more *id*s, and *expr* `,` ⋯¹`,` *expr* `,`<sup>opt</sup> represents one or more comma-separated *expr*s possibly followed by an extra comma. The rules involving commas apply equally to semicolons, i.e., apply when `,` is replaced by `;`.
 
-#### <a name="identifier">identifier</a> (*id*, *module-name*, *function-name*, *struct-name*, *enum-name*, *contract-name*, *tvar-name*, *type-name*)
+#### identifier
+*id*, *module-name*, *function-name*, *struct-name*, *enum-name*, *contract-name*, *tvar-name*, *type-name*
 
 Identifiers have the same syntax as Typescript identifiers.
 
-#### <a name="field-literal">field-literal</a> (*nat*)
+#### field-literal
+*nat*
 
 A field literal is 0 or a natural number formed from a sequence of digits starting with 1-9, e.g. 723, whose value does not exceed the maximum field value.
 
-#### <a name="string-literal">string-literal</a> (*str*, *file*)
+#### string-literal
+*str*, *file*
 
 A string literal has the same syntax as a Typescript string.
 
-#### <a name="version-literal">version-literal</a> (*version*)
+#### version-literal
+*version*
 
-A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2.3, representing major, minor, and bugfix versions.
+A version literal takes the form nat.nat representing major and minor versions or nat.nat.nat representing major, minor, and bugfix versions. Where version literals are allowed, a plain nat representing just the major version is also allowed.
 
-#### <a name="Compact">Compact</a> (*program*)
+#### Compact
 
 <div className="lang-ref-table">
 |           |         |                                                                                |
 |-----------|---------|--------------------------------------------------------------------------------|
-| *program* | &xrarr; | [*program-element*](#Program-element) ⋯ [*program-element*](#Program-element)  |
+| *program* | &xrarr; | [*program-element*](#program-element) ⋯ [*program-element*](#program-element)  |
 </div>
 
-#### <a name="Program-element">Program-element</a> (*program-element*)
+#### Program-element
 
 <div className="lang-ref-table">
 |                   |         |                                                          |
 |-------------------|---------|----------------------------------------------------------|
-| *program-element* | &xrarr; | [*pragma-form*](#Pragma)                                 |
-|                   | \|      | [*module-definition*](#Module-definition)                |
-|                   | \|      | [*import-form*](#Import-declaration)                     |
-|                   | \|      | [*export-form*](#Export-declaration)                     |
-|                   | \|      | [*include-form*](#Include)                               |
-|                   | \|      | [*struct-declaration*](#Structure-declaration)           |
-|                   | \|      | [*enum-declaration*](#Enum-declaration)                  |
-|                   | \|      | [*contract-declaration*](#External-contract-declaration) |
-|                   | \|      | [*type-alias-declaration*](#Type-declaration)            |
-|                   | \|      | [*ledger-declaration*](#Ledger-declaration)              |
-|                   | \|      | [*witness-declaration*](#Witness-declaration)            |
-|                   | \|      | [*constructor-definition*](#Constructor)                 |
-|                   | \|      | [*circuit-definition*](#Circuit-definition)              |
+| *program-element* | &xrarr; | [*pragma-form*](#pragma)                                 |
+|                   | \|      | [*module-definition*](#module-definition)                |
+|                   | \|      | [*import-form*](#import-declaration)                     |
+|                   | \|      | [*export-form*](#export-declaration)                     |
+|                   | \|      | [*include-form*](#include)                               |
+|                   | \|      | [*struct-declaration*](#structure-declaration)           |
+|                   | \|      | [*enum-declaration*](#enum-declaration)                  |
+|                   | \|      | [*contract-declaration*](#external-contract-declaration) |
+|                   | \|      | [*type-alias-declaration*](#type-declaration)            |
+|                   | \|      | [*ledger-declaration*](#ledger-declaration)              |
+|                   | \|      | [*witness-declaration*](#witness-declaration)            |
+|                   | \|      | [*constructor-definition*](#constructor)                 |
+|                   | \|      | [*circuit-definition*](#circuit-definition)              |
 </div>
 
-#### <a name="Pragma">Pragma</a> (*pragma-form*)
+#### Pragma
 
 <div className="lang-ref-table">
 |               |         |                                                                        |
 |---------------|---------|------------------------------------------------------------------------|
-| *pragma-form* | &xrarr; | `pragma` [*id*](#identifier) [*version-expr*](#Version-expression) `;` |
+| *pragma-form* | &xrarr; | `pragma` [*id*](#identifier) [*version-expr*](#version-expression) `;` |
 </div>
 
-#### <a name="Version-expression">Version-expression</a> (*version-expr*)
+#### Version-expression
 
 <div className="lang-ref-table">
 |                |         |                                                                                                 |
 |----------------|---------|-------------------------------------------------------------------------------------------------|
-| *version-expr* | &xrarr; | [*version-expr*](#Version-expression) `\|\|` [*version-expr<sub>0</sub>*](#Version-expression0) |
-|                | \|      | [*version-expr<sub>0</sub>*](#Version-expression0)                                              |
+| *version-expr* | &xrarr; | [*version-expr*](#version-expression) `\|\|` [*version-expr<sub>0</sub>*](#version-expression0) |
+|                | \|      | [*version-expr<sub>0</sub>*](#version-expression0)                                              |
 </div>
 
-#### <a name="Version-expression0">Version-expression<sub>0</sub></a> (*version-expr<sub>0</sub>*)
+#### Version-expression<sub>0</sub>
 
 <div className="lang-ref-table">
 |                            |         |                                                                                         |
 |----------------------------|---------|-----------------------------------------------------------------------------------------|
-| *version-expr<sub>0</sub>* | &xrarr; | [*version-expr<sub>0</sub>*](#Version-expression0) `&&` [*version-term*](#Version-Term) |
-|                            | \|      | [*version-term*](#Version-Term)                                                         |
+| *version-expr<sub>0</sub>* | &xrarr; | [*version-expr<sub>0</sub>*](#version-expression0) `&&` [*version-term*](#version-term) |
+|                            | \|      | [*version-term*](#version-term)                                                         |
 </div>
 
-#### <a name="Version-Term">Version-Term</a> (*version-term*)
+#### Version-Term
 
 <div className="lang-ref-table">
 |                |         |                                               |
 |----------------|---------|-----------------------------------------------|
-| *version-term* | &xrarr; | [*version-atom*](#Version-atom)               |
-|                | \|      | `!` [*version-atom*](#Version-atom)           |
-|                | \|      | `<` [*version-atom*](#Version-atom)           |
-|                | \|      | `<=` [*version-atom*](#Version-atom)          |
-|                | \|      | `>=` [*version-atom*](#Version-atom)          |
-|                | \|      | `>` [*version-atom*](#Version-atom)           |
-|                | \|      | `(` [*version-expr*](#Version-expression) `)` |
+| *version-term* | &xrarr; | [*version-atom*](#version-atom)               |
+|                | \|      | `!` [*version-atom*](#version-atom)           |
+|                | \|      | `<` [*version-atom*](#version-atom)           |
+|                | \|      | `<=` [*version-atom*](#version-atom)          |
+|                | \|      | `>=` [*version-atom*](#version-atom)          |
+|                | \|      | `>` [*version-atom*](#version-atom)           |
+|                | \|      | `(` [*version-expr*](#version-expression) `)` |
 </div>
 
-#### <a name="Version-atom">Version-atom</a> (*version-atom*)
+#### Version-atom
 
 <div className="lang-ref-table">
 |                |         |                               |
@@ -103,7 +107,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                | \|      | [*version*](#version-literal) |
 </div>
 
-#### <a name="Include">Include</a> (*include-form*)
+#### Include
 
 <div className="lang-ref-table">
 |                |         |                                         |
@@ -111,23 +115,23 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *include-form* | &xrarr; | `include` [*file*](#string-literal) `;` |
 </div>
 
-#### <a name="Module-definition">Module-definition</a> (*module-definition*)
+#### Module-definition
 
 <div className="lang-ref-table">
 |                     |         |                                                                                                                                                                                                       |
 |---------------------|---------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*program-element*](#Program-element) ⋯ [*program-element*](#Program-element) `}` |
+| *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#identifier) [*gparams*](#generic-parameter-list)<sup>opt</sup> `{` [*program-element*](#program-element) ⋯ [*program-element*](#program-element) `}` |
 </div>
 
-#### <a name="Generic-parameter-list">Generic-parameter-list</a> (*gparams*)
+#### Generic-parameter-list
 
 <div className="lang-ref-table">
 |           |         |                                                                                                                 |
 |-----------|---------|-----------------------------------------------------------------------------------------------------------------|
-| *gparams* | &xrarr; | `<` [*generic-param*](#Generic-parameter) `,` ⋯ `,` [*generic-param*](#Generic-parameter) `,`<sup>opt</sup> `>` |
+| *gparams* | &xrarr; | `<` [*generic-param*](#generic-parameter) `,` ⋯ `,` [*generic-param*](#generic-parameter) `,`<sup>opt</sup> `>` |
 </div>
 
-#### <a name="Generic-parameter">Generic-parameter</a> (*generic-param*)
+#### Generic-parameter
 
 <div className="lang-ref-table">
 |                 |         |                                |
@@ -136,23 +140,23 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                 | \|      | [*tvar-name*](#identifier)     |
 </div>
 
-#### <a name="Import-declaration">Import-declaration</a> (*import-form*)
+#### Import-declaration
 
 <div className="lang-ref-table">
 |               |         |                                                                                                                                                                                                  |
 |---------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *import-form* | &xrarr; | `import` [*import-selection*](#Import-selection)<sup>opt</sup> [*import-name*](#Import-name) [*gargs*](#Generic-argument-list)<sup>opt</sup> [*import-prefix*](#Import-prefix)<sup>opt</sup> `;` |
+| *import-form* | &xrarr; | `import` [*import-selection*](#import-selection)<sup>opt</sup> [*import-name*](#import-name) [*gargs*](#generic-argument-list)<sup>opt</sup> [*import-prefix*](#import-prefix)<sup>opt</sup> `;` |
 </div>
 
-#### <a name="Import-selection">Import-selection</a> (*import-selection*)
+#### Import-selection
 
 <div className="lang-ref-table">
 |                    |         |                                                                                                                    |
 |--------------------|---------|--------------------------------------------------------------------------------------------------------------------|
-| *import-selection* | &xrarr; | `{` [*import-element*](#Import-element) `,` ⋯ `,` [*import-element*](#Import-element) `,`<sup>opt</sup> `}` `from` |
+| *import-selection* | &xrarr; | `{` [*import-element*](#import-element) `,` ⋯ `,` [*import-element*](#import-element) `,`<sup>opt</sup> `}` `from` |
 </div>
 
-#### <a name="Import-element">Import-element</a> (*import-element*)
+#### Import-element
 
 <div className="lang-ref-table">
 |                  |         |                                              |
@@ -161,7 +165,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |                  | \|      | [*id*](#identifier) `as` [*id*](#identifier) |
 </div>
 
-#### <a name="Import-name">Import-name</a> (*import-name*)
+#### Import-name
 
 <div className="lang-ref-table">
 |               |         |                           |
@@ -170,7 +174,7 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |               | \|      | [*file*](#string-literal) |
 </div>
 
-#### <a name="Import-prefix">Import-prefix</a> (*import-prefix*)
+#### Import-prefix
 
 <div className="lang-ref-table">
 |                 |         |                              |
@@ -178,24 +182,24 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *import-prefix* | &xrarr; | `prefix` [*id*](#identifier) |
 </div>
 
-#### <a name="Generic-argument-list">Generic-argument-list</a> (*gargs*)
+#### Generic-argument-list
 
 <div className="lang-ref-table">
 |         |         |                                                                                             |
 |---------|---------|---------------------------------------------------------------------------------------------|
-| *gargs* | &xrarr; | `<` [*garg*](#Generic-argument) `,` ⋯ `,` [*garg*](#Generic-argument) `,`<sup>opt</sup> `>` |
+| *gargs* | &xrarr; | `<` [*garg*](#generic-argument) `,` ⋯ `,` [*garg*](#generic-argument) `,`<sup>opt</sup> `>` |
 </div>
 
-#### <a name="Generic-argument">Generic-argument</a> (*garg*)
+#### Generic-argument
 
 <div className="lang-ref-table">
 |        |         |                         |
 |--------|---------|-------------------------|
 | *garg* | &xrarr; | [*nat*](#field-literal) |
-|        | \|      | [*type*](#Type)         |
+|        | \|      | [*type*](#type)         |
 </div>
 
-#### <a name="Export-declaration">Export-declaration</a> (*export-form*)
+#### Export-declaration
 
 <div className="lang-ref-table">
 |               |         |                                                                                                        |
@@ -203,48 +207,48 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *export-form* | &xrarr; | `export` `{` [*id*](#identifier) `,` ⋯ `,` [*id*](#identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### <a name="Ledger-declaration">Ledger-declaration</a> (*ledger-declaration*)
+#### Ledger-declaration
 
 <div className="lang-ref-table">
 |                      |         |                                                                                                    |
 |----------------------|---------|----------------------------------------------------------------------------------------------------|
-| *ledger-declaration* | &xrarr; | `export`<sup>opt</sup> `sealed`<sup>opt</sup> `ledger` [*id*](#identifier) `:` [*type*](#Type) `;` |
+| *ledger-declaration* | &xrarr; | `export`<sup>opt</sup> `sealed`<sup>opt</sup> `ledger` [*id*](#identifier) `:` [*type*](#type) `;` |
 </div>
 
-#### <a name="Witness-declaration">Witness-declaration</a> (*witness-declaration*)
+#### Witness-declaration
 
 <div className="lang-ref-table">
 |                       |         |                                                                                                                                                                                   |
 |-----------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *witness-declaration* | &xrarr; | `export`<sup>opt</sup> `witness` [*id*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> [*simple-parameter-list*](#Simple-parameter-list) `:` [*type*](#Type) `;` |
+| *witness-declaration* | &xrarr; | `export`<sup>opt</sup> `witness` [*id*](#identifier) [*gparams*](#generic-parameter-list)<sup>opt</sup> [*simple-parameter-list*](#simple-parameter-list) `:` [*type*](#type) `;` |
 </div>
 
-#### <a name="Constructor">Constructor</a> (*constructor-definition*)
+#### Constructor
 
 <div className="lang-ref-table">
 |                          |         |                                                                                     |
 |--------------------------|---------|-------------------------------------------------------------------------------------|
-| *constructor-definition* | &xrarr; | `constructor` [*pattern-parameter-list*](#Pattern-parameter-list) [*block*](#Block) |
+| *constructor-definition* | &xrarr; | `constructor` [*pattern-parameter-list*](#pattern-parameter-list) [*block*](#block) |
 </div>
 
-#### <a name="Circuit-definition">Circuit-definition</a> (*circuit-definition*)
+#### Circuit-definition
 
 <div className="lang-ref-table">
 |                      |         |                                                                                                                                                                                                                                   |
 |----------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *circuit-definition* | &xrarr; | `export`<sup>opt</sup> `pure`<sup>opt</sup> `circuit` [*function-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> [*pattern-parameter-list*](#Pattern-parameter-list) `:` [*type*](#Type) [*block*](#Block) |
+| *circuit-definition* | &xrarr; | `export`<sup>opt</sup> `pure`<sup>opt</sup> `circuit` [*function-name*](#identifier) [*gparams*](#generic-parameter-list)<sup>opt</sup> [*pattern-parameter-list*](#pattern-parameter-list) `:` [*type*](#type) [*block*](#block) |
 </div>
 
-#### <a name="Structure-declaration">Structure-declaration</a> (*struct-declaration*)
+#### Structure-declaration
 
 <div className="lang-ref-table">
 |                      |         |                                                                                                                                                                                                                                       |
 |----------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *struct-declaration* | &xrarr; | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-id*](#Typed-identifier) `;` ⋯ `;` [*typed-id*](#Typed-identifier) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
-|                      | \|      | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `{` [*typed-id*](#Typed-identifier) `,` ⋯ `,` [*typed-id*](#Typed-identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+| *struct-declaration* | &xrarr; | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#generic-parameter-list)<sup>opt</sup> `{` [*typed-id*](#typed-identifier) `;` ⋯ `;` [*typed-id*](#typed-identifier) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                      | \|      | `export`<sup>opt</sup> `struct` [*struct-name*](#identifier) [*gparams*](#generic-parameter-list)<sup>opt</sup> `{` [*typed-id*](#typed-identifier) `,` ⋯ `,` [*typed-id*](#typed-identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### <a name="Enum-declaration">Enum-declaration</a> (*enum-declaration*)
+#### Enum-declaration
 
 <div className="lang-ref-table">
 |                    |         |                                                                                                                                                         |
@@ -252,88 +256,88 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 | *enum-declaration* | &xrarr; | `export`<sup>opt</sup> `enum` [*enum-name*](#identifier) `{` [*id*](#identifier) `,` ⋯¹ `,` [*id*](#identifier) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### <a name="External-contract-declaration">External-contract-declaration</a> (*contract-declaration*)
+#### External-contract-declaration
 
 <div className="lang-ref-table">
 |                        |         |                                                                                                                                                                                                                                |
 |------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *contract-declaration* | &xrarr; | `export`<sup>opt</sup> `contract` [*contract-name*](#identifier) `{` [*circuit-declaration*](#External-contract-circuit) `;` ⋯ `;` [*circuit-declaration*](#External-contract-circuit) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
-|                        | \|      | `export`<sup>opt</sup> `contract` [*contract-name*](#identifier) `{` [*circuit-declaration*](#External-contract-circuit) `,` ⋯ `,` [*circuit-declaration*](#External-contract-circuit) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+| *contract-declaration* | &xrarr; | `export`<sup>opt</sup> `contract` [*contract-name*](#identifier) `{` [*circuit-declaration*](#external-contract-circuit) `;` ⋯ `;` [*circuit-declaration*](#external-contract-circuit) `;`<sup>opt</sup> `}` `;`<sup>opt</sup> |
+|                        | \|      | `export`<sup>opt</sup> `contract` [*contract-name*](#identifier) `{` [*circuit-declaration*](#external-contract-circuit) `,` ⋯ `,` [*circuit-declaration*](#external-contract-circuit) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-#### <a name="External-contract-circuit">External-contract-circuit</a> (*circuit-declaration*)
+#### External-contract-circuit
 
 <div className="lang-ref-table">
 |                       |         |                                                                                                                          |
 |-----------------------|---------|--------------------------------------------------------------------------------------------------------------------------|
-| *circuit-declaration* | &xrarr; | `pure`<sup>opt</sup> `circuit` [*id*](#identifier) [*simple-parameter-list*](#Simple-parameter-list) `:` [*type*](#Type) |
+| *circuit-declaration* | &xrarr; | `pure`<sup>opt</sup> `circuit` [*id*](#identifier) [*simple-parameter-list*](#simple-parameter-list) `:` [*type*](#type) |
 </div>
 
-#### <a name="Type-declaration">Type-declaration</a> (*type-alias-declaration*)
+#### Type-declaration
 
 <div className="lang-ref-table">
 |                          |         |                                                                                                                                                         |
 |--------------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *type-alias-declaration* | &xrarr; | `export`<sup>opt</sup> `new`<sup>opt</sup> `type` [*type-name*](#identifier) [*gparams*](#Generic-parameter-list)<sup>opt</sup> `=` [*type*](#Type) `;` |
+| *type-alias-declaration* | &xrarr; | `export`<sup>opt</sup> `new`<sup>opt</sup> `type` [*type-name*](#identifier) [*gparams*](#generic-parameter-list)<sup>opt</sup> `=` [*type*](#type) `;` |
 </div>
 
-#### <a name="Typed-identifier">Typed-identifier</a> (*typed-id*)
+#### Typed-identifier
 
 <div className="lang-ref-table">
 |            |         |                                         |
 |------------|---------|-----------------------------------------|
-| *typed-id* | &xrarr; | [*id*](#identifier) `:` [*type*](#Type) |
+| *typed-id* | &xrarr; | [*id*](#identifier) `:` [*type*](#type) |
 </div>
 
-#### <a name="Simple-parameter-list">Simple-parameter-list</a> (*simple-parameter-list*)
+#### Simple-parameter-list
 
 <div className="lang-ref-table">
 |                         |         |                                                                                                     |
 |-------------------------|---------|-----------------------------------------------------------------------------------------------------|
-| *simple-parameter-list* | &xrarr; | `(` [*typed-id*](#Typed-identifier) `,` ⋯ `,` [*typed-id*](#Typed-identifier) `,`<sup>opt</sup> `)` |
+| *simple-parameter-list* | &xrarr; | `(` [*typed-id*](#typed-identifier) `,` ⋯ `,` [*typed-id*](#typed-identifier) `,`<sup>opt</sup> `)` |
 </div>
 
-#### <a name="Typed-pattern">Typed-pattern</a> (*typed-pattern*)
+#### Typed-pattern
 
 <div className="lang-ref-table">
 |                 |         |                                           |
 |-----------------|---------|-------------------------------------------|
-| *typed-pattern* | &xrarr; | [*pattern*](#Pattern) `:` [*type*](#Type) |
+| *typed-pattern* | &xrarr; | [*pattern*](#pattern) `:` [*type*](#type) |
 </div>
 
-#### <a name="Pattern-parameter-list">Pattern-parameter-list</a> (*pattern-parameter-list*)
+#### Pattern-parameter-list
 
 <div className="lang-ref-table">
 |                          |         |                                                                                                         |
 |--------------------------|---------|---------------------------------------------------------------------------------------------------------|
-| *pattern-parameter-list* | &xrarr; | `(` [*typed-pattern*](#Typed-pattern) `,` ⋯ `,` [*typed-pattern*](#Typed-pattern) `,`<sup>opt</sup> `)` |
+| *pattern-parameter-list* | &xrarr; | `(` [*typed-pattern*](#typed-pattern) `,` ⋯ `,` [*typed-pattern*](#typed-pattern) `,`<sup>opt</sup> `)` |
 </div>
 
-#### <a name="Type">Type</a> (*type*)
+#### Type
 
 <div className="lang-ref-table">
 |        |         |                                                                     |
 |--------|---------|---------------------------------------------------------------------|
-| *type* | &xrarr; | [*tref*](#Type-reference)                                           |
+| *type* | &xrarr; | [*tref*](#type-reference)                                           |
 |        | \|      | `Boolean`                                                           |
 |        | \|      | `Field`                                                             |
-|        | \|      | `Uint` `<` [*tsize*](#Type-size) `>`                                |
-|        | \|      | `Uint` `<` [*tsize*](#Type-size) `..` [*tsize*](#Type-size) `>`     |
-|        | \|      | `Bytes` `<` [*tsize*](#Type-size) `>`                               |
+|        | \|      | `Uint` `<` [*tsize*](#type-size) `>`                                |
+|        | \|      | `Uint` `<` [*tsize*](#type-size) `..` [*tsize*](#type-size) `>`     |
+|        | \|      | `Bytes` `<` [*tsize*](#type-size) `>`                               |
 |        | \|      | `Opaque` `<` [*str*](#string-literal) `>`                           |
-|        | \|      | `Vector` `<` [*tsize*](#Type-size) `,` [*type*](#Type) `>`          |
-|        | \|      | `[` [*type*](#Type) `,` ⋯ `,` [*type*](#Type) `,`<sup>opt</sup> `]` |
+|        | \|      | `Vector` `<` [*tsize*](#type-size) `,` [*type*](#type) `>`          |
+|        | \|      | `[` [*type*](#type) `,` ⋯ `,` [*type*](#type) `,`<sup>opt</sup> `]` |
 </div>
 
-#### <a name="Type-reference">Type-reference</a> (*tref*)
+#### Type-reference
 
 <div className="lang-ref-table">
 |        |         |                                                                     |
 |--------|---------|---------------------------------------------------------------------|
-| *tref* | &xrarr; | [*id*](#identifier) [*gargs*](#Generic-argument-list)<sup>opt</sup> |
+| *tref* | &xrarr; | [*id*](#identifier) [*gargs*](#generic-argument-list)<sup>opt</sup> |
 </div>
 
-#### <a name="Type-size">Type-size</a> (*tsize*)
+#### Type-size
 
 <div className="lang-ref-table">
 |         |         |                         |
@@ -342,184 +346,184 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |         | \|      | [*id*](#identifier)     |
 </div>
 
-#### <a name="Block">Block</a> (*block*)
+#### Block
 
 <div className="lang-ref-table">
 |         |         |                                                     |
 |---------|---------|-----------------------------------------------------|
-| *block* | &xrarr; | `{` [*stmt*](#Statement) ⋯ [*stmt*](#Statement) `}` |
+| *block* | &xrarr; | `{` [*stmt*](#statement) ⋯ [*stmt*](#statement) `}` |
 </div>
 
-#### <a name="Statement">Statement</a> (*stmt*)
+#### Statement
 
 <div className="lang-ref-table">
 |        |         |                                                                      |
 |--------|---------|----------------------------------------------------------------------|
-| *stmt* | &xrarr; | `if` `(` [*expr-seq*](#Expression-sequence) `)` [*stmt*](#Statement) |
-|        | \|      | [*stmt<sub>0</sub>*](#Statement0)                                    |
+| *stmt* | &xrarr; | `if` `(` [*expr-seq*](#expression-sequence) `)` [*stmt*](#statement) |
+|        | \|      | [*stmt<sub>0</sub>*](#statement0)                                    |
 </div>
 
-#### <a name="Statement0">Statement<sub>0</sub></a> (*stmt<sub>0</sub>*)
+#### Statement<sub>0</sub>
 
 <div className="lang-ref-table">
 |                    |         |                                                                                                                          |
 |--------------------|---------|--------------------------------------------------------------------------------------------------------------------------|
-| *stmt<sub>0</sub>* | &xrarr; | [*expr-seq*](#Expression-sequence) `;`                                                                                   |
-|                    | \|      | `const` [*cbinding*](#Const-Binding) `,` ⋯¹ `,` [*cbinding*](#Const-Binding)  `;`                                        |
-|                    | \|      | `if` `(` [*expr-seq*](#Expression-sequence) `)` [*stmt<sub>0</sub>*](#Statement0) `else` [*stmt*](#Statement)            |
-|                    | \|      | `for` `(` `const` [*id*](#identifier) `of` [*nat*](#field-literal) `..` [*nat*](#field-literal) `)` [*stmt*](#Statement) |
-|                    | \|      | `for` `(` `const` [*id*](#identifier) `of` [*expr-seq*](#Expression-sequence) `)` [*stmt*](#Statement)                   |
-|                    | \|      | `return` [*expr-seq*](#Expression-sequence) `;`                                                                          |
+| *stmt<sub>0</sub>* | &xrarr; | [*expr-seq*](#expression-sequence) `;`                                                                                   |
+|                    | \|      | `const` [*cbinding*](#const-binding) `,` ⋯¹ `,` [*cbinding*](#const-binding)  `;`                                        |
+|                    | \|      | `if` `(` [*expr-seq*](#expression-sequence) `)` [*stmt<sub>0</sub>*](#statement0) `else` [*stmt*](#statement)            |
+|                    | \|      | `for` `(` `const` [*id*](#identifier) `of` [*nat*](#field-literal) `..` [*nat*](#field-literal) `)` [*stmt*](#statement) |
+|                    | \|      | `for` `(` `const` [*id*](#identifier) `of` [*expr-seq*](#expression-sequence) `)` [*stmt*](#statement)                   |
+|                    | \|      | `return` [*expr-seq*](#expression-sequence) `;`                                                                          |
 |                    | \|      | `return` `;`                                                                                                             |
-|                    | \|      | [*block*](#Block)                                                                                                        |
+|                    | \|      | [*block*](#block)                                                                                                        |
 </div>
 
-#### <a name="Pattern">Pattern</a> (*pattern*)
+#### Pattern
 
 <div className="lang-ref-table">
 |           |         |                                                                                                                                     |
 |-----------|---------|-------------------------------------------------------------------------------------------------------------------------------------|
 | *pattern* | &xrarr; | [*id*](#identifier)                                                                                                                 |
-|           | \|      | `[` [*pattern*](#Pattern)<sup>opt</sup> `,` ⋯ `,` [*pattern*](#Pattern)<sup>opt</sup> `,`<sup>opt</sup> `]`                         |
-|           | \|      | `{` [*pattern-struct-elt*](#Pattern-struct-element) `,` ⋯ `,` [*pattern-struct-elt*](#Pattern-struct-element) `,`<sup>opt</sup> `}` |
+|           | \|      | `[` [*pattern*](#pattern)<sup>opt</sup> `,` ⋯ `,` [*pattern*](#pattern)<sup>opt</sup> `,`<sup>opt</sup> `]`                         |
+|           | \|      | `{` [*pattern-struct-elt*](#pattern-struct-element) `,` ⋯ `,` [*pattern-struct-elt*](#pattern-struct-element) `,`<sup>opt</sup> `}` |
 </div>
 
-#### <a name="Pattern-struct-element">Pattern-struct-element</a> (*pattern-struct-elt*)
+#### Pattern-struct-element
 
 <div className="lang-ref-table">
 |                      |         |                                               |
 |----------------------|---------|-----------------------------------------------|
 | *pattern-struct-elt* | &xrarr; | [*id*](#identifier)                           |
-|                      | \|      | [*id*](#identifier) `:` [*pattern*](#Pattern) |
+|                      | \|      | [*id*](#identifier) `:` [*pattern*](#pattern) |
 </div>
 
-#### <a name="Expression-sequence">Expression-sequence</a> (*expr-seq*)
+#### Expression-sequence
 
 <div className="lang-ref-table">
 |            |         |                                                                                   |
 |------------|---------|-----------------------------------------------------------------------------------|
-| *expr-seq* | &xrarr; | [*expr*](#Expression)                                                             |
-|            | \|      | [*expr*](#Expression) `,` ⋯¹ `,` [*expr*](#Expression)  `,` [*expr*](#Expression) |
+| *expr-seq* | &xrarr; | [*expr*](#expression)                                                             |
+|            | \|      | [*expr*](#expression) `,` ⋯¹ `,` [*expr*](#expression)  `,` [*expr*](#expression) |
 </div>
 
-#### <a name="Expression">Expression</a> (*expr*)
+#### Expression
 
 <div className="lang-ref-table">
 |        |         |                                                                                        |
 |--------|---------|----------------------------------------------------------------------------------------|
-| *expr* | &xrarr; | [*expr<sub>0</sub>*](#Expression0) `?` [*expr*](#Expression) `:` [*expr*](#Expression) |
-|        | \|      | [*expr<sub>0</sub>*](#Expression0) `=` [*expr*](#Expression)                           |
-|        | \|      | [*expr<sub>0</sub>*](#Expression0) `+=` [*expr*](#Expression)                          |
-|        | \|      | [*expr<sub>0</sub>*](#Expression0) `-=` [*expr*](#Expression)                          |
-|        | \|      | [*expr<sub>0</sub>*](#Expression0)                                                     |
+| *expr* | &xrarr; | [*expr<sub>0</sub>*](#expression0) `?` [*expr*](#expression) `:` [*expr*](#expression) |
+|        | \|      | [*expr<sub>0</sub>*](#expression0) `=` [*expr*](#expression)                           |
+|        | \|      | [*expr<sub>0</sub>*](#expression0) `+=` [*expr*](#expression)                          |
+|        | \|      | [*expr<sub>0</sub>*](#expression0) `-=` [*expr*](#expression)                          |
+|        | \|      | [*expr<sub>0</sub>*](#expression0)                                                     |
 </div>
 
-#### <a name="Expression0">Expression<sub>0</sub></a> (*expr<sub>0</sub>*)
+#### Expression<sub>0</sub>
 
 <div className="lang-ref-table">
 |                    |         |                                                                              |
 |--------------------|---------|------------------------------------------------------------------------------|
-| *expr<sub>0</sub>* | &xrarr; | [*expr<sub>0</sub>*](#Expression0) `\|\|` [*expr<sub>1</sub>*](#Expression1) |
-|                    | \|      | [*expr<sub>1</sub>*](#Expression1)                                           |
+| *expr<sub>0</sub>* | &xrarr; | [*expr<sub>0</sub>*](#expression0) `\|\|` [*expr<sub>1</sub>*](#expression1) |
+|                    | \|      | [*expr<sub>1</sub>*](#expression1)                                           |
 </div>
 
-#### <a name="Expression1">Expression<sub>1</sub></a> (*expr<sub>1</sub>*)
+#### Expression<sub>1</sub>
 
 <div className="lang-ref-table">
 |                    |         |                                                                            |
 |--------------------|---------|----------------------------------------------------------------------------|
-| *expr<sub>1</sub>* | &xrarr; | [*expr<sub>1</sub>*](#Expression1) `&&` [*expr<sub>2</sub>*](#Expression2) |
-|                    | \|      | [*expr<sub>2</sub>*](#Expression2)                                         |
+| *expr<sub>1</sub>* | &xrarr; | [*expr<sub>1</sub>*](#expression1) `&&` [*expr<sub>2</sub>*](#expression2) |
+|                    | \|      | [*expr<sub>2</sub>*](#expression2)                                         |
 </div>
 
-#### <a name="Expression2">Expression<sub>2</sub></a> (*expr<sub>2</sub>*)
+#### Expression<sub>2</sub>
 
 <div className="lang-ref-table">
 |                    |         |                                                                            |
 |--------------------|---------|----------------------------------------------------------------------------|
-| *expr<sub>2</sub>* | &xrarr; | [*expr<sub>2</sub>*](#Expression2) `==` [*expr<sub>3</sub>*](#Expression3) |
-|                    | \|      | [*expr<sub>2</sub>*](#Expression2) `!=` [*expr<sub>3</sub>*](#Expression3) |
-|                    | \|      | [*expr<sub>3</sub>*](#Expression3)                                         |
+| *expr<sub>2</sub>* | &xrarr; | [*expr<sub>2</sub>*](#expression2) `==` [*expr<sub>3</sub>*](#expression3) |
+|                    | \|      | [*expr<sub>2</sub>*](#expression2) `!=` [*expr<sub>3</sub>*](#expression3) |
+|                    | \|      | [*expr<sub>3</sub>*](#expression3)                                         |
 </div>
 
-#### <a name="Expression3">Expression<sub>3</sub></a> (*expr<sub>3</sub>*)
+#### Expression<sub>3</sub>
 
 <div className="lang-ref-table">
 |                    |         |                                                                            |
 |--------------------|---------|----------------------------------------------------------------------------|
-| *expr<sub>3</sub>* | &xrarr; | [*expr<sub>4</sub>*](#Expression4) `<` [*expr<sub>4</sub>*](#Expression4)  |
-|                    | \|      | [*expr<sub>4</sub>*](#Expression4) `<=` [*expr<sub>4</sub>*](#Expression4) |
-|                    | \|      | [*expr<sub>4</sub>*](#Expression4) `>=` [*expr<sub>4</sub>*](#Expression4) |
-|                    | \|      | [*expr<sub>4</sub>*](#Expression4) `>` [*expr<sub>4</sub>*](#Expression4)  |
-|                    | \|      | [*expr<sub>4</sub>*](#Expression4)                                         |
+| *expr<sub>3</sub>* | &xrarr; | [*expr<sub>4</sub>*](#expression4) `<` [*expr<sub>4</sub>*](#expression4)  |
+|                    | \|      | [*expr<sub>4</sub>*](#expression4) `<=` [*expr<sub>4</sub>*](#expression4) |
+|                    | \|      | [*expr<sub>4</sub>*](#expression4) `>=` [*expr<sub>4</sub>*](#expression4) |
+|                    | \|      | [*expr<sub>4</sub>*](#expression4) `>` [*expr<sub>4</sub>*](#expression4)  |
+|                    | \|      | [*expr<sub>4</sub>*](#expression4)                                         |
 </div>
 
-#### <a name="Expression4">Expression<sub>4</sub></a> (*expr<sub>4</sub>*)
+#### Expression<sub>4</sub>
 
 <div className="lang-ref-table">
 |                    |         |                                                         |
 |--------------------|---------|---------------------------------------------------------|
-| *expr<sub>4</sub>* | &xrarr; | [*expr<sub>4</sub>*](#Expression4) `as` [*type*](#Type) |
-|                    | \|      | [*expr<sub>5</sub>*](#Expression5)                      |
+| *expr<sub>4</sub>* | &xrarr; | [*expr<sub>4</sub>*](#expression4) `as` [*type*](#type) |
+|                    | \|      | [*expr<sub>5</sub>*](#expression5)                      |
 </div>
 
-#### <a name="Expression5">Expression<sub>5</sub></a> (*expr<sub>5</sub>*)
+#### Expression<sub>5</sub>
 
 <div className="lang-ref-table">
 |                    |         |                                                                           |
 |--------------------|---------|---------------------------------------------------------------------------|
-| *expr<sub>5</sub>* | &xrarr; | [*expr<sub>5</sub>*](#Expression5) `+` [*expr<sub>6</sub>*](#Expression6) |
-|                    | \|      | [*expr<sub>5</sub>*](#Expression5) `-` [*expr<sub>6</sub>*](#Expression6) |
-|                    | \|      | [*expr<sub>6</sub>*](#Expression6)                                        |
+| *expr<sub>5</sub>* | &xrarr; | [*expr<sub>5</sub>*](#expression5) `+` [*expr<sub>6</sub>*](#expression6) |
+|                    | \|      | [*expr<sub>5</sub>*](#expression5) `-` [*expr<sub>6</sub>*](#expression6) |
+|                    | \|      | [*expr<sub>6</sub>*](#expression6)                                        |
 </div>
 
-#### <a name="Expression6">Expression<sub>6</sub></a> (*expr<sub>6</sub>*)
+#### Expression<sub>6</sub>
 
 <div className="lang-ref-table">
 |                    |         |                                                                           |
 |--------------------|---------|---------------------------------------------------------------------------|
-| *expr<sub>6</sub>* | &xrarr; | [*expr<sub>6</sub>*](#Expression6) `*` [*expr<sub>7</sub>*](#Expression7) |
-|                    | \|      | [*expr<sub>7</sub>*](#Expression7)                                        |
+| *expr<sub>6</sub>* | &xrarr; | [*expr<sub>6</sub>*](#expression6) `*` [*expr<sub>7</sub>*](#expression7) |
+|                    | \|      | [*expr<sub>7</sub>*](#expression7)                                        |
 </div>
 
-#### <a name="Expression7">Expression<sub>7</sub></a> (*expr<sub>7</sub>*)
+#### Expression<sub>7</sub>
 
 <div className="lang-ref-table">
 |                    |         |                                        |
 |--------------------|---------|----------------------------------------|
-| *expr<sub>7</sub>* | &xrarr; | `!` [*expr<sub>7</sub>*](#Expression7) |
-|                    | \|      | [*expr<sub>8</sub>*](#Expression8)     |
+| *expr<sub>7</sub>* | &xrarr; | `!` [*expr<sub>7</sub>*](#expression7) |
+|                    | \|      | [*expr<sub>8</sub>*](#expression8)     |
 </div>
 
-#### <a name="Expression8">Expression<sub>8</sub></a> (*expr<sub>8</sub>*)
+#### Expression<sub>8</sub>
 
 <div className="lang-ref-table">
 |                    |         |                                                                                                                                            |
 |--------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------|
-| *expr<sub>8</sub>* | &xrarr; | [*expr<sub>8</sub>*](#Expression8) `[` [*expr*](#Expression) `]`                                                                           |
-|                    | \|      | [*expr<sub>8</sub>*](#Expression8) `.` [*id*](#identifier)                                                                                 |
-|                    | \|      | [*expr<sub>8</sub>*](#Expression8) `.` [*id*](#identifier) `(` [*expr*](#Expression) `,` ⋯ `,` [*expr*](#Expression) `,`<sup>opt</sup> `)` |
-|                    | \|      | [*expr<sub>9</sub>*](#Expression9)                                                                                                         |
+| *expr<sub>8</sub>* | &xrarr; | [*expr<sub>8</sub>*](#expression8) `[` [*expr*](#expression) `]`                                                                           |
+|                    | \|      | [*expr<sub>8</sub>*](#expression8) `.` [*id*](#identifier)                                                                                 |
+|                    | \|      | [*expr<sub>8</sub>*](#expression8) `.` [*id*](#identifier) `(` [*expr*](#expression) `,` ⋯ `,` [*expr*](#expression) `,`<sup>opt</sup> `)` |
+|                    | \|      | [*expr<sub>9</sub>*](#expression9)                                                                                                         |
 </div>
 
-#### <a name="Expression9">Expression<sub>9</sub></a> (*expr<sub>9</sub>*)
+#### Expression<sub>9</sub>
 
 <div className="lang-ref-table">
 |                    |         |                                                                                                                                          |
 |--------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------|
-| *expr<sub>9</sub>* | &xrarr; | [*fun*](#Function) `(` [*expr*](#Expression) `,` ⋯ `,` [*expr*](#Expression) `,`<sup>opt</sup> `)`                                       |
-|                    | \|      | `map` `(` [*fun*](#Function) `,` [*expr*](#Expression) `,` ⋯¹ `,` [*expr*](#Expression) `,`<sup>opt</sup> `)`                            |
-|                    | \|      | `fold` `(` [*fun*](#Function) `,` [*expr*](#Expression) `,` [*expr*](#Expression) `,` ⋯¹ `,` [*expr*](#Expression) `,`<sup>opt</sup> `)` |
-|                    | \|      | `slice` `<` [*tsize*](#Type-size) `>` `(` [*expr*](#Expression) `,` [*expr*](#Expression) `)`                                            |
-|                    | \|      | `[` [*tuple-arg*](#Tuple-argument) `,` ⋯ `,` [*tuple-arg*](#Tuple-argument) `,`<sup>opt</sup> `]`                                        |
-|                    | \|      | `Bytes` `[` [*tuple-arg*](#Tuple-argument) `,` ⋯ `,` [*tuple-arg*](#Tuple-argument) `,`<sup>opt</sup> `]`                                |
-|                    | \|      | [*tref*](#Type-reference) `{` [*struct-arg*](#Structure-argument) `,` ⋯ `,` [*struct-arg*](#Structure-argument) `,`<sup>opt</sup> `}`    |
-|                    | \|      | `assert` `(` [*expr*](#Expression) `,` [*str*](#string-literal) `)`                                                                      |
-|                    | \|      | `disclose` `(` [*expr*](#Expression) `)`                                                                                                 |
-|                    | \|      | [*term*](#Term)                                                                                                                          |
+| *expr<sub>9</sub>* | &xrarr; | [*fun*](#function) `(` [*expr*](#expression) `,` ⋯ `,` [*expr*](#expression) `,`<sup>opt</sup> `)`                                       |
+|                    | \|      | `map` `(` [*fun*](#function) `,` [*expr*](#expression) `,` ⋯¹ `,` [*expr*](#expression) `,`<sup>opt</sup> `)`                            |
+|                    | \|      | `fold` `(` [*fun*](#function) `,` [*expr*](#expression) `,` [*expr*](#expression) `,` ⋯¹ `,` [*expr*](#expression) `,`<sup>opt</sup> `)` |
+|                    | \|      | `slice` `<` [*tsize*](#type-size) `>` `(` [*expr*](#expression) `,` [*expr*](#expression) `)`                                            |
+|                    | \|      | `[` [*tuple-arg*](#tuple-argument) `,` ⋯ `,` [*tuple-arg*](#tuple-argument) `,`<sup>opt</sup> `]`                                        |
+|                    | \|      | `Bytes` `[` [*bytes-arg*](#tuple-argument) `,` ⋯ `,` [*bytes-arg*](#tuple-argument) `,`<sup>opt</sup> `]`                                |
+|                    | \|      | [*tref*](#type-reference) `{` [*struct-arg*](#structure-argument) `,` ⋯ `,` [*struct-arg*](#structure-argument) `,`<sup>opt</sup> `}`    |
+|                    | \|      | `assert` `(` [*expr*](#expression) `,` [*str*](#string-literal) `)`                                                                      |
+|                    | \|      | `disclose` `(` [*expr*](#expression) `)`                                                                                                 |
+|                    | \|      | [*term*](#term)                                                                                                                          |
 </div>
 
-#### <a name="Term">Term</a> (*term*)
+#### Term
 
 <div className="lang-ref-table">
 |        |         |                                                                    |
@@ -530,71 +534,71 @@ A version literal takes the form nat or nat.nat or nat.nat.nat, e.g., 1.2 or 1.2
 |        | \|      | [*nat*](#field-literal)                                            |
 |        | \|      | [*str*](#string-literal)                                           |
 |        | \|      | `pad` `(` [*nat*](#field-literal) `,` [*str*](#string-literal) `)` |
-|        | \|      | `default` `<` [*type*](#Type) `>`                                  |
-|        | \|      | `(` [*expr-seq*](#Expression-sequence) `)`                         |
+|        | \|      | `default` `<` [*type*](#type) `>`                                  |
+|        | \|      | `(` [*expr-seq*](#expression-sequence) `)`                         |
 </div>
 
-#### <a name="Tuple-argument">Tuple-argument</a> (*tuple-arg*, *bytes-arg*)
+#### Tuple-argument
 
 <div className="lang-ref-table">
-|             |         |                             |
-|-------------|---------|-----------------------------|
-| *tuple-arg* | &xrarr; | [*expr*](#Expression)       |
-|             | \|      | `...` [*expr*](#Expression) |
-| *bytes-arg* | &xrarr; | *tuple-arg*                 |
+|             |         |                                |
+|-------------|---------|--------------------------------|
+| *tuple-arg* | &xrarr; | [*expr*](#expression)          |
+|             | \|      | `...` [*expr*](#expression)    |
+| *bytes-arg* | &xrarr; | [*tuple-arg*](#tuple-argument) |
 </div>
 
-#### <a name="Structure-argument">Structure-argument</a> (*struct-arg*)
+#### Structure-argument
 
 <div className="lang-ref-table">
 |              |         |                                               |
 |--------------|---------|-----------------------------------------------|
-| *struct-arg* | &xrarr; | [*expr*](#Expression)                         |
-|              | \|      | [*id*](#identifier) `:` [*expr*](#Expression) |
-|              | \|      | `...` [*expr*](#Expression)                   |
+| *struct-arg* | &xrarr; | [*expr*](#expression)                         |
+|              | \|      | [*id*](#identifier) `:` [*expr*](#expression) |
+|              | \|      | `...` [*expr*](#expression)                   |
 </div>
 
-#### <a name="Function">Function</a> (*fun*)
+#### Function
 
 <div className="lang-ref-table">
 |       |         |                                                                                                                        |
 |-------|---------|------------------------------------------------------------------------------------------------------------------------|
-| *fun* | &xrarr; | [*id*](#identifier) [*gargs*](#Generic-argument-list)<sup>opt</sup>                                                    |
-|       | \|      | [*arrow-parameter-list*](#Arrow-parameter-list) [*return-type*](#Return-type)<sup>opt</sup> `=>` [*block*](#Block)     |
-|       | \|      | [*arrow-parameter-list*](#Arrow-parameter-list) [*return-type*](#Return-type)<sup>opt</sup> `=>` [*expr*](#Expression) |
-|       | \|      | `(` [*fun*](#Function) `)`                                                                                             |
+| *fun* | &xrarr; | [*id*](#identifier) [*gargs*](#generic-argument-list)<sup>opt</sup>                                                    |
+|       | \|      | [*arrow-parameter-list*](#arrow-parameter-list) [*return-type*](#return-type)<sup>opt</sup> `=>` [*block*](#block)     |
+|       | \|      | [*arrow-parameter-list*](#arrow-parameter-list) [*return-type*](#return-type)<sup>opt</sup> `=>` [*expr*](#expression) |
+|       | \|      | `(` [*fun*](#function) `)`                                                                                             |
 </div>
 
-#### <a name="Return-type">Return-type</a> (*return-type*)
+#### Return-type
 
 <div className="lang-ref-table">
 |               |         |                     |
 |---------------|---------|---------------------|
-| *return-type* | &xrarr; | `:` [*type*](#Type) |
+| *return-type* | &xrarr; | `:` [*type*](#type) |
 </div>
 
-#### <a name="Optionally-typed-pattern">Optionally-typed-pattern</a> (*optionally-typed-pattern*)
+#### Optionally-typed-pattern
 
 <div className="lang-ref-table">
 |                            |         |                                   |
 |----------------------------|---------|-----------------------------------|
-| *optionally-typed-pattern* | &xrarr; | [*pattern*](#Pattern)             |
-|                            | \|      | [*typed-pattern*](#Typed-pattern) |
+| *optionally-typed-pattern* | &xrarr; | [*pattern*](#pattern)             |
+|                            | \|      | [*typed-pattern*](#typed-pattern) |
 </div>
 
-#### <a name="Const-Binding">Const-Binding</a> (*cbinding*)
+#### Const-Binding
 
 <div className="lang-ref-table">
 |            |         |                                                                                   |
 |------------|---------|-----------------------------------------------------------------------------------|
-| *cbinding* | &xrarr; | [*optionally-typed-pattern*](#Optionally-typed-pattern) `=` [*expr*](#Expression) |
+| *cbinding* | &xrarr; | [*optionally-typed-pattern*](#optionally-typed-pattern) `=` [*expr*](#expression) |
 </div>
 
-#### <a name="Arrow-parameter-list">Arrow-parameter-list</a> (*arrow-parameter-list*)
+#### Arrow-parameter-list
 
 <div className="lang-ref-table">
 |                        |         |                                                                                                                                                     |
 |------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------|
-| *arrow-parameter-list* | &xrarr; | `(` [*optionally-typed-pattern*](#Optionally-typed-pattern) `,` ⋯ `,` [*optionally-typed-pattern*](#Optionally-typed-pattern) `,`<sup>opt</sup> `)` |
+| *arrow-parameter-list* | &xrarr; | `(` [*optionally-typed-pattern*](#optionally-typed-pattern) `,` ⋯ `,` [*optionally-typed-pattern*](#optionally-typed-pattern) `,`<sup>opt</sup> `)` |
 </div>
 
diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 97ca6d50..ec8badfb 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -23,7 +23,7 @@ kinds of program elements:
 - module and import forms for management of namespaces and separate files,
 - declarations of program-defined types,
 - declarations of the data that the contract stores in the public ledger,
-- declarations of *witnesses*, which are callback functions supplied by the TypeScript runner, and
+- declarations of *witnesses*, which are callback functions supplied by the TypeScript runner,
 - definitions of *circuits*, which are functions serving as the operational core of a smart contract, and
 - the definition of at most one *constructor*, which is a function used to intialize the public ledger.
 
@@ -38,7 +38,8 @@ Compact deviates intentionally from TypeScript, however, in several important wa
   Compact as well as preventing external application of a Compact circuit with
   more or fewer than the declared number of arguments.
 - Compact provides namespace management via static rather than dynamic modules, and
-  these modules can be parameterized via compile-time generic parameters, which include size as
+  these modules can be parameterized via compile-time
+  [generic parameters](#generic-parameters-and-arguments), which include size as
   well as type parameters.
 - Because every Compact program must compile into a set of finite proving circuits,
   all Compact types have sizes that are fixed at compile time, loops are bounded either
@@ -56,7 +57,7 @@ Compact deviates intentionally from TypeScript, however, in several important wa
   [Explicit disclosure in Compact](explicit-disclosure).
 
 Like TypeScript, Compact compiles into JavaScript, but it also produces a TypeScript
-definition file so that it effectively also compiles into TypeScript.
+definition file so it effectively also compiles into TypeScript.
 It produces separate TypeScript definition files and JavaScript implementation files
 rather than simply producing TypeScript for three reasons:
 - to allow compiled Compact programs to be used without requiring an additional
@@ -345,7 +346,7 @@ parameters, so any generic argument can pass along the value of a generic type
 or natural-number parameter that is visible at the point of specialization.
 
 The `#` used to distinguish generic natural-number parameters from generic type parameters
-need not and must not used at the point of specialization.
+need not and must not be used at the point of specialization.
 It is a static error, however, if a generic argument supplied for a generic
 parameter is not numeric when a numeric value is expected or is not a type when
 a type is expected.
@@ -1310,7 +1311,6 @@ provided by the TypeScript driver.
 |-------------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | *witness-declaration*   | &xrarr; | `export`<sup>opt</sup> `witness` [*id*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> [*simple-parameter-list*](#declaring-witnesses-for-private-state-management) `:` [*type*](#primitive-types) `;` |
 | *simple-parameter-list* | &xrarr; | `(` [*typed-id*](#structure-types) `,` ⋯ `,` [*typed-id*](#structure-types) `,`<sup>opt</sup> `)`                                                                                                                                     |
-| *typed-id*              | &xrarr; | [*id*](#terminal-names) `:` [*type*](#primitive-types)                                                                                                                                                                                |
 </div>
 
 
@@ -1628,11 +1628,9 @@ in [Circuit and witness calls](#circuit-and-witness-calls).
 Named circuit definitions have the following syntax:
 
 <div className="lang-ref-table">
-|                          |         |                                                                                                                                                                                                                                                           |
-|--------------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *circuit-definition*     | &xrarr; | `export`<sup>opt</sup> `pure`<sup>opt</sup> `circuit` [*function-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> [*pattern-parameter-list*](#contract-constructor) `:` [*type*](#primitive-types) [*block*](#blocks) |
-| *pattern-parameter-list* | &xrarr; | `(` [*typed-pattern*](#contract-constructor) `,` ⋯ `,` [*typed-pattern*](#contract-constructor) `,`<sup>opt</sup> `)`                                                                                                                                     |
-| *typed-pattern*          | &xrarr; | [*pattern*](#patterns-and-destructuring) `:` [*type*](#primitive-types)                                                                                                                                                                                   |
+|                      |         |                                                                                                                                                                                                                                                           |
+|----------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *circuit-definition* | &xrarr; | `export`<sup>opt</sup> `pure`<sup>opt</sup> `circuit` [*function-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> [*pattern-parameter-list*](#contract-constructor) `:` [*type*](#primitive-types) [*block*](#blocks) |
 </div>
 
 
@@ -1798,8 +1796,6 @@ in the syntax specified by the following grammar snippet:
 | *cbinding*                 | &xrarr; | [*optionally-typed-pattern*](#const-statements) `=` [*expr*](#expressions) |
 | *optionally-typed-pattern* | &xrarr; | [*pattern*](#patterns-and-destructuring)                                   |
 |                            | \|      | [*typed-pattern*](#contract-constructor)                                   |
-| *pattern-struct-elt*       | &xrarr; | [*id*](#terminal-names)                                                    |
-|                            | \|      | [*id*](#terminal-names) `:` [*pattern*](#patterns-and-destructuring)       |
 </div>
 
 
@@ -2042,17 +2038,11 @@ The syntax of Compact expressions is summarized by the following grammar snippet
 |                    | \|      | `fold` `(` [*fun*](#circuit-and-witness-calls) `,` [*expr*](#expressions) `,` [*expr*](#expressions) `,` ⋯¹ `,` [*expr*](#expressions) `,`<sup>opt</sup> `)` |
 |                    | \|      | `slice` `<` [*tsize*](#primitive-types) `>` `(` [*expr*](#expressions) `,` [*expr*](#expressions) `)`                                                        |
 |                    | \|      | `[` [*tuple-arg*](#expressions) `,` ⋯ `,` [*tuple-arg*](#expressions) `,`<sup>opt</sup> `]`                                                                  |
-|                    | \|      | `Bytes` `[` [*tuple-arg*](#expressions) `,` ⋯ `,` [*tuple-arg*](#expressions) `,`<sup>opt</sup> `]`                                                          |
+|                    | \|      | `Bytes` `[` [*bytes-arg*](#expressions) `,` ⋯ `,` [*bytes-arg*](#expressions) `,`<sup>opt</sup> `]`                                                          |
 |                    | \|      | [*tref*](#primitive-types) `{` [*struct-arg*](#expressions) `,` ⋯ `,` [*struct-arg*](#expressions) `,`<sup>opt</sup> `}`                                     |
 |                    | \|      | `assert` `(` [*expr*](#expressions) `,` [*str*](#terminal-names) `)`                                                                                         |
 |                    | \|      | `disclose` `(` [*expr*](#expressions) `)`                                                                                                                    |
 |                    | \|      | [*term*](#expressions)                                                                                                                                       |
-| *tuple-arg*        | &xrarr; | [*expr*](#expressions)                                                                                                                                       |
-|                    | \|      | `...` [*expr*](#expressions)                                                                                                                                 |
-| *bytes-arg*        | &xrarr; | [*tuple-arg*](#expressions)                                                                                                                                  |
-| *struct-arg*       | &xrarr; | [*expr*](#expressions)                                                                                                                                       |
-|                    | \|      | [*id*](#terminal-names) `:` [*expr*](#expressions)                                                                                                           |
-|                    | \|      | `...` [*expr*](#expressions)                                                                                                                                 |
 | *term*             | &xrarr; | [*id*](#terminal-names)                                                                                                                                      |
 |                    | \|      | `true`                                                                                                                                                       |
 |                    | \|      | `false`                                                                                                                                                      |
@@ -2061,6 +2051,12 @@ The syntax of Compact expressions is summarized by the following grammar snippet
 |                    | \|      | `pad` `(` [*nat*](#terminal-names) `,` [*str*](#terminal-names) `)`                                                                                          |
 |                    | \|      | `default` `<` [*type*](#primitive-types) `>`                                                                                                                 |
 |                    | \|      | `(` [*expr-seq*](#expressions) `)`                                                                                                                           |
+| *struct-arg*       | &xrarr; | [*expr*](#expressions)                                                                                                                                       |
+|                    | \|      | [*id*](#terminal-names) `:` [*expr*](#expressions)                                                                                                           |
+|                    | \|      | `...` [*expr*](#expressions)                                                                                                                                 |
+| *bytes-arg*        | &xrarr; | [*tuple-arg*](#expressions)                                                                                                                                  |
+| *tuple-arg*        | &xrarr; | [*expr*](#expressions)                                                                                                                                       |
+|                    | \|      | `...` [*expr*](#expressions)                                                                                                                                 |
 </div>
 
 
@@ -2747,21 +2743,14 @@ type of `e` is an enumeration type.
 ### Circuit and witness calls
 
 <div className="lang-ref-table">
-|                            |         |                                                                                                                                                   |
-|----------------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------|
-| *fun*                      | &xrarr; | [*id*](#terminal-names) [*gargs*](#generic-parameters-and-arguments)<sup>opt</sup>                                                                |
-|                            | \|      | [*arrow-parameter-list*](#circuit-and-witness-calls) [*return-type*](#circuit-and-witness-calls)<sup>opt</sup> `=>` [*block*](#blocks)            |
-|                            | \|      | [*arrow-parameter-list*](#circuit-and-witness-calls) [*return-type*](#circuit-and-witness-calls)<sup>opt</sup> `=>` [*expr*](#expressions)        |
-|                            | \|      | `(` [*fun*](#circuit-and-witness-calls) `)`                                                                                                       |
-| *arrow-parameter-list*     | &xrarr; | `(` [*optionally-typed-pattern*](#const-statements) `,` ⋯ `,` [*optionally-typed-pattern*](#const-statements) `,`<sup>opt</sup> `)`               |
-| *optionally-typed-pattern* | &xrarr; | [*pattern*](#patterns-and-destructuring)                                                                                                          |
-|                            | \|      | [*typed-pattern*](#contract-constructor)                                                                                                          |
-| *pattern*                  | &xrarr; | [*id*](#terminal-names)                                                                                                                           |
-|                            | \|      | `[` [*pattern*](#patterns-and-destructuring)<sup>opt</sup> `,` ⋯ `,` [*pattern*](#patterns-and-destructuring)<sup>opt</sup> `,`<sup>opt</sup> `]` |
-|                            | \|      | `{` [*pattern-struct-elt*](#patterns-and-destructuring) `,` ⋯ `,` [*pattern-struct-elt*](#patterns-and-destructuring) `,`<sup>opt</sup> `}`       |
-| *pattern-struct-elt*       | &xrarr; | [*id*](#terminal-names)                                                                                                                           |
-|                            | \|      | [*id*](#terminal-names) `:` [*pattern*](#patterns-and-destructuring)                                                                              |
-| *return-type*              | &xrarr; | `:` [*type*](#primitive-types)                                                                                                                    |
+|                        |         |                                                                                                                                            |
+|------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------|
+| *fun*                  | &xrarr; | [*id*](#terminal-names) [*gargs*](#generic-parameters-and-arguments)<sup>opt</sup>                                                         |
+|                        | \|      | [*arrow-parameter-list*](#circuit-and-witness-calls) [*return-type*](#circuit-and-witness-calls)<sup>opt</sup> `=>` [*block*](#blocks)     |
+|                        | \|      | [*arrow-parameter-list*](#circuit-and-witness-calls) [*return-type*](#circuit-and-witness-calls)<sup>opt</sup> `=>` [*expr*](#expressions) |
+|                        | \|      | `(` [*fun*](#circuit-and-witness-calls) `)`                                                                                                |
+| *arrow-parameter-list* | &xrarr; | `(` [*optionally-typed-pattern*](#const-statements) `,` ⋯ `,` [*optionally-typed-pattern*](#const-statements) `,`<sup>opt</sup> `)`        |
+| *return-type*          | &xrarr; | `:` [*type*](#primitive-types)                                                                                                             |
 </div>
 
 

From 58f6a6c5f0ce6076df189d4c0a97f4ab4c7e3cd7 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Sun, 15 Mar 2026 12:00:02 +0100
Subject: [PATCH 19/41] latest version of lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 490 ++++++++++++++--------------
 1 file changed, 243 insertions(+), 247 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index ec8badfb..93658949 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -2,6 +2,7 @@
 SPDX-License-Identifier: Apache-2.0
 copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 title: Compact reference
+DO NOT EDIT.  This file is automatically generated.
 ---
 
 # Compact reference
@@ -25,7 +26,7 @@ kinds of program elements:
 - declarations of the data that the contract stores in the public ledger,
 - declarations of *witnesses*, which are callback functions supplied by the TypeScript runner,
 - definitions of *circuits*, which are functions serving as the operational core of a smart contract, and
-- the definition of at most one *constructor*, which is a function used to intialize the public ledger.
+- the definition of at most one *constructor*, which is a function used to initialize the public ledger.
 
 Compact is similar to TypeScript: it has a syntax similar to that of JavaScript,
 and it layers a type system over the JavaScript syntax.
@@ -159,7 +160,7 @@ all represent identifier tokens.
 - *version* represents version literals (in pragmas).
 
 While identifiers and string literals are each represented by more than one name,
-each representes the entire set of possible identifier or string-literal tokens.
+each represents the entire set of possible identifier or string-literal tokens.
 The grammar snippets use different terminal names only to suggest their use, e.g,
 *module-name* for module names versus *tvar-name* for type variable names.
 
@@ -172,8 +173,10 @@ for the errors and terminates without generating any output.
 
 The code the compiler generates and the run-time libraries it uses detect various
 kinds of *dynamic errors*, e.g., attempts from code outside of Compact to call
-Compact circuits with wrong numbers or types of arguments.
-These errors are reported when the generated code is run.
+Compact circuits with wrong numbers or types of arguments or attempts to cast
+an unsigned value to an unsigned type that is too small for the value.
+These errors are reported when the generated code is run and cause evaluation
+of the current circuit to halt.
 
 ## Identifiers, bindings, and scope
 
@@ -212,7 +215,7 @@ and/or different numbers or types of run-time parameters.
 
 The scope of each binding depends upon where it appears, as described below.
 (The caveat "except where shadowed" is not explicitly stated but applies in each case.)
-- Identifiers bound at the outermost level of a contract (refered to as the *top
+- Identifiers bound at the outermost level of a contract (referred to as the *top
   level*) are visible throughout the contract, but not within any modules that are
   imported from separate files.
 - Identifiers bound at the outermost level of a module are visible throughout the module.
@@ -258,7 +261,7 @@ For circuit and witness bindings, the lifetime is effectively permanent, i.e.,
 the binding is always available for use whenever the program is run.
 
 The lifetimes of ledger-field bindings begin when they are first initialized
-and are effectively permanant from that point on; although the value of a
+and are effectively permanent from that point on; although the value of a
 field can change over time, the association of the ledger-field name with the
 ledger field's location in the (replicated) public state of a contract never
 changes.
@@ -305,7 +308,7 @@ parameters whose values are given at the use site rather than fixed at the point
 of declaration.
 This allows the same *generic* code to be used with different specific types,
 bounds, and sizes.
-Except where shadowed, generic parameters are visible thoughout the entire entity.
+Except where shadowed, generic parameters are visible throughout the entire entity.
 In particular, the generic parameters of a module are visible within the program
 elements that appear within the body of the module.
 
@@ -313,7 +316,7 @@ When present, generic parameters are enclosed in angle brackets following the
 name of the generic entity (module, structure, type alias, circuit, or witness).
 Each parameter is either a type name (e.g., `T`) or a hash-prefixed natural-number name
 (e.g., `#N`).
-Generic natural-number parameters are prefixed by `#` to distingish them from
+Generic natural-number parameters are prefixed by `#` to distinguish them from
 generic type parameters.
 
 <div className="lang-ref-table">
@@ -1266,7 +1269,7 @@ It is a static error to export any other kind of binding from the top level.
 ## Include files
 
 Compact allows programs and modules to be split into multiple files and spliced
-togther via `include` forms, which have the following syntax, where `file` is a
+together via `include` forms, which have the following syntax, where `file` is a
 string literal specifying a filesystem pathname for file to be included:
 
 <div className="lang-ref-table">
@@ -1439,7 +1442,7 @@ is created to minimize the chance of the transaction being rejected when the
 proof is checked on chain.
 For example, `Counter` increment and decrement do not commit to the current value
 of the counter.
-While the preceding example could be written a Cell instead:
+While the preceding example could be written using a Cell instead:
 
 ```compact
 ledger F: Uint<64>;
@@ -1483,10 +1486,14 @@ export circuit initNestedCounter(b: Boolean, n: Field): [] {
   fld.lookup(b).insert(disclose(n), default<Counter>);
 }
 
-export circuit incrementNestedCounter(b: Boolean, n: Field, k: Uint<16>): [] {
+export circuit incrementNestedCounter1(b: Boolean, n: Field, k: Uint<16>): [] {
   fld.lookup(b).lookup(n).increment(disclose(k));
 }
 
+export circuit incrementNestedCounter2(b: Boolean, n: Field, k: Uint<16>): [] {
+  fld.lookup(b).lookup(n) += disclose(k);
+}
+
 export circuit readNestedCounter1(b: Boolean, n: Field): Uint<64> {
   return fld.lookup(b).lookup(n).read();
 }
@@ -1500,7 +1507,8 @@ In this example,
 - `fld` is bound to a `Map` from `Boolean` values to `Map`s from `Field` values to `Counter`s
 - `initNestedMap` can be used to create the inner `Map` for a particular outer-`Map` key
 - `initNestedCounter` can be used to create a `Counter` for a given outer-`Map` key and a given inner-`Map` key
-- `incrementNestedCounter` can be used to increment an existing `Counter` for a given outer-`Map` key and a given inner-`Map` key
+- either `incrementNestedCounter1` or `incrementNestedCounter2` can be used to increment
+  an existing `Counter` for a given outer-`Map` key and a given inner-`Map` key
 - either `readNestedCounter1` or `readNestedCounter2` can be used to read the value of an existing `Counter`
   for a given outer-`Map` key and a given inner-`Map` key.
 
@@ -1520,11 +1528,16 @@ Notes:
      fld.lookup(b); // ERROR: incomplete chain of indirects
    }
    ```
-4. When the last lookup is a read of a base type one can omit the
-   explicit `read()` indirect, as illustrated by the definitions of
-   `readNestedCounter1` and `readNestedCounter2` above, which have the
+4. When the last operation is a write of a base type, increment of a Counter type,
+   or decrement of a Counter type, one can replace the `write`, `increment`, or
+   `decrement` operation with the `=`, `+=`, or `-=` assignment syntax, as
+   illustrated by `incrementNestedCounter1` and `incrementNestedCounter2`,
+   which have the same behavior.
+5. When the last operation is a read of a Counter or base type one can omit the
+   explicit `read()` indirect, as illustrated by
+   `readNestedCounter1` and `readNestedCounter2`, which have the
    same behavior.
-5. For convenience, local variables can hold default values of ledger-state types,
+6. For convenience, local variables can hold default values of ledger-state types,
    so the following definition of `initNestedMap` is equivalent to the one
    above.
    ```compact
@@ -1607,15 +1620,15 @@ constructor(v: Field) {
 Each constructor parameter must be explicitly typed.
 The type of each variable binding arising from the binding of identifiers in
 each parameter pattern to the corresponding pieces of the input is the type of
-the corresonding part of the declared type's structure.
+the corresponding part of the declared type's structure.
 
 The return type of the constructor is always `[]`.
-Any attempt to return another type of value using `return expression;` where the
-type of `expression` is something other than `[]`, is a static error.
+Any attempt to return another type of value using `return` *expr*`;` where the
+type of *expr* is something other than `[]`, is a static error.
 
 ## Circuit definitions
 
-The basic operational element in Compact is the `circuit`.
+The basic operational element in Compact is the *circuit*.
 This corresponds closely to a function in most languages but is designed
 to be compilable into a zero-knowledge circuit.
 The key limitation of circuits relative to functions in most languages is
@@ -1634,7 +1647,7 @@ Named circuit definitions have the following syntax:
 </div>
 
 
-A circuit definition binds `function-name` to a circuit with the given parameters,
+A circuit definition binds *function-name* to a circuit with the given parameters,
 type, and body.
 The optional `export` modifier indicates that the circuit binding should
 be exported from the enclosing module or the program itself, if the circuit
@@ -1642,7 +1655,7 @@ is defined outside of any module.
 The optional `pure` modifier indicates that the
 [circuit is pure](#pure-and-impure-circuits).
 
-If any generic parameters are present (`gparams` is present and is nonempty),
+If any generic parameters are present (*gparams* is present and is nonempty),
 the circuit is [generic][#generic-parameters-and-arguments] and must be specialized
 (provided with generic arguments) at the point of call.
 
@@ -1652,13 +1665,13 @@ to be bound to selected pieces of the argument values.
 In the simplest case, a pattern is just an identifier and is bound to the argument
 value as a whole.
 The bindings established by the parameters are visible within (and only within)
-the `block` that constitutes the body of the circuit.
+the *block* that constitutes the body of the circuit.
 Each parameter must be explicitly typed, and at the point of every call to the
 circuit, the type of the corresponding argument expression must be a subtype of
 that type.
 The type of each variable binding arising from the binding of identifiers in
 each parameter pattern to the corresponding pieces of the input is the type of
-the corresonding part of the declared type's structure.
+the corresponding part of the declared type's structure.
 For example, in the body of `sumStruct` below:
 
 ```compact
@@ -1675,7 +1688,7 @@ Every named circuit's return type must be explicitly declared, and it is a
 static error if the circuit can return a value that is not a subtype of that
 type.
 
-The body is evaluated each time the circuit it is called.
+The body is evaluated each time the circuit is called.
 
 ### Pure and impure circuits
 
@@ -1706,7 +1719,7 @@ Compact program by the Compact compiler.
 
 ## Blocks
 
-A `block` is a group of statements enclosed in braces:
+A *block* is a group of statements enclosed in braces:
 
 <div className="lang-ref-table">
 |         |         |                                                       |
@@ -1717,14 +1730,14 @@ A `block` is a group of statements enclosed in braces:
 
 A block can be used in place of a single statement anywhere a single statement
 is allowed, which is useful for allowing multiple statements to be evaluated by the
-`then` and `else` parts of an `if` statement or the body of a `for`.
+"then" and "else" parts of an `if` statement or the body of a `for` statement.
 
 The body of every circuit definition and the body of the constructor, if any,
 is always a block.
 The right-hand side of the arrow in an anonymous circuit can be either a block
 or an expression.
 
-The statements within a block occupy a nested scope: `const` bindings created by
+The statements within a block occupy a nested scope: variable bindings created by
 `const` statements within the block are not visible outside the block, and they can
 shadow identifier bindings with the same names that exist outside the block.
 
@@ -1753,42 +1766,39 @@ The syntax of Compact statements is summarized by the following grammar snippet:
 
 
 The snippet shows that a statement (`stmt`) is either a one-armed `if` expression
-or some other kinf of statement (`stmt0`).
-This structure is used to enforce the restriction that the *then* part of a
+or some other kind of statement (`stmt0`).
+This structure is used to enforce the restriction that the "then" part of a
 two-armed cannot be a one-armed `if` expression.
-This is often left ambiguous in the grammar, with a separate note to say
-that the ambiguity is resolved by assocating an *else* part with the closest
+This is often left ambiguous in a language grammar, with a separate note to say
+that the ambiguity is resolved by associating each "else" part with the closest
 enclosing `if` expression, but we prefer to make the constraint explicit in
 the grammar and avoid any ambiguity.
 
 The first kind of `stmt0` is `expr-seq`.
 An `expr-seq`, or *expression sequence*, is a comma separated sequence of one
 or more expressions to be evaluated in sequence.
-This simply means that any expression or comma-separated sequence also qualifies
-as a statement.
+This simply means that any expression or comma-separated sequence of expressions
+also qualifies as a statement.
 Expression sequences are described more fully in
-(their own section)[expression-sequences].
+[their own section](#expression-sequences).
 
 The remaining subsections of this section describe each of the other kinds of
-statement.
+statements.
 
 Statements either do not have a value or (in the case of expression sequences
-serving as statements) their value is ignored.
+serving as statements) the type and value are ignored.
 Thus it is not necessary to talk about the type of a statement.
 Nevertheless, each statement has typing rules that must be followed, such as that
-the type of the test expression of an `if` expression must be `Boolean`.
+the type of the test expression of an `if` statement must be `Boolean`.
 
 ### `const` statements
 
 `const` statements create local variable bindings.
 Every `const` statement takes the following form:
 
-```compact
-const cbindings
-```
+`const` *cbinding* `,` ⋯¹ `,` *cbinding*  `;`
 
-where `cbindings` is a comma-separated sequence of one or more `cbinding` subforms
-in the syntax specified by the following grammar snippet:
+where each *cbinding* takes the following form:
 
 <div className="lang-ref-table">
 |                            |         |                                                                            |
@@ -1799,18 +1809,18 @@ in the syntax specified by the following grammar snippet:
 </div>
 
 
-A `const` statement is typed by typing each of its `cbinding` subforms.
-A `cbinding` subform is typed by typing the expression on the right-hand side
+A `const` statement is typed by typing each of its *cbinding* subforms.
+A *cbinding* subform is typed by typing the expression on the right-hand side
 of the `=`.
-If a type `T` is included on the left-hand side, the type of the expression
-must be a subtype of `T`, otherwise it is a static error.
+If a type *T* is declared on the left-hand side, the type of the expression
+must be a subtype of *T*, otherwise it is a static error.
 It is also a static error if the pattern implies a different structure from
 the type of the expression.
 For example, it is a static error if the pattern implies that the expression's
 value is a tuple when the type is actually, say, `Field`.
 
 The type of each variable binding arising from the binding of identifiers in each
-pattern to the corresponding pieces of the input is the type of the corresonding
+pattern to the corresponding pieces of the input is the type of the corresponding
 part of the structure of the declared type, if present, otherwise of the inferred
 type.
 For example, in the following code, the binding for `x` has type `Boolean`, and
@@ -1850,7 +1860,7 @@ circuit foo(a: Uint<16>): Field {
 }
 ```
 
-Similarly, the reference to `x` in the first `cbinding` of the `const`
+Similarly, the reference to `x` in the first *cbinding* of the `const`
 statement below is also a static error.
 
 ```compact
@@ -1858,57 +1868,49 @@ const y = x, x = 7;
 }
 ```
 
-A `const` statement is evaluated by evaluating the `cbinding` subforms in order
-so that the variables given values by each `cbinding` is available to the
-cbindings that follow.
+A `const` statement is evaluated by evaluating the *cbinding* subforms in order
+so that the variables given values by each *cbinding* are available to be
+referenced by the cbindings that follow.
 
-The evaluation of each `cbinding` involves evaluating the expression
-on the right-hand side of the `=` and then giving values to identifiers
-in the pattern `p` on the left-hand side to the value `v` of the
-expression as described earlier in
-(Patterns and destructuring)[patterns-and-destructuring].
+The evaluation of each *cbinding* involves determining the value *v* of the
+expression on the right-hand side of the `=`, then giving values to identifiers
+in the pattern *p* on the left-hand side to the corresponding pieces of *v*
+as described earlier in [Patterns and destructuring](#patterns-and-destructuring).
 
 Any variable bound by `const` may not be reused within a block, although a
 `const` binding in a nested block might [shadow it](#identifiers-bindings-and-scope).
 Variables are immutable, although the same variable might take on different values
-at different times if is contined within a block of code that is evaluated more
-than once, such as would be the case for the body of a `circuit` that is called
+at different times if is contained within a block of code that is evaluated more
+than once, such as would be the case for the body of a circuit that is called
 more than once.
 
 ### `if` statements
 
 An `if` statement is used to determine the flow of control through the
 statements of a circuit or constructor body.
-A *one-armed* `if` expression has a *test part* (an `expr-seq` enclosed
-in parentheses) and a *then part* (`then-statement`):
+A *one-armed* `if` expression has a "test part" (an *expr-seq* enclosed
+in parentheses) and a "then part" (*then-statement*):
 
-```compact
-if (expr-seq) then-statement
-```
+`if (`*expr-seq*`)` *then-statement*
 
-A *two-armed* `if` expression has a *test part* (an `expr-seq` enclosed
-in parentheses), a *then part* (`then-statement`), and an *else part*
-(`else-statement`):
+A *two-armed* `if` statement has a test part, a then part, and an "else part"
+(*else-statement*):
 
-```compact
-if (expr-seq)
-  then-statement
-else
-  else-statement
-```
+`if (`*expr-seq*`)` *then-statement* `else` *else-statement*
 
-The typing of an `if` expression requires only that the type of `expr-seq` must be
+The typing of an `if` statement requires only that the type of *expr-seq* must be
 `Boolean`.
 
-Evaluating an `if` expression involves first evaluating the `expr-seq`.
-If it evaluates to `true`, `then-statement` is evaluated.
-Otherwise, it must evaluate to `false`, in which case `else-statement`
+Evaluating an `if` expression involves first determining the value *v* of
+*expr-seq*.
+If *v* is `true`, *then-statement* is evaluated.
+Otherwise, *v* must be `false`, in which case *else-statement*
 (if present), is evaluated.
 
 ### `for` statements
 
 `for` statements are used to iterate over a sequence of values.
-In Compact, in constrast to most languages, the number of iterations can
+In Compact, in contrast to most languages, the number of iterations can
 always be determined at compile time.
 That is, the number of iterations is bounded either by constant numeric
 bounds or by size of an object of constant size.
@@ -1919,60 +1921,53 @@ Compact supports two kinds of `for` statements.
 The first iterates over vectors, tuples, and byte-vectors and takes the
 following form:
 
-```compact
-for (const x of expression) statement
-```
+`for (const` *x* `of` *expr*`)` *stmt*
 
-This kind of `for` statement is typed by typing `expression` and verifying that
-it is a `Vector` type, a tuple type that (has a vector type)[Subtyping and least
-upper bounds], or a `Bytes` type.
+This kind of `for` statement is typed by typing *expr* and verifying that
+it is a `Vector` type, a tuple type that
+[has a vector type](#subtyping-and-least-upper-bounds), or a `Bytes` type.
 
-Evaluating this kind of `for` requires evaluating `expression` then evaluating
-`statement` once for each element with `x` bound to the value of each element
-in turn.
+Evaluating this kind of `for` requires determining the vector, tuple, or
+byte-vector value *v* of *expr* then evaluating
+*stmt* once for each element of *v* with *x* bound to the value of each element
+of *v* in turn.
 
 The second form iterates over a range of unsigned integer values and takes the
 following form:
 
-```compact
-for (const i of start..end) statement
-```
+`for (const` *i* `of` *start* `..` *end*`)` *stmt*
 
-In this form, each of `start` and `end` must be a literal unsigned integer
-or a generic natural-number parameter, and `end` must be greater than or
-equal to `start`.
+In this form, each of *start* and *end* must be a literal unsigned integer
+or reference to a generic natural-number parameter, and *end* must be
+greater than or equal to *start*.
 Otherwise, it is a static error.
 
 This form is always well-typed.
 
-Evaluating this kind of `for` requires evaluating statement with `i` bound
-to *k* for each *k* in the range `start` (inclusive) to `end` (exclusive).
+Evaluating this kind of `for` requires evaluating *stmt* with *i* bound
+to *k* for each *k* in the range *start* (inclusive) to *end* (exclusive).
 
 `return` statements cannot be used to return from within `for` statements.
-It is therefore a static error for `statement` to be a `return` statement
-or for a `return` statement to appear within `statement` (except where it
-appears nested within an anoymous circuit).
+It is therefore a static error for *stmt* to be a `return` statement
+or for a `return` statement to appear within *stmt* (except where it
+appears nested within an anonymous circuit).
 
 Iteration can also be accomplished via
-(`map` and `fold` expressions)[map-and-fold-expressions].
+[`map` and `fold` expressions](#map-and-fold-expressions).
 
 ### `return` statements
 
 A `return` statement can be used to exit from the closest enclosing
-[anonymous circuit](#circuit-and-witness-calls) circuit, if any, or otherwise from
+[anonymous circuit](#circuit-and-witness-calls), if any, or otherwise from
 the enclosing constructor or named circuit, and to return to the caller either
-an explicit return value, i.e., the value of (`expr-seq`)[expression-sequences]
+an explicit return value, i.e., the value of [`expr-seq`](#expression-sequences)
 in this form of `return`:
 
-```compact
-return expr-seq;
-```
+`return` *expr-seq*`;`
 
 or the default value `[]` in this form of `return`:
 
-```compact
-return;
-```
+`return;`
 
 A circuit or constructor body can also exit without an explicit `return` statement:
 any path through the body that does not end in an explicit `return` statement is
@@ -1980,8 +1975,8 @@ treated as if ended with `return;`.
 
 A `return` statement is always well-typed if it exits from an anonymous circuit
 without a declared return type.
-Otherwise, a `return` statement is well-typed if the type of `expr-seq`, or
-`[]` if no `expr-seq` is present, is a subtype the expected return type.
+Otherwise, a `return` statement is well-typed if the type of *expr-seq*, or
+`[]` if no *expr-seq* is present, is a subtype the expected return type.
 If the `return` form exits from a named circuit or an anonymous circuit
 with a declared return type, the expected type is the declared return type,
 while if it exits from the constructor, the expected return type is `[]`.
@@ -1989,10 +1984,10 @@ while if it exits from the constructor, the expected return type is `[]`.
 An implication of these rules is that it is a static error to exit without an
 explicit return value from a circuit with a declared return type other than `[]`.
 
-When a `return` statement is evaluated, the `expr-seq`, if present, is evaluated,
+When a `return` statement is evaluated, the *expr-seq*, if present, is evaluated,
 the circuit or constructor exits immediately without evaluating any
-subsequent statements, and it returns to the caller the value of `expr-seq` or
-`[]` if no `expr-seq` is present.
+subsequent statements, and it returns to the caller the value of *expr-seq* or
+`[]` if no *expr-seq* is present.
 
 ## Expressions
 
@@ -2067,51 +2062,51 @@ error: the Compact compiler reports the error and does not produce any target co
 The static type of a well-typed expression is either a Compact type or a
 ledger-state type.
 
-Every Compact expression either evaluates to a value or raises an exception,
-and it might have have an effect.
+Every well-typed Compact expression either evaluates to a value or causes a
+dynamic error, and it might have effects.
 The evaluation of an expression is defined in terms of the evaluation of its
 subexpressions.
-If the evaluation of a subexpression raises an exception, then the evaluation of
-the containing expression halts and raises the same exception.
 
 The first section below discusses how the grammar reflects the rules
 for precedence and associativity of operators, and the remaining sections
 describe the typing and evaluation rules for each kind of expression.
 
-
 ### Precedence and associativity
 
 The structure of the expression grammar unambiguously reflects the precedence
 and associativity of operators.
 
-Each subscripted nonterminal `expr_n` represents a precedence level, with higher
-subscripts representing higher levels of precedence.
-For example, `expr_6` (multiplication) binds more tightly than `expr_5` (addition)
-because the grammar permits the operands of an addition expression to be
-multiplication expressions, but not vice versa.
+Each group from *expr-seq* through *term* represents a precedence level,
+with *expr-seq* at a higher precedence level than *expr*, *expr* at a higher level
+than *expr<sub>0</sub>*, and so on.
+For example, *expr<sub>6</sub>* (multiplication) is at a higher precedence level
+and so binds more tightly than *expr<sub>5</sub>* (addition) because the grammar
+permits the operands of an addition expression to be multiplication expressions,
+but not vice versa.
 For example, `x * y + z` is parsed as the addition of `x * y` and `z`
-rather than the multiplication of `x` and `y + z`, because the `expr_5` production
-for addition is not reachable from the `expr_6` production for multiplication.
-One can still write `x * (y + z)` because an `expr_6` can be a `term` (via the
-"fall through" productions `expr_6 → expr_7`, `expr_7 → expr_8`, and so on),
-and a term can be a parenthesized `expr-seq`.
-
-The grammar enforces associativity by allowing either the left or right
-operand of an operator to be at the same precedence level while requiring
-the other to be at a higher level.
-Specifically, left-associativity is expressed by allowing the left operand to be
-at the same level while requring the right operand to be at a higher level.
-For instance, `expr_5 → expr_5 + expr_6` enforces the left-associativity of
-addition, since the left operand can be at the same level while the right
-operand is at a higher level.
-This means that `x + y - z` can be treated only as the subtraction of `z`
+rather than the multiplication of `x` and `y + z`, because the *expr<sub>5</sub>*
+production for addition is not reachable from the *expr<sub>6</sub>* production
+for multiplication.
+One can still write `x * (y + z)` because an *expr<sub>6</sub>* can be a *term* (via the
+"fall through" productions *expr<sub>6</sub>* &xrarr; *expr<sub>7</sub>*,
+*expr<sub>7</sub>* &xrarr; *expr<sub>8</sub>*, and so on),
+a *term* can be a parenthesized *expr-seq*, and an *expr-seq* can be an *expr*.
+
+The grammar enforces associativity by requiring the left or right
+operand of an operator or both to be at a higher precedence level.
+Specifically, left-associativity is expressed by requiring the right operand to
+be at a higher level while allowing the left operand to be at the same level.
+For instance, *expr<sub>5</sub>* &xrarr; *expr<sub>5</sub>* `+` *expr<sub>6</sub>*
+enforces the left-associativity of addition, since the left operand must be at
+a higher level.
+This means, for example, that `x + y - z` can be treated only as the subtraction of `z`
 from `x + y` rather than as the addition of `x` and `y - z`.
 Right-associativity is expressed in the opposite manner, e.g.,
-`expr_0 ? expr : expr` enforces the right-associativity of the
+*expr<sub>0</sub>* `?` *expr* `:` *expr* enforces the right-associativity of the
 ternary `?:` operator.
-Non-associative operators such as the relational operators `<`, `<=`, `>=`, `>` have
-both operands at a strictly higher level (`expr_4` on both sides of `expr_3`),
-preventing chaining like `a < b < c`.
+Non-associative operators such as the relational operators `<`, `<=`, `>=`, and
+`>` require both operands to be at a strictly higher level (*expr<sub>4</sub>*
+on both sides of *expr<sub>3</sub>*), preventing chaining like `a < b < c`.
 
 The middle operand of the ternary `?:` operator plays no roll in determining
 precedence and associativity and can be any kind of expression.
@@ -2124,37 +2119,34 @@ expression where it can be confused as an operand of some other operator.
 
 ### Parenthesized expressions
 
-Compact allows parenthesized expressions of the form `(e)`, where `e` is an
-expression.
-They can be used to control the order of operations or simply to make the default
-order of operations to be explicit.
+Compact allows parenthesized expressions of the form `(`*e*`)`, where
+*e* is an expression or, more generally, an expression sequence.
+Parenthesized expressions can be used to control the order of operations or simply
+to make the default order of operations explicit.
 
 For example, `x + y * z` computes the product of `y` and `z` and adds `x` to the
 result, because `*` has higher precedence than `+`.
 `x + (y * z)` computes the same thing but more makes the order of operations more
 clear, while `(x + y) * z` computes the sum of `x` and `y` and multiplies it by `z`.
 
-The type of a parenthesized expression is the type of the embedded expression,
-and its value is the value of the subexpression.
+The type of a parenthesized expression is the type of the embedded expression
+sequence, and its value is the value of the subexpression.
 
 ### Expression sequences
 
-An expression sequence (`expr-seq` in the grammar above) is a comma-separated
+An expression sequence (*expr-seq* in the grammar above) is a comma-separated
 sequence of one or more expressions.
 
-```compact
-expression, ⋯, expression
-```
+*expr*`,` ⋯`,` *expr*
 
 Expression sequences can appear only in a few contexts.
 When an expression sequence is required in a context where only a single expression
 is permitted, the expression sequence can be wrapped in parentheses:
 
-```compact
-(expression, ⋯, expression)
-```
+`(`*expr*`,` ⋯`,` *expr*`)`
 
 The type of an expression sequence is the type of its last subexpression.
+The types of the other subexpressions are ignored and are not constrained in any way.
 
 An expression sequence is evaluated by evaluating the subexpressions from
 left to right, and its value is the value of the last subexpression.
@@ -2205,18 +2197,18 @@ circuit foo(): Uint<16> {
 This is treated exactly as if the numeric literal appeared in place of the
 reference to `N` in the source code of the program.
 
-It is a static error if the number `n` denoted by a numeric literal exceeds the
+It is a static error if the number *n* denoted by a numeric literal exceeds the
 maximum unsigned value and the maximum field value.
 
-If `n` does not exceed the maximum representable unsigned value, the literal's
-type is `Uint<0..k>`, `k = n + 1`, and its value is the unsigned integer `n`.
+If *n* does not exceed the maximum representable unsigned value, the literal's
+type is `Uint<0..`*k*`>`, *k* `=` *n*+1, and its value is the unsigned integer *n*.
 
-If `n` exceeds the maximum representable unsigned value but not the
+If *n* exceeds the maximum representable unsigned value but not the
 maximum representable field value, the literal must be directly cast to
-`Field`, i.e., `<numeric literal> as Field`.
+`Field`, i.e., *n* `as Field`.
 Otherwise it is a static error.
-The type of `<numeric literal> as Field` is `Field`, and its value is the
-field value `n`.
+The type of *n* `as Field` is `Field`, and its value is the
+field value *n*.
 
 __String literals__ can be either simple string literals or `pad` expressions.
 String literals produce byte vectors; Compact has no dedicated String type.
@@ -2224,53 +2216,46 @@ String literals produce byte vectors; Compact has no dedicated String type.
 Simple string literals use TypeScript string literal syntax.
 They can be enclosed in either single (`'`) or double (`"`) quotes, and they can
 contain escaped characters.
-The length `n` of a simple string literal is the length of its UTF-8 encoding.
-The static type of a string literal is `Bytes<n>`, and its value is a
-byte vector containing its UTF-8 encoding.
+The length *n* of a simple string literal is the length of its UTF-8 encoding.
+The static type of a string literal of length *n* is `Bytes<`*n*`>`, and its
+value is a byte vector containing its UTF-8 encoding.
 
-A `pad` expression `pad(n, s)` is also a string literal, where `pad` is a reserved
-word, `n` is a natural number literal, and `s` is a simple string literal whose
-length must be less than or equal to `n`.
-The static type of a padded string literal `pad(n, s)` is `Bytes<n>`, and its
-value is a byte vector containing the UTF-8 encoding of `s` followed by `0`
-bytes up to the padded length `n`.
+A `pad` expression `pad(`*n*`,` *s*`)` is also a string literal, where `pad` is a reserved
+word, *n* is a natural number literal, and *s* is a simple string literal whose
+length must be less than or equal to *n*.
+The static type of a padded string literal `pad(`*n*`,` *s*`)` is `Bytes<`*n*`>`, and its
+value is a byte vector containing the UTF-8 encoding of *s* followed by `0`
+bytes up to the padded length *n*.
 
 ### Default values of a type
 
-Every Compact type and ledger-state type has a default value.
-
-The expression `default<T>`, where `T` is a Compact type or a ledger-state type,
-has static type `T`. It evaluates to the default value of that type.
-
-Note that default value expressions can have ledger-state types.
-
-Every type in Compact has a *default value* of that type.  The default values
-are as follows:
+The expression `default<`*T*`>`, where *T* is a Compact type or a ledger-state type,
+has static type *T* and evaluates to the default value of that type as follows:
 
 - `Boolean`: the value of the literal `false`
-- `Uint<0..n>` and `Uint<n>`: `0`
+- `Uint<0..`*n*`>` and `Uint<`*n*`>`: `0`
 - `Field`: `0`
-- `[T, `⋯`]` where `T`, ⋯ is a sequence of zero or more types: the tuple with
-  the corresponding length, each of the default value of the corresponding type
-- `Bytes<n>`: the byte vector of length `n` with all zero bytes
-- `Opaque<"string">`: an empty string, i.e., `""`
-- `Opaque<"Uint8Array">`: a zero-length `Uint8Array`, i.e., `new Uint8Array(0)`
-- structure types: the struct with all fields set to the default value of their
-  type
-- enumeration types: the first value listed in the declaration
+- `[`*T<sub>1</sub>*`, `⋯`, `*T<sub>n</sub>*`]`: a tuple with *n* elements,
+  each of which is the default value of the corresponding type *T<sub>i</sub>*
+- `Vector<`*n*`, `*T*`>`: a vector with *n* elements, each of which is
+  the default value of type *T*.
+- `Bytes<`*n*`>`: a byte vector of length *n*, each element of which is `0`.
+- `Opaque<"string">`: a zero-length string
+- `Opaque<"Uint8Array">`: a zero-length `Uint8Array`
+- Structure types: a struct with each element set to the default value of its type
+- Enumeration types: the value of *E*`.`*id* where *E* is the name of the enumeration
+  type and *id* is the first element
 - alias types: the default value of the underlying type
-- `Counter`: `0`
-- `Set<T>`, for any Compact type `T`: an empty set
-- `Map<K, T>`, for any Compact types `K` and `T`: an empty map
-- `Map<K, V>`, for any Compact type `K` and ledger-state type `V`: an empty map
-- `List<T>`, for any Compact type `T`: an empty list
-- `MerkleTree<n, T>`, for a compile time integer `1 < n <= 32`, and any Compact
-  type `T`: an empty Merkle tree
-- `HistoricMerkleTree<n, T>`, for a compile time integer `1 < n <= 32`, and any
-  Compact type `T`: an empty Merkle tree
+- `Counter`: a Counter initialized to `0`
+- `Set<`*T*`>`: an empty Set
+- `Map<`*K*`, `*T*`>`: an empty Map
+- `List<`*T*`>`: an empty List
+- `MerkleTree<`*n*`, `*T*`>`: an empty Merkle tree
+- `HistoricMerkleTree<`*n*`, `*T*`>`: an empty historic Merkle tree
 
-Default is not ddefined for contract types and `Kernel` type (which is defined
-in `CompactStandardLibrary`).
+Default values are not defined for contract types or the `CompactStandardLibrary`
+`Kernel` type, so it is a static error if *T* in `default<`*T*`>` is one of
+these types.
 
 ### Variable references
 
@@ -2282,88 +2267,99 @@ Each call to a circuit (or constructor) associates a new set of values with each
 variable bound by the circuit's (or constructor's) parameters, and each block
 in the circuit (or constructor) associates a new set of values with each of the
 `const` bindings created within the block.
-The value of each variable reference is the value associated with the variable
-by the current activation.
+The value of each variable reference is the value currently associated with the
+variable.
 
 ### Conditional expressions
 
-Compact supports conditional expressions of the form `e0 ? e1 : e2` where `e0`,
-`e1`, and `e2` are expressions.
+Compact supports conditional expressions of the form
 
-Conditional expressions require the type of `e0` to be `Boolean`.  The types of
-`e1` and `e2` must be in the subtype relation.  That is, the type of
-`e1` is a subtype of the type of `e2` or the type of `e2` is a subtype of
-the type of `e1`.
+*e<sub>0</sub>* `?` *e<sub>1</sub>* `:` *e<sub>2</sub>*
 
-The type of the entire expression is the type of `e2` if `e1` is a subtype of
-`e2` and the type of `e1` if `e2` is a subtype of `e1`.
+where *e<sub>0</sub>*, *e<sub>1</sub>*, and *e<sub>2</sub>* are expressions.
 
-Conditional expressions are evaluated by first evaluating `e0`.  Then, the
-value of that expression determines which of the other subexpressions is
+The type of *e<sub>0</sub>* must be `Boolean`.
+The types of *e<sub>1</sub>* and *e<sub>2</sub>* must be related.
+That is, the type of *e<sub>1</sub>* must be a subtype of the type of *e<sub>2</sub>*,
+or the type of *e<sub>2</sub>* must be a subtype of the type of *e<sub>1</sub>*.
+
+The type of the entire expression is the type of *e<sub>2</sub>* if *e<sub>1</sub>*
+is a subtype of *e<sub>2</sub>* and the type of *e<sub>1</sub>* if *e<sub>2</sub>*
+is a subtype of *e<sub>1</sub>*.
+
+Conditional expressions are evaluated by first evaluating *e<sub>0</sub>*.
+The value *v* of that expression determines which of the other subexpressions is
 evaluated:
 
-- if the value of `e0` is `true`, then `e1` is evaluated and its value is the
+- if *v* is `true`, then *e<sub>1</sub>* is evaluated and its value is the
   value of the entire expression
-- if the value of `e0` is `false`, then `e2` is evaluated and its value is the
+- if *v* is `false`, then *e<sub>2</sub>* is evaluated and its value is the
   value of the entire expression
 
-The evaluation rules ensure that only one of `e1` and `e2` is evaluated.
+The evaluation rules ensure that only one of *e<sub>1</sub>* and *e<sub>2</sub>*
+is evaluated.
 
 ### Relational comparison expressions
 
-Relational comparison expressions are of the form `e0 op e1` where `e0`
-and `e1` are expressions and `op` is one of Compact's relational operators.
+Relational comparison expressions take the form *e<sub>0</sub>* `op` *e<sub>1</sub>*
+where *e<sub>0</sub>* and *e<sub>1</sub>* are expressions and `op` is one of
+Compact's relational operators.
 The relational operators are **equals** (`==`), **not equals** (`!=`), **less
 than** (`<`), **greater than** (`>`), **less than or equals** (`<=`), and
 **greater than or equals** (`>=`).
 
-Equals and not equals require the types of the subexpressions to be in the
-subtype relation.
-That is, the type of the first subexpression must be a subtype of the type of
-the second subexpression, or the type of the second subexpression must be
-a subtype of the type of the first subexpression.
+Equals and not equals require the types of *e<sub>1</sub>* and *e<sub>2</sub>*
+to be related.
+That is, the type of *e<sub>1</sub>* must be a subtype of the type of *e<sub>2</sub>*,
+or the type of *e<sub>2</sub>* must be a subtype of the type of *e<sub>1</sub>*.
 
 Less than, greater than, less than or equals, and greater than or equals require
-the type of both subexpressions to be unsigned integer types.  (Values of type
-`Field` cannot be compared with these operators.)
+the types of *e<sub>1</sub>* and *e<sub>2</sub>* to be unsigned integer types.
+(Values of type `Field` cannot be compared with these operators.)
 
 The type of the result is `Boolean`.
 
-Relational comparison expressions are evaluated by evaluating the subexpressions
-in order from left to right.
-Then the comparison is performed as described below.
+A relational comparison expression *e<sub>0</sub>* `op` *e<sub>1</sub>* is
+evaluated by evaluating *e<sub>0</sub>*, then evaluating *e<sub>1</sub>*, then
+comparing the resulting values as described below.
 
 **Equals and not equals**
 
 Equality depends on the types of the operands according to the following rules.
-The rules implicitly do not and need not cover cases where one operand is not a
-subtype of the other.
+The rules need not and therefore do not cover cases where one operand is not a subtype of
+the other.
 For example, if one operand has type `Boolean`, so does the other; if one
 operand has a `Bytes` type of length `n`, so does the other; and if one
 has a specific structure type, so does the other.
 
 - **`Boolean` == `Boolean`:**
-  The values are equal if both are `true` or both are `false`.
+  the values are equal if both are `true` or both are `false`.
 - **`Uint` or `Field` == `Uint` or `Field`:**
-  The values are equal if the integer values are equal.
-- **`Bytes`**
-  The values are equal if the corresponding bytes at each index are equal.
+  the values are equal if the integer values are equal.
+- **`Bytes`:**
+  the values are equal if the corresponding bytes at each index are equal.
 - **`Tuple` and `Vector`:**
-  The values are equal if the corresponding values at each index are equal.
+  the values are equal if the corresponding values at each index are equal.
 - **Structure types:**
-  The values are equal if the corresponding members are equal.
+  the values are equal if the corresponding members are equal.
 - **Enumeration types:**
-  The values are equal if they are the same enumeration member.
+  the values are equal if they are the same enumeration member.
 - **`Opaque types:`**
-  The values are equal if the runtime values are equal according to JavaScript's
-  strict equalty (`===`) operator.
+  the values are equal if the runtime values are equal according to JavaScript's
+  strict equality (`===`) operator.
+
+Otherwise the values are not equal.
 
-Otherwise the operands are not equal.
+For *equal*, the relational comparison expression evaluates to `true` if the
+values are equal; otherwise it evaluates to `false`.
+Likewise, for *not equals*, the relational comparison expression evaluates to
+`false` if the values are equal; otherwise it evaluates to `true`.
 
 **Less than, greater than, less than or equals, and greater than or equals**
 
-The unsigned integer values of the operands are compared according to the
-corredponding relational operation.
+The values are compared according to the corresponding relational operation.
+The relational comparison expression evaluates to `true` if the relation holds;
+otherwise it evaluates to `false`.
 
 ### Short-circuit logical expressions
 
@@ -2468,7 +2464,7 @@ circuit foo(x: Feet, y: Feet, scale: Uint<32>): Feet {
 }
 ```
 
-computes the sum of `x` and `y` multipled by `scale`.
+computes the sum of `x` and `y` multiplied by `scale`.
 If the value of this computation fits in 32 bits, `foo` returns the value.
 Otherwise, the enclosing top-level circuit or constructor halts with a
 message indicating that the cast of the value to `Feet` failed.
@@ -2827,9 +2823,9 @@ Type checking a function call depends on the form of the underlying function.
   - If there is no type annotation for a parameter, the parameter's type is
     inferred as the type of the corresponding argument expression.
 
-  Within the body of the anoymous circuit, the type of each variable binding arising
+  Within the body of the anonymous circuit, the type of each variable binding arising
   from the binding of identifiers in each parameter pattern to the corresponding
-  pieces of the corresponding argument is the type of the corresonding part of
+  pieces of the corresponding argument is the type of the corresponding part of
   the structure of the declared or inferred parameter type.
 
   If there is a return type annotation, it is a static error if the body can
@@ -2961,7 +2957,7 @@ Any cast not covered by one of the rules is not allowed.
 
 #### Upcasts
 
-- Upcasts, i.e., casts from a type to a (supertype)[subtyping-and-least-upper-bounds]
+- Upcasts, i.e., casts from a type to a [supertype](#subtyping-and-least-upper-bounds)
   (e.g., from `Vector<3, Uint<8>>` to `Vector<3, Uint<16>>`), are always allowed
   (but never required), never result in run-time errors, and, except in the case
   where the type and the supertype are the same, might require run-time conversions.
@@ -3157,12 +3153,12 @@ is the exception.
 The mechanism for explicitly declaring disclosure is simple: disclosure of private
 data (exported circuit arguments, witness return values, and anything derived from
 private data) must be acknowledged by wrapping an expression whose value contains
-private data in a `disclose()` wrapper before storing it in the public state, returing
+private data in a `disclose()` wrapper before storing it in the public state, returning
 it from an exported circuit, or using it in conditional expressions that might
 affect what is stored in the public state or or returned from an exported circuit.
 
-For example, the following contract attempts to disclose privata data without
-explictly declaring the disclosure when it stores the value of the exported
+For example, the following contract attempts to disclose private data without
+explicitly declaring the disclosure when it stores the value of the exported
 parameter `x` into the ledger field `F`:
 
 ```compact

From 962e8c20567c0b43063bed13d1efbe7d62e7473c Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Sun, 15 Mar 2026 22:10:51 +0100
Subject: [PATCH 20/41] latest lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 512 ++++++++++++++--------------
 1 file changed, 261 insertions(+), 251 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 93658949..84ba297c 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -537,7 +537,7 @@ struct NumberAnd<T> {
 ```
 
 The first declaration introduces a structure type named `Thing` with two fields:
-`triple` (a vector with 3 field elements) and `flag` (a Boolean).
+`triple` (a vector with three `Field` elements) and `flag` (a Boolean).
 The second introduces a *generic* structure type named `NumberAnd` with generic
 parameter `T` and two fields: `num` (a 32-bit unsigned integer) and `item`
 (a value of type `T`).
@@ -616,7 +616,7 @@ export circuit doesntWork(s: Even): Odd {
 Values of structure types are created with
 [**structure-creation** expressions](#structure-creation)
 and accessed via
-[**structure-member-access** expressions](#structure-member-access).
+[**structure-field-access** expressions](#structure-field-access).
 
 #### Enumeration types
 
@@ -1514,38 +1514,38 @@ In this example,
 
 Notes:
 
-1. Nesting is permitted only within `Map` values.  That is, nesting is not permitted in
-   `Map` keys or within any ledger-state type other than `Map`.
-2. Nested values must be initialized before first use.  The syntax `default<T>`
-   is used to create default ledger-state type values, just as it can be used to
-   create default Compact type values.
-3. Ledger state type values are not first-class objects, so when
-   accessing a nested value, the entire indirection chain must be
-   used.  For example, the following results in a compiler error:
-
-   ```compact
-   export circuit incrementNestedCounter(b: Boolean, n: Field, k: Uint<16>): [] {
-     fld.lookup(b); // ERROR: incomplete chain of indirects
-   }
-   ```
-4. When the last operation is a write of a base type, increment of a Counter type,
-   or decrement of a Counter type, one can replace the `write`, `increment`, or
-   `decrement` operation with the `=`, `+=`, or `-=` assignment syntax, as
-   illustrated by `incrementNestedCounter1` and `incrementNestedCounter2`,
-   which have the same behavior.
-5. When the last operation is a read of a Counter or base type one can omit the
-   explicit `read()` indirect, as illustrated by
-   `readNestedCounter1` and `readNestedCounter2`, which have the
-   same behavior.
-6. For convenience, local variables can hold default values of ledger-state types,
-   so the following definition of `initNestedMap` is equivalent to the one
-   above.
-   ```compact
-   export circuit initNestedMap(b: Boolean): [] {
-     const t = default<Map<Field, Counter>>;
-     fld.insert(disclose(b), t);
-   }
-   ```
+- Nesting is permitted only within `Map` values.  That is, nesting is not permitted in
+  `Map` keys or within any ledger-state type other than `Map`.
+- Nested values must be initialized before first use.  The syntax `default<T>`
+  is used to create default ledger-state type values, just as it can be used to
+  create default Compact type values.
+- Ledger state type values are not first-class objects, so when
+  accessing a nested value, the entire indirection chain must be
+  used.  For example, the following results in a compiler error:
+
+  ```compact
+  export circuit incrementNestedCounter(b: Boolean, n: Field, k: Uint<16>): [] {
+    fld.lookup(b); // ERROR: incomplete chain of indirects
+  }
+  ```
+- When the last operation is a write of a base type, increment of a Counter type,
+  or decrement of a Counter type, one can replace the `write`, `increment`, or
+  `decrement` operation with the `=`, `+=`, or `-=` assignment syntax, as
+  illustrated by `incrementNestedCounter1` and `incrementNestedCounter2`,
+  which have the same behavior.
+- When the last operation is a read of a Counter or base type one can omit the
+  explicit `read()` indirect, as illustrated by
+  `readNestedCounter1` and `readNestedCounter2`, which have the
+  same behavior.
+- For convenience, local variables can hold default values of ledger-state types,
+  so the following definition of `initNestedMap` is equivalent to the one
+  above.
+  ```compact
+  export circuit initNestedMap(b: Boolean): [] {
+    const t = default<Map<Field, Counter>>;
+    fld.insert(disclose(b), t);
+  }
+  ```
 
 ### Sealed and unsealed ledger fields
 
@@ -1765,8 +1765,8 @@ The syntax of Compact statements is summarized by the following grammar snippet:
 </div>
 
 
-The snippet shows that a statement (`stmt`) is either a one-armed `if` expression
-or some other kind of statement (`stmt0`).
+The snippet shows that a statement (*stmt*) is either a one-armed `if` expression
+or some other kind of statement (*stmt<sub>0</sub>*).
 This structure is used to enforce the restriction that the "then" part of a
 two-armed cannot be a one-armed `if` expression.
 This is often left ambiguous in a language grammar, with a separate note to say
@@ -1774,8 +1774,8 @@ that the ambiguity is resolved by associating each "else" part with the closest
 enclosing `if` expression, but we prefer to make the constraint explicit in
 the grammar and avoid any ambiguity.
 
-The first kind of `stmt0` is `expr-seq`.
-An `expr-seq`, or *expression sequence*, is a comma separated sequence of one
+The first kind of *stmt<sub>0</sub>* is *expr-seq*`;`.
+An *expr-seq*, or *expression sequence*, is a comma separated sequence of one
 or more expressions to be evaluated in sequence.
 This simply means that any expression or comma-separated sequence of expressions
 also qualifies as a statement.
@@ -1960,7 +1960,7 @@ Iteration can also be accomplished via
 A `return` statement can be used to exit from the closest enclosing
 [anonymous circuit](#circuit-and-witness-calls), if any, or otherwise from
 the enclosing constructor or named circuit, and to return to the caller either
-an explicit return value, i.e., the value of [`expr-seq`](#expression-sequences)
+an explicit return value, i.e., the value of [*expr-seq*](#expression-sequences)
 in this form of `return`:
 
 `return` *expr-seq*`;`
@@ -2158,8 +2158,8 @@ are evaluated solely for their effects.
 Compact has syntax for Boolean, numeric, and string literal expressions.
 
 A __Boolean literal__ is one of the reserved words `true` or `false`.
-The static type of a boolean literal is `Boolean` and its value is the
-corresponding boolean value.
+The static type of a Boolean literal is `Boolean` and its value is the
+corresponding Boolean value.
 
 A __numeric literal__ is a non-negative integer written in decimal, binary,
 octal, or hexadecimal notation as follows:
@@ -2287,9 +2287,9 @@ The type of the entire expression is the type of *e<sub>2</sub>* if *e<sub>1</su
 is a subtype of *e<sub>2</sub>* and the type of *e<sub>1</sub>* if *e<sub>2</sub>*
 is a subtype of *e<sub>1</sub>*.
 
-Conditional expressions are evaluated by first evaluating *e<sub>0</sub>*.
-The value *v* of that expression determines which of the other subexpressions is
-evaluated:
+A conditional expression *e<sub>0</sub>* `?` *e<sub>1</sub>* `:` *e<sub>2</sub>*
+is evaluated by first evaluating *e<sub>0</sub>*.  The value *v* of *e<sub>0</sub>*
+determines which of the other subexpressions is evaluated:
 
 - if *v* is `true`, then *e<sub>1</sub>* is evaluated and its value is the
   value of the entire expression
@@ -2301,8 +2301,8 @@ is evaluated.
 
 ### Relational comparison expressions
 
-Relational comparison expressions take the form *e<sub>0</sub>* `op` *e<sub>1</sub>*
-where *e<sub>0</sub>* and *e<sub>1</sub>* are expressions and `op` is one of
+Relational comparison expressions take the form *e<sub>1</sub> op e<sub>2</sub>*
+where *e<sub>1</sub>* and *e<sub>2</sub>* are expressions and *op* is one of
 Compact's relational operators.
 The relational operators are **equals** (`==`), **not equals** (`!=`), **less
 than** (`<`), **greater than** (`>`), **less than or equals** (`<=`), and
@@ -2319,8 +2319,8 @@ the types of *e<sub>1</sub>* and *e<sub>2</sub>* to be unsigned integer types.
 
 The type of the result is `Boolean`.
 
-A relational comparison expression *e<sub>0</sub>* `op` *e<sub>1</sub>* is
-evaluated by evaluating *e<sub>0</sub>*, then evaluating *e<sub>1</sub>*, then
+A relational comparison expression *e<sub>1</sub> op e<sub>2</sub>* is
+evaluated by evaluating *e<sub>1</sub>*, then evaluating *e<sub>2</sub>*, then
 comparing the resulting values as described below.
 
 **Equals and not equals**
@@ -2329,7 +2329,7 @@ Equality depends on the types of the operands according to the following rules.
 The rules need not and therefore do not cover cases where one operand is not a subtype of
 the other.
 For example, if one operand has type `Boolean`, so does the other; if one
-operand has a `Bytes` type of length `n`, so does the other; and if one
+operand has a `Bytes` type of length *n*, so does the other; and if one
 has a specific structure type, so does the other.
 
 - **`Boolean` == `Boolean`:**
@@ -2341,7 +2341,7 @@ has a specific structure type, so does the other.
 - **`Tuple` and `Vector`:**
   the values are equal if the corresponding values at each index are equal.
 - **Structure types:**
-  the values are equal if the corresponding members are equal.
+  the values are equal if the values of the corresponding fields are equal.
 - **Enumeration types:**
   the values are equal if they are the same enumeration member.
 - **`Opaque types:`**
@@ -2363,98 +2363,96 @@ otherwise it evaluates to `false`.
 
 ### Short-circuit logical expressions
 
-Compact supports short-circuit logical expressions of the form `e0 op e1`
-where `e0` and `e1` are expressions and `op` is one of the logical operators
-**or** (`||`) or **and** (`&&`).
+Compact supports short-circuit logical expressions of the form
+*e<sub>1</sub> op e<sub>2</sub>* where *e<sub>1</sub>* and *e<sub>2</sub>*
+are expressions and *op* is one of the logical operators **or** (`||`) or **and**
+(`&&`).
 
 Logical expressions require the types of both subexpressions to be `Boolean`.
 Otherwise it is a static error.
 The logical expression itself also has type `Boolean`.
 
-Logical expressions are evaluated by first evaluating the left subexpression.
-Then, the value of that expression determines the value of the entire
-expression as follows:
+Evaluating *e<sub>1</sub> op e<sub>2</sub>* involves first evaluating
+*e<sub>1</sub>*, then:
 
-- For `||`, if the value of the left subexpression is `true` the right
-  subexpression is *not* evaluated, i.e., short-circuited, and the value
-  of the entire expression is `true`.
-  Otherwise, the right subexpression *is* evaluated, and its value is the
-  value of the entire expression.
-- For `&&`, if the value of the left subexpression is `false` the right
-  subexpression is *not* evaluated, i.e., short-circuited, and the value
-  of the entire expression is `false`.
-  Otherwise, the right subexpression *is* evaluated, and its value is the
+- For `||`, if *v* is `true`, *e<sub>2</sub>* is *not* evaluated, 
+  and the value of the entire expression is `true`.
+  Otherwise, *e<sub>2</sub>* *is* evaluated, and its value is the
   value of the entire expression.
+- For `&&`, if *v* is `false`, *e<sub>2</sub>* is *not* evaluated,
+  and the value of the entire expression is `false`.
+  Otherwise, *e<sub>2</sub>* *is* evaluated, and its value is the value of the
+  entire expression.
 
-These are short circuiting operators because they do not evaluate the second
+These are short-circuiting operators because they do not evaluate the second
 operand if the final value is determined from the first.
 
 ### Boolean negation expressions
 
-Compact supports unary boolean negation expressions of the form `!e` where`e`
+Compact supports unary Boolean negation expressions of the form `!`*e* where *e*
 is an expression.
 
-The type of the subexpression must be of type `Boolean`, otherwise it is a
+The type of *e* must be of type `Boolean`, otherwise it is a
 static error.
 The Boolean-negation expression itself also has type `Boolean`.
 
-Negation expressions are evaluated by first evaluating the subexpression and
-checking its value.
-If the subexpression's value is `true`, the value of the Boolean negation expression is `false`.
-If the subexpression's value is `false`, the value of the Boolean negation expression is `true`.
+A Boolean negation expression `!`*e* is evaluated by evaluating *e* to
+determine its value *v*.
+Then if *v* is `true`, the value of the Boolean negation expression is `false`,
+and If *v* is `false`, the value of the Boolean negation expression is `true`.
 
 ### Binary arithmetic expressions
 
-Binary arithmetic expressions have the form `e0 op e1`, where `e0` and `e1`
-are expressions and `op` is one of Compact's binary arithmetic operators.  The
-binary arithmetic operators are **add** (`+`), **subtract** (`-`) and
+Binary arithmetic expressions have the form *e<sub>1</sub> op e<sub>2</sub>*,
+where *e<sub>1</sub>* and *e<sub>2</sub>* are expressions and *op* is one of
+Compact's binary arithmetic operators.
+The binary arithmetic operators are **add** (`+`), **subtract** (`-`) and
 **multiply** (`*`).
 
-Arithmetic expressions require the type of both subexpressions to be numeric
+Arithmetic expressions require the types of both subexpressions to be numeric
 types, that is, either a `Field`, a `Uint`, or a type alias for a `Field` or
 a `Uint`.
 Putting aside type aliases for now, the type of the result depends on the
 types of the subexpressions as follows:
 
 - If either subexpression has type `Field`, the result has type `Field`.
-- Otherwise the left subexpression has type `Uint<0..m>`,
-  and the right subexpression has type `Uint<0..n>`
-  for some bounds `m` and `n`.
+- Otherwise *e<sub>1</sub>* must have type `Uint<0..`*m*`>`, and
+  *e<sub>2</sub>* must have type `Uint<0..`*n*`>` for some bounds *m* and *n*.
   The type of the result depends on the operation as follows:
-  - for add, the result has type `Uint<0..m+n>`,
-  - for subtract, the result has type `Uint<0..m>`, and
-  - for multiply, the result has type `Uint<0..m*n>`.
+  - for add, the result has type `Uint<0..`*m+n*`>`,
+  - for subtract, the result has type `Uint<0..`*m*`>`, and
+  - for multiply, the result has type `Uint<0..`*m⋅n*`>`.
 
 For arithmetic operations with `Uint` result types, it is a static error if
 the result's bound would be greater than the maximum unsigned integer.
 
-Evaluating an arithmetic expression involves first evaluating the subexpressions in
-order from left to right.  Integer addition, subtraction, or multiplication is
-then used on the subexpression values.  The overflow and underflow behavior
-differs for `Field` and `Uint` operations:
+Evaluating an arithmetic expression *e<sub>1</sub> op e<sub>2</sub>* involves
+first evaluating *e<sub>1</sub>*, then evaluating *e<sub>2</sub>*.
+Integer addition, subtraction, or multiplication is then used on the subexpression
+values.
+The overflow and underflow behavior differs for `Field` (either operand has
+type `Field`) and `Uint` operations (both operands have a `Uint` type):
 
 - `Field` arithmetic overflow and underflow wraps around 0; that is, the result
   of an arithmetic operation whose result is a `Field` is the actual arithmetic
-  value modulo `k`, where `k` is one more than the maximum field value.
+  value modulo *k*, where *k* is one more than the
+  [maximum field value](#implementation-specific-limits).
 - `Uint` addition and multiplication cannot overflow: the static type of the
   result is always large enough to hold the result value.
-- `Uint` subtraction checks if the value of the right subexpression is greater
-  than the value of the left subexpression.  If so, it is a runtime error, since
-  the result would be negative.  Otherwise the unsigned subtraction is performed.
-
-The static typing rules imply that if `Field` arithmetic semantics is desired,
-then at least one of the operands must have static type `Field`.
+- `Uint` subtraction results in a dynamic error if the resulting value would
+  be negative, i.e., if the value of *e<sub>2</sub>* is greater the the value
+  of *e<sub>1</sub>*.
 
 If the type of either subexpression is a structural type alias for a `Field` or
 `Uint` it is treated identically to that `Field` or `Uint`, both in type checking
 and evaluation.
 
 On the other hand, if the type of either subexpression is a nominal type alias
-`T` for a `Field` or a `Uint`, the type of the other subexpression must also have
-type `T`, and the type of the result also has type `T`.
+*T* for a `Field` or a `Uint`, the type of the other subexpression must also have
+type *T*, and the type of the result also has type *T*.
 Evaluation proceeds as if the two operands had the underlying `Field` or `Uint`
-type with the value cast back to `T`, which can result in a run-time error if
-`T` is a nominal alias for a type `Uint<0..n>` and the value is not less than `n`.
+type with the value cast back to *T*, which can result in a run-time error if *T*
+is a nominal alias for a type `Uint<0..`*n*`>` and the value is not less than *n*.
 For example:
 
 ```compact
@@ -2471,28 +2469,28 @@ message indicating that the cast of the value to `Feet` failed.
 
 ### Tuple creation
 
-New tuple values are created with expressions of the form `[tuple-arg, `⋯`]` where
-`tuple-arg`, ⋯ is a sequence of zero or more comma-separated tuple
+New tuple values are created with expressions of the form `[`*tuple-arg*, ⋯, *tuple-arg*`]` where
+*tuple-arg*, ⋯, *tuple-arg* is a sequence of zero or more comma-separated tuple
 arguments.
 A non-empty sequence can have an optional trailing comma.
 Each tuple argument is either an expression or a *spread*.
 
-If a tuple argument is an expression `expr` of type `T`, it contributes a single
-element of type `T` to the new tuple: the value of `expr`.
+If a tuple argument is an expression *e* of type *T*, it contributes a single
+element of type *T* to the new tuple: the value of *e*.
 
-If a tuple argument is a spread `... expr`, the type `T` of `expr` must be
+If a tuple argument is a spread `... `*e*, the type *T* of *e* must be
 a tuple type, a Vector type, or a Bytes type.
 Otherwise, it is a static error.
 
-If `expr` has a tuple type `[U, `⋯`]` of length *n*, the spread contributes
-`n` new elements of type `U`, ⋯ to to the new tuple, i.e., the elements
-of the tuple value of `expr`.
-If `expr` has a Vector type `Vector<n, U>`, the spread contributes
-`n` new elements of type `U` to to the new tuple, i.e., the elements
-of the Vector value of `expr`.
-If `expr` has a Bytes type `Bytes<n>`, the spread contributes `n` new elements of
+If *T* is a tuple type `[`*U<sub>1</sub>*, ⋯, *U<sub>n</sub>*`]`, the
+spread contributes *n* new elements of types *U<sub>1</sub>*, ⋯, *U<sub>n</sub>*
+to to the new tuple, i.e., the elements of the tuple value of *e*.
+If *T* is a Vector type `Vector<`*n*, *U*`>`, the spread contributes
+*n* new elements of type *U* to the new tuple, i.e., the elements
+of the Vector value of *e*.
+If *T* is a Bytes type `Bytes<`*n*`>`, the spread contributes *n* new elements of
 type `Uint<8>` to to the new tuple, i.e., the elements of the byte-vector value
-of `expr`.
+of *e*.
 
 The type of a tuple-creation expression is the tuple type whose elements are
 the types contributed by each of the tuple arguments in order.
@@ -2506,41 +2504,38 @@ which can be less than or greater than number of tuple arguments.
 ### Byte-vector creation
 
 New byte vectors are created with expressions of the form
-`Bytes [tuple-arg, `⋯`]`.
+`Bytes [`*tuple-arg*, ⋯, *tuple-arg*`]`.
 Bytes creation is essentially the same as [tuple creation](#tuple-creation)
 except that the types of the contributed elements must all be subtypes of `Uint<8>`
 (if not, it is static error), and the result is a new byte vector of type
-`Bytes<n>` where `n` is the number of contributed elements.
+`Bytes<`*n*`>` where *n* is the number of contributed elements.
 
 ### Tuple, vector, and byte-vector references
 
 Compact allows references to individual elements of sequence values (tuples,
-vectors, and byte vectors) via the syntax `expr[index]` where `expr` is
-an expression and `index` is a numeric literal, generic natural-number parameter reference,
+vectors, and byte vectors) via the syntax *e*`[`*index*`]` where *e* is
+an expression and *index* is a numeric literal, generic natural-number parameter reference,
 or an expression that can be reduced to a numeric constant at compile time as
 described below.
 
-The type of `expr` must be a sequence type, i.e., a tuple type, a vector type,
+The type of *e* must be a sequence type, i.e., a tuple type, a vector type,
 or a Bytes type.
-The type of `index` must be `Uint<n>` for any `n`.
-The eventual constant value of `index` must be less than the length of the
+The type of *index* must be `Uint<`*n*`>` for any *n*.
+The eventual constant value of *index* must be less than the length of the
 sequence value as determined by its type.
 Violating any of these constraints is a static error.
 
-The unsigned integer value of `index` must be computable at compile time
+The unsigned integer value of *index* must be computable at compile time
 via the following rules, or it is a static error.
-
-- Any `index` can be a constant, i.e., a numeric literal or a generic natural-number
+- Any *index* can be a constant, i.e., a numeric literal or a generic natural-number
   parameter reference.
-
-- If the type of `expr` is a tuple type that has a vector type, the rule for
-  vector types below applies, with `expr` treated as having the vector type.
-  If the type of `expr` is a tuple type that does not have a vector type,
-  however, `index` must be a constant.
+- If the type of *e* is a tuple type that [has a vector type](#subtyping-and-least-upper-bounds), the rule for
+  vector types below applies, with *e* treated as having the vector type.
+  If the type of *e* is a tuple type that does not have a vector type,
+  however, *index* must be a constant.
   This restriction allows the compiler to compute a type for tuple reference
-  expressions without first attempting to reduce `index` to a numeric value.
-
-- If the type of `expr` a vector or byte-vector type, `index` must be a
+  expressions without first attempting to reduce *index* to a numeric value.
+- If the type of *e* is a vector or byte-vector type, *index* must be a
   *constant-valued* expression, where a constant-valued expression is:
   - a constant,
   - a reference to a generic natural-number parameter,
@@ -2550,16 +2545,16 @@ via the following rules, or it is a static error.
     expressions.
 
 The type of a byte-vector reference is `Uint<8>`.
-The type of a vector reference where the vector has type `Vector<n, T>` is `T`.
-The type of a tuple reference where the tuple has type `[T1, `⋯`, Tn]` is
-`Ti` if `index` is the constant `i` or the value `i` of a generic natural-number
-parameter.
-Otherwise, `[T1, `⋯`, Tn]` must have a vector type `Vector<n, T>` and the
-type of the tuple reference is `T`.
+The type of a vector reference where the vector has element type *T* is *T*.
+The type of a tuple reference where the tuple has type `[`*T<sub>1</sub>*, ⋯,
+*T<sub>n</sub>*`]` and *index* is the constant *i* or the value
+*i* of a generic natural-number parameter is *T<sub>i</sub>*.
+Otherwise, the tuple type must have a vector type
+`Vector<`*n*, *T*`>` and the type of the tuple reference is *T*.
 
-The value of a sequence reference is element `i` (zero-based) of the result
-of evaluating `expr`, where `i` is the (eventually) compile-time constant
-value of `index`.
+The value of a sequence reference is the value of the *ith* (zero-based) element
+of the result of evaluating *e*, where *i* is the (eventually) compile-time constant
+value of *index*.
 
 ### Tuple, vector, and byte-vector slices
 
@@ -2568,25 +2563,30 @@ subsequence of the original value.
 It is similar to a sequence reference but extracts a sequence of values rather
 than a single value from the sequence value.
 
-Slice expressions take the form `slice<size>(expr, index)`, where `slice`
-is a keyword, `size` is a constant or numeric generic parameter reference, `expr` is
-an expression, and `index` is a numeric literal, a generic natural-number
-parameter reference, or an expression that can be reduced to a numeric constant at
-compile time as described above in the section on [Tuple, vector, and byte-vector
-references](#tuple-vector-and-byte-vector-references).
-
-The type of a byte-vector slice is `Bytes<k>` where `k` is the constant value of `size`.
-The type of a vector slice where the vector has type `Vector<n, T>` is `Vector<k, T>`.
-The type of a tuple slice where the tuple has type `[T1, `⋯`, Tn]` is the subsequence
-`[Ti, `⋯`, Tj]` starting with element `i` (zero-based) and ending with element
-`j = i + k - 1` of `[T1, `⋯`, Tn]`.
-Otherwise, `[T1, `⋯`, Tn]` must have a vector type `Vector<n, T>` and the
-type of the tuple reference is `Vector<k, T>`.
-
-The value of a `slice` expression is subsequence of the original tuple, vector,
-or byte vector from `i` (zero-based, inclusive) through `i + k` (zero-based,
-exclusive) of the resulting of evaluating `expr`, where `i` is the (eventually)
-compile-time constant value of `index` and `k` is the constant value of `size`.
+Slice expressions take the form `slice<`*k*`>(`*e*, *index*`)`, where `slice`
+is a keyword, *k* is a constant or numeric generic parameter reference specifying
+the fixed size of the slice, *e* is an expression, and *index* is a numeric
+literal, a generic natural-number parameter reference, or an expression that can be
+reduced to a numeric constant at compile time as described above in the section on
+[sequence references](#tuple-vector-and-byte-vector-references).
+
+The type of a byte-vector slice is `Bytes<`*k*`>`.
+The type of a vector slice where the vector has element type *T* is
+`Vector<`*k*, *T*`>`.
+The type of a tuple slice where the tuple has type
+`[`*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*`]` and *index* is the constant *i*
+or the value *i* of a generic natural-number parameter
+is the subsequence `[`*T<sub>i</sub>*, ⋯, *T<sub>j</sub>*`]` starting with
+element *i* (zero-based) and ending with element *j=i+k-1* of `[`*T<sub>1</sub>*,
+⋯, *T<sub>n</sub>*`]`.
+Otherwise, the tuple type must [have a vector
+type](#subtyping-and-least-upper-bounds) `Vector<`*n*, *T*`>` and the type of
+the slice is `Vector<`*k*, *T*`>`.
+
+The value of a `slice` expression `slice<`*k*`>(`*e*, *index*`)` is the subsequence
+of the original tuple, vector, or byte vector from *i* (zero-based, inclusive)
+through *i+k* (zero-based, exclusive) of the result of evaluating *e*, where *i*
+is the (eventually) compile-time constant value of *index*.
 
 For example, if `getMiddle` is defined as follows:
 
@@ -2610,30 +2610,41 @@ Bytes[18, 19, 20]
 
 ### Structure creation
 
-Structure values are created with structure creation expressions.  The
-expression `T {f, `⋯`}` is a structure creation expression, where `T` is a
-structure type name `S` or specialized generic structure type name `S<garg, `⋯`>`,
-and `f, `⋯ is a sequence of zero or more comma-separated field-value specifiers.
-
-A field-value specifier can be one of three things:
-
-* A **positional** field-value specifier is an expression.  Evaluating the expression
-  gives the value for the field.  Positional field values must be given in the
-  order that fields are declared in the corresponding structure declaration.
-* A **named** field-value specifier is of the form `id: e` where `id` is a field name and
-  `e` is an expression.  Evaluating the expression gives the value for the
-  corresponding named field.  Named fields can appear in any order.  If named
-  and positional fields are mixed, all the named fields must appear after all
-  the positional fields.
-* A **spread** field-value specifier is of the form `...e` where `...` is the
-  literal three dots (ellipsis) token and `e` is an expression.
-  Evaluating the expression must give a value of the same structure type as the
-  one being created.
-  Each field of the created structure is given the value of the corresponding
-  field from the spread structure, if not overridden by a named field value,
-  as described below.
-  If a spread expression is present, it must occur as the first field-value
-  specifier, and all other specifiers must be named field values.
+Structure values are created with structure-creation expressions of the form
+*T* `{`*struct-arg*, ⋯, *struct-arg*`}`, where *T* is a structure type name *S*
+or specialized generic structure type *S*`<`*garg*, ⋯, *garg*`>`, and
+*struct-arg*, ⋯, *struct-arg* is a sequence of zero or more comma-separated
+structure arguments.
+
+A structure argument can be one of three things:
+
+- a **positional** argument, which takes the form of an expression *e*,
+- a **named** argument, which takes the form *id*`:` *e*, where *id* is a field
+  name and *e* is an expression, or
+- a **spread** argument, which takes the form `...`*e*, where `...` is the
+  literal three dots (ellipsis) token and *e* is an expression.
+
+The sequence of structure arguments within a structure-creation expression can consist
+either of:
+- zero or more positional arguments followed by zero or more named arguments, or
+- a spread argument followed by zero or more named arguments.
+
+In the first case, the values of the *n* positional arguments become the values
+of the first *n* fields of the created structure and must be given in the same
+order as the fields in the structure declaration.
+The named elements specify the values of the remaining fields by name; that is,
+the value of *e* in the named argument *id*`:` *e* becomes the value of the
+field named *id*.
+
+In the second case, the expression *e* in the spread argument `...`*e* must
+have the same structure type *T* as the one being created, and each field of the
+created structure is given the value of the corresponding field from the value
+of *e* if not overridden by one of the named arguments.
+
+Named arguments need not appear in any particular order.
+
+It is possible for only positional or only named arguments to be present.
+It is also possible, though not useful, for only a spread argument to be present.
 
 The examples below demonstrate the use of positional and spread field values:
 
@@ -2656,85 +2667,84 @@ circuit f(x: Uint<32>, y: Boolean, z: Bytes<8>): S {
 }
 ```
 
-The structure type name must be bound to a structure type in scope.  If the
-structure is generic, then it must be explicitly specialized with generic
-arguments enclosed in angle brackets.  Generic structures must be fully
-specialized: the number of generic arguments must match the number of generic
-parameters.
-
-The static type of a non-generic structure creation expression is the named
-structure type.
-
-The generic arguments to a generic structure can be types, natural number
-literals, or the names of generic parameters in scope.
-The static type of a generic structure-creation expression is a structure with
-the same name as the generic type and field types obtained by substituting the
-generic arguments for the generic parameters in the structure's declaration.
-
-**If a spread field specifier is not present:** It is a static error if the number of
-field specifiers does not match the number of fields in the corresponding
-structure declaration: a value must be given for every field.  It is a static
-error if a named field specifier occurs before a positional field specifier.  It
-is a static error if a field name occurs more than once, and it is a static
-error if a field name occurs that is not the name of a field in the
-corresponding structure declaration.  It is a static error if the type of a
-positional field subexpression is not a subtype of the declared type of the
-(positionally) corresponding field in the structure declaration.  It is a static
-error if the type of a named field subexpression is not a subtype of the
+The structure type name must be bound to a structure type in scope.
+If the structure is generic, it must be fully specialized with generic arguments
+enclosed in angle brackets.
+
+The static type of a non-generic structure-creation expression is the named
+structure type, while the static type of a generic structure-creation expression
+is a structure with the same name as the generic type and field types obtained by
+substituting the generic arguments for the generic parameters in the structure's
+declaration.
+
+**If a spread argument is not present:**
+The number of structure arguments must match the number of fields in the corresponding
+structure declaration: a value must be given for every field.
+Positional arguments must appear before named arguments.
+A field name must not occur more than once among the named arguments, and each
+field name that does occur must be the name of a field in the corresponding
+structure declaration whose value is not given positionally.
+The type of a positional field subexpression must be a subtype of the
+declared type of the (positionally) corresponding field in the structure
+declaration.
+Similarly, the type of a named field subexpression must be a subtype of the
 declared type of the corresponding (named) field in the structure declaration.
 
-**If a spread field specifier is present:** It is a static error if the spread
-field specifier does not come first in the sequence.  It is a static error
-if the type of the spread subexpression is not the same type as the structure to be
-created.  It is a static error if there are any positional field specifiers.  It
-is a static error if a field name occurs that is not the name of a field in the
-corresponding structure declaration.  It is a static error if the type of a
-named field subexpression is not a subtype of the declared type of the
-corresponding (named) field in the structure declaration.
-
-A structure creation expression is evaluated by evaluating the field specifier
-subexpressions in order from left to right, and its value is a structure value
-whose fields have values based on the corresponding field specifier: if there is
-a positional or named field specifier for the field, the field value is the
-value of the subexpression, otherwise there must be a spread expression and the
-field value is the value of the corresponding field in the (structure) value of
-the spread subexpression.
-
-### Structure member access
-
-An expression of the form `e.id` where `e` is an expression with a structure
-type `S` and `id` is an identifier is a structure member access.
-It is a static error if `S` does not have a member named `id`.
-
-The type of any structure member access `e.id` where `e` has type `S`
-is the type of the corresponding named member of `S`.
-
-The value of any structure member access `e.id` is the result of evaluating the
-subexpression `e` and extracting the value of the resulting structure's
-`id` member.
-
-Some expressions of the form `e.id` can also be
+**If a spread argument is present:**
+The spread argument must come first in the sequence of structure arguments.
+The type of the spread subexpression must be the same as the structure to be
+created.
+There must not be any positional arguments.
+A field name must not occur more than once among the named arguments, and
+each field name that does occur must be the name of a field in the corresponding
+structure declaration.
+The type of a named field subexpression must be a subtype of the
+declared type of the corresponding (named) field in the structure declaration.
+
+Violating any of the above constraints is a static error.
+
+A structure-creation expression is evaluated by evaluating the structure argument
+expressions in order from left to right and constructing a structure value
+whose fields values are based on the corresponding structure arguments: if there
+is a positional or named argument for a field, the field's value is the
+value of the expression, otherwise there must be a spread argument and the
+field's value is the value of the corresponding field in the (structure) value
+of the spread expression.
+
+### Structure field access
+
+A structure field access is an expression of the form *e*`.`*id* where *e* is
+an expression with a structure type *T* and *id* is an identifier.
+It is a static error if *T* does not have a field named *id*.
+
+The type of any structure field access *e*`.`*id* where *e* has type *T* is the
+type of the *id* field of *T*.
+
+The value of any structure field access *e*`.`*id* is the result of evaluating the
+subexpression *e* and extracting the value of the resulting structure's *id* field.
+
+Some expressions of the form *e*`.`*id* can also be
 [enumeration member accesses](#enumeration-member-access) or
-[ledger `read` operations](#ledger-state-operations).
-`e.id` is recognized as a structure member access only when the
-type of `e` is a structure type.
+[ledger-state operations](#ledger-state-operations).
+*e*`.`*id* is recognized as a structure field access only when the
+type of *e* is a structure type.
 
 ### Enumeration member access
 
-An expression of the form `E.id` where `E` is the name of an enumeration
-type and `id` is an identifier is an enumeration member access.
-It is a static error if `E` does not have a member named `id`.
+An expression of the form *E*`.`*id* where *E* is the name of an enumeration
+type and *id* is an identifier is an enumeration member access.
+It is a static error if *E* does not have a member named *id*.
 
-The type of any enumeration member access `E.id` is `E`.
+The type of any enumeration member access *E*`.`*id* is *E*.
 
-`E.id` is a constant.
-That is, the value of any enumeration member access `E.id` is `E.id`.
+*E*`.`*id* is a constant.
+That is, the value of any enumeration member access *E*`.`*id* is *E*`.`*id*.
 
-Some expressions of the form `e.id` can also be
-[structure member accesses](#enumeration-member-access) or
-[ledger `read` operations](#ledger-state-operations).
-`e.id` is recognized as an enumeration member access only when the
-type of `e` is an enumeration type.
+Some expressions of the form *E*`.`*id* can also be
+[structure field accesses](#structure-field-access) or
+[ledger-state operations](#ledger-state-operations).
+*E*`.`*id* is recognized as an enumeration member access only when the
+type of *e* is an enumeration type.
 
 ### Circuit and witness calls
 
@@ -3225,7 +3235,7 @@ The TypeScript type representing a Compact type is defined in [Representations
 in TypeScript](#representations-in-typescript).
 
 Compact represents values exactly as TypeScript represents values, i.e., as
-ordinary JavaScript values.  So a Compact boolean is represented at run time
+ordinary JavaScript values.  So a Compact Boolean is represented at run time
 as a JavaScript boolean, a Compact tuple is represented as a JavaScript
 array, and enum values are represented by numbers.
 

From d8d8304b67e844da2b1098faa6a8e026c4b77dbb Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Mon, 16 Mar 2026 07:52:10 +0100
Subject: [PATCH 21/41] latest lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 163 +++++++++++++---------------
 1 file changed, 78 insertions(+), 85 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 84ba297c..c2141372 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -2748,6 +2748,12 @@ type of *e* is an enumeration type.
 
 ### Circuit and witness calls
 
+Circuits and witnesses, collectively referred to as functions, are called via
+expressions of the form *fun*`(`*e*, ⋯, *e*`)`, where *fun* is a function expression
+and *e*, ⋯, *e* is a sequence of zero or more comma-separated argument expressions.
+
+The function expression *fun* can take one of the following forms:
+
 <div className="lang-ref-table">
 |                        |         |                                                                                                                                            |
 |------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------|
@@ -2760,42 +2766,28 @@ type of *e* is an enumeration type.
 </div>
 
 
-Circuits and witnesses, collectively referred to as functions, are called via an
-expression of the form `f(e, ...)`, where `f` is a function and `e, ...` is a
-sequence of zero or more comma-separated argument expressions.
-
-The function expression can take several different forms:
-
-A **function name** is the name of a circuit or witness from a circuit or
-witness declaration in scope.
-
-An **anonymous circuit** is an inline circuit definition having the form `(P,
-...) => body` or `(P, ...): R => body`, where `P, ...` are zero or more
-comma-separated parameter declarations, `R` is an optional return type
-annotation, and `body` is the circuit's body.
-Each parameter is a [pattern](#patterns-and-destructuring) with an optional type
-annotation `: T` where `T` is a Compact type.
-The optional return type `R` is a Compact type.
-The body is either a [block](#blocks) or an expression.
+In the simplest form, *fun* is just a identifier *id* referring to a witness or
+named circuit.
+When *id* refers to a generic witness or circuit, it must be fully specialized via
+generic parameters.
 
-There is no syntax for generic anonymous circuits.  This is because circuits are
-not first-class values: they cannot be passed around or stored in data
-structures, they *must* be called.  And generic circuits must be specialized to
-call them, so anonymous generic circuits would have to be immediately
-specialized.  In that case, the programmer can just write the non-generic
-version themselves.
+*fun* can also be an *anonymous circuit*, also known as an *arrow circuit*.
+This form consists of a parameter list
+`(`*optionally-typed-pattern*, ⋯, *optionally-typed-pattern*`)` followed
+by an optional return type `:` *type*,
+an arrow (`=>`), and a body, which can be a *block* or an *expr*.
+Each *optionally-typed-pattern* is a [pattern](#patterns-and-destructuring)
+with an optional type annotation `:` *type*.
 
-A **parenthesized function** has the form `(f)` where `f` is a function expression,
-i.e., a function name, anonymous circuit, or parenthesized function.
+Finally, *fun* can be a parenthesized function `(`*fun*`)`.
 
-Because circuits and witnesses are not first class, parameter names and constant
-names are not allowed as the circuit or witness part of a call.  Nor are
-arbitrary expressions allowed, for the same reason.
+Because circuits and witnesses are not first class, *fun* cannot be a variable
+name or arbitary expresison.
 
-Generic functions cannot be called without explicitly specializing them with
-generic arguments enclosed in angle brackets.  Calls to generic functions must
-be fully specialized: the number of generic arguments must match the number of
-generic parameters.
+Anonymous circuits cannot have generic parameters.
+Since they appear only in contexts where they are directly called, the circuit
+would have to be immediately specialized, in which case only one specialization
+can exist and the non-generic version would be clearer.
 
 The *underlying function* of a function expression is a non-parenthesized
 function expression.  For a function name it is the function name, for an
@@ -2811,7 +2803,7 @@ Type checking a function call depends on the form of the underlying function.
   present in the scope of the call.
 
   A candidate function is not necessarily compatible with the number and kinds
-  of the generic parameter values, nor with the number and types of the argument
+  of the generic parameter values nor with the number and types of the argument
   expressions provided at the call site.  It is compatible if and only if the
   number of generic parameters is the same as the number of generic arguments,
   each generic argument is of the required kind (numeric or type), the number
@@ -2838,13 +2830,13 @@ Type checking a function call depends on the form of the underlying function.
   pieces of the corresponding argument is the type of the corresponding part of
   the structure of the declared or inferred parameter type.
 
-  If there is a return type annotation, it is a static error if the body can
-  return a type of value that is not a subtype of the return type annotation.
+  If there is a return-type annotation, it is a static error if the body can
+  return a type of value that is not a subtype of the return-type annotation.
   A return statement of the form `return;` implicitly returns a value of type
   `[]`, as does every control flow path through a body that does not explicitly
   end with a return statement.
 
-  If there is no return type annotation, then a return type is inferred from the
+  If there is no return-type annotation, then a return type is inferred from the
   body as the least upper bound of the types of the values that can be returned
   from the body (explicitly or implicitly).
   It is a static error if these types do not have a least upper bound.
@@ -2863,73 +2855,74 @@ value of a witness call is the value returned by the witness function.
 ### Map and fold expressions
 
 Compact supports expressions that perform the higher-order operations _map_ and
-(left) _fold_ over vectors, tuples that have vector types (not arbitrary tuples),
+(left-to-right) _fold_ over vectors, tuples that have vector types (not arbitrary tuples),
 and byte vectors.
 
-Map expressions have the form `map(f, e, e, ...)` where `map` is a keyword, `f`
-is a circuit or witness taking at least one argument, and each `e` is an expression.
-A circuit or witness taking _n_ arguments can be mapped over _n_ sequence values
-(vectors, tuples that have vector types, or byte-vectors) by providing _n_
+Map expressions have the form `map(`*fun*, *e*, ⋯¹, *e*`)` where `map` is a
+keyword, *fun* is a circuit or witness taking at least one argument, and each *e*
+is an expression.
+A circuit or witness taking *n* arguments can be mapped over *n* sequence values
+(vectors, tuples that have vector types, or byte-vectors) by providing *n*
 sequence-value subexpressions to the `map`.
 
-Fold expressions have the form `fold(f, init, e, e, ...)` where `fold` is a
-keyword, `f` is a circuit or witness taking at least two arguments, `init`
-is an expression, and each `e` is an expression.
-A circuit or witness taking _n_+1 arguments can be folded over an initial value
-`init` and _n_ sequence values by providing _n_ sequence-value subexpressions to
+Fold expressions have the form `fold(`*fun*, *init*, *e*, ⋯¹, *e*`)` where
+`fold` is a keyword, *fun* is a circuit or witness taking at least two arguments,
+*init* is an expression, and each *e* is an expression.
+A circuit or witness taking *n*+1 arguments can be folded over an initial value
+*init* and *n* sequence values by providing *n* sequence-value subexpressions to
 the `fold`.
 
-A detailed description of the circuit or witness `f` is given in
+A detailed description of the circuit or witness *fun* is given in
 [Circuit and witness calls](#circuit-and-witness-calls) above.
 
 A map expression is type-checked by checking the type of the witness or circuit
-`f` to find its declared or inferred parameter types and its declared or
-inferred return type `R`.
-`f` must have at least one parameter, and the map expression must have the same
-number of sequence-value subexpressions as the number of parameters of `f`.
+*fun* to find its declared or inferred parameter types and its declared or
+inferred return type *R*.
+*fun* must have at least one parameter, and the map expression must have the same
+number of sequence-value subexpressions as the number of parameters of *fun*.
 Each of the sequence-value subexpressions must have a vector or byte-vector type,
-and all these types must have the same length `n`.
-If the type of the *i*th parameter to `f` is `T`, then the *i*th sequence-value
-subexpression must have the vector type `Vector<n, S>` where `S` is a subtype of
-`T`, or it must be the byte-vector type `Bytes<n>` and `Uint<8>` must be a subtype
-of `T`.
-The type of `map` expression is `Vector<n, R>`, regardless of whether the input
-sequence-value subexpressions are vectors, tuples, or byte-vectors.
+and all these types must have the same length *n*.
+If the type of the *ith* parameter to *fun* is *T*, then the *ith* sequence-value
+subexpression must have the vector type `Vector<`*n*, *S*`>` where *S* is a subtype of
+*T*, or it must be the byte-vector type `Bytes<`*n*`>` and `Uint<8>` must be a subtype
+of *T*.
+The type of the `map` expression is `Vector<`*n*, *R*`>`; `map` produces a vector
+regardless of whether the input sequence-value subexpressions are vectors, tuples,
+byte-vectors, or some combination.
 
 A fold expression is type-checked by checking the type of the witness or circuit
-`f` to find its parameter types and its return type `R`.
-`f` must have at least two parameters, and the type of the first parameter must
-be the same type as the return type `R`.
-The `fold` expression must have one fewer sequence-value subexpression than the
-number of parameters of `f`.
-The first subexpression `init` gives the initial value for the fold.
-It must have a type which is a subtype `R`.
-Each of the sequence-value subexpressions must have a vector or byte-vector type
-and all these types must have the same length `n`.
-If the type of the *i*+1th parameter of `f` is `T`, then the type of the *i*th
-sequence-value subexpression must have the vector type `Vector<n, S>` where `S`
-is a subtype of `T`, or it must be the byte-vector type `Bytes<n>` and `Uint<8>`
-must be a subtype of `T`.
-The type of the entire expression is `R`.
+*fun* to find its parameter types and its return type *R*.
+*fun* must have at least two parameters, and the type of the first parameter must
+be the same type as the return type *R*.
+The fold expression must have one fewer sequence-value subexpression than the
+number of parameters of *fun*.
+The first subexpression *init* gives the initial value for the fold.
+It must have a type which is a subtype *R*.
+Each of the sequence-value subexpressions must have a vector or byte-vector type,
+and all these types must have the same length *n*.
+If the type of parameter *i*+1 of *fun* is *T*, then the type of the *ith*
+sequence-value subexpression must have the vector type `Vector<`*n*, *S*`>` where *S*
+is a subtype of *T*, or it must be the byte-vector type `Bytes<`*n*`>` and `Uint<8>`
+must be a subtype of *T*.
+The type of the entire expression is *R*.
 
 Map expressions are evaluated by evaluating the sequence-value subexpressions
-from left to right.
-These values are the input sequence values.
-The witness or circuit `f` is then applied in turn, from index 0 up to index
-`n`-1, to arguments taken from the input sequence values.
-The result is a vector of length `n` where each *i*th element is the result of
-applying `f` to the *i*th elements of the corresponding input sequence values.
-
-Fold expressions are evaluated by evaluating the initial value expression `init` and
+from left to right to produce the input sequence values.
+The witness or circuit *fun* is then applied in turn, from index 0 up to index
+*n*-1, to arguments taken from the input sequence values.
+The result is a vector of length *n* where each *ith* element is the result of
+applying *fun* to the *ith* elements of the corresponding input sequence values.
+
+Fold expressions are evaluated by evaluating the initial value expression *init* and
 then evaluating the sequence-value subexpressions from left to right.
 The values of the sequence-value expressions are the input sequence values.
-The witness or circuit `f` is then applied in turn, from index 0 up to index `n`-1,
+The witness or circuit *fun* is then applied in turn, from index 0 up to index *n*-1,
 to an accumulator value argument and arguments taken from the input sequence values.
-The 0th (initial) accumulator value is the value of the expression `init`, and
-each subsequent *i*+1th accumulator value is the result of applying `f` to the
-*i*th accumulator value and to the *i*th elements of the corresponding input
+The 0th (initial) accumulator value is the value of the expression *init*, and
+each subsequent *i+1*th accumulator value is the result of applying *fun* to the
+*ith* accumulator value and to the *ith* elements of the corresponding input
 sequence values.
-The result is the `n`th (final) accumulator value where `n` is the length of the
+The result is the *nth* (final) accumulator value where *n* is the length of the
 input vectors.
 
 ### Type cast expressions

From 99e326839ac7e2e7421e18b0e74e03e787ba1e6f Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Mon, 16 Mar 2026 10:28:22 +0100
Subject: [PATCH 22/41] latest lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 216 ++++++++++++++--------------
 1 file changed, 108 insertions(+), 108 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index c2141372..da3f32fe 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -694,7 +694,7 @@ that expects a value of type `Vector<3, Uint<16>>` without an explicit cast.
 When one operand of an arithmetic operation (e.g., `+`) receives a value of some
 nominal type alias *type-name*, the other operand must also be of type *type-name*,
 and the result of performing the operation is cast to type *type-name*.
-This might cause a run-time error if the result cannot be represented by type
+This might cause a dynamic error if the result cannot be represented by type
 *type-name*.
 
 Values of any nominal type alias *type-name* cannot be compared directly using,
@@ -1378,9 +1378,9 @@ The following *ledger-state types* are supported.
 - `Map<K, T>`, for any Compact types `K` and `T`
 - `Map<K, V>`, for any Compact type `K` and ledger-state type `V` (see the following section)
 - `List<T>`, for any Compact type `T`
-- `MerkleTree<n, T>`, for a compile time integer `1 < n <= 32`, and any Compact
+- `MerkleTree<n, T>`, for a compile time integer 1 \< *n* ≤ 32, and any Compact
   type `T`
-- `HistoricMerkleTree<n, T>`, for a compile time integer `1 < n <= 32`, and any
+- `HistoricMerkleTree<n, T>`, for a compile time integer 1 \< *n* ≤ 32, and any
   Compact type `T`
 
 Each ledger type supports a set of operations, which can be invoked with
@@ -2451,7 +2451,7 @@ On the other hand, if the type of either subexpression is a nominal type alias
 *T* for a `Field` or a `Uint`, the type of the other subexpression must also have
 type *T*, and the type of the result also has type *T*.
 Evaluation proceeds as if the two operands had the underlying `Field` or `Uint`
-type with the value cast back to *T*, which can result in a run-time error if *T*
+type with the value cast back to *T*, which can result in a dynamic error if *T*
 is a nominal alias for a type `Uint<0..`*n*`>` and the value is not less than *n*.
 For example:
 
@@ -2919,7 +2919,7 @@ The values of the sequence-value expressions are the input sequence values.
 The witness or circuit *fun* is then applied in turn, from index 0 up to index *n*-1,
 to an accumulator value argument and arguments taken from the input sequence values.
 The 0th (initial) accumulator value is the value of the expression *init*, and
-each subsequent *i+1*th accumulator value is the result of applying *fun* to the
+each subsequent *i+1th* accumulator value is the result of applying *fun* to the
 *ith* accumulator value and to the *ith* elements of the corresponding input
 sequence values.
 The result is the *nth* (final) accumulator value where *n* is the length of the
@@ -2928,117 +2928,118 @@ input vectors.
 ### Type cast expressions
 
 Values of one type can be cast to another, when allowed, via a *cast*, which
-takes the following form:
-
-```compact
-e as T
-```
-
-where `e` is an expression and `T` is a type.
-The effects of casting an expression `e` of type `T` to another type `U` depend
+takes the form *e* `as` *T* where *e* is an expression and *T* is a type.
+The effects of casting an expression *e* of type *T* to another type *U* depend
 on the specific types involved.
-For some types `T` and `U`, the cast is not allowed, which is a static error.
-Even if the cast is allowed, some values of type `T` might not be representable
-as values of type `U`.
-In such cases, a run-time check of the value of `e` is required and can result
-in a run-time error.
-In cases where the run-time representation of `T` is different from the run-time
-representation of `U`, the value of `e` must be converted at run time from the
+For some types *T* and *U*, the cast is not allowed, which is a static error.
+Even if the cast is allowed, some values of type *T* might not be representable
+as values of type *U*.
+In such cases, a run-time check of the value of *e* is required and can result
+in a dynamic error.
+In cases where the run-time representation of *T* is different from the run-time
+representation of *U*, the value of *e* must be converted at run time from the
 one representation to the other.
 
-The type of any (allowed) cast `e as T` is, naturally, `T`.
+The type of any (allowed) cast *e* `as` *T* is, naturally, *T*.
 
 Evaluation of a cast proceeds by evaluation of its subexpression, followed by
 any checks and conversions required by the cast.
-If a check fails, a run-time error is reported.
+If a check fails, a dynamic error is reported.
 
-TypeScript casts of the form `<T>e` are not supported in Compact.
+TypeScript casts of the form `<`*T*`>`*e* are not supported in Compact.
 
-The following rules govern when casts are allowed, when casts might cause run-time
+The following rules govern when casts are allowed, when casts might cause dynamic
 errors, and casts might require run-time conversions.
 Any cast not covered by one of the rules is not allowed.
 
 #### Upcasts
 
 - Upcasts, i.e., casts from a type to a [supertype](#subtyping-and-least-upper-bounds)
-  (e.g., from `Vector<3, Uint<8>>` to `Vector<3, Uint<16>>`), are always allowed
-  (but never required), never result in run-time errors, and, except in the case
-  where the type and the supertype are the same, might require run-time conversions.
-
-This rule has three implications:
-
-- Tuple-to-vector upcasts: if a tuple type `[T, ...]` has a vector type `Vector<n, S>`
-  (i.e., `S` is the least upper bound of the element types), then the tuple is a subtype
-  of that vector type and can be used where the vector type is expected without an
-  explicit cast. For example, values of type `[Uint<8>, Uint<16>]` can be used where a
-  value of type `Vector<2, Uint<16>>` are required.
-- Vector-to-tuple upcasts: a vector type `Vector<n, T>` is a subtype of any tuple type
-  `[S, ...]` of length `n` where `T` is a subtype of each `S`, so a vector can be used where
-  such a tuple is expected without an explicit cast. For example, values of type
-  `Vector<2, Uint<8>>` can be used where values of type `[Uint<16>, Uint<16>]` are required.
-- Since `Vector<n, T>` is the same type as the tuple `[T, ..., T]` with `n` occurrences of `T`,
-  casts between a vector type and its equivalent tuple type are always upcasts in both
-  directions.
+  (e.g., from `Vector<3, Uint<8>>` to `Vector<3, Uint<16>>`), are always allowed,
+  never result in dynamic errors, and, except in the case where the type and
+  the supertype are the same, might require run-time conversions.
+  Upcasts are never required: it is always possible to use a value of type *T*
+  as a value of a supertype of *T*.
+
+  This rule is straightfoward, but some implications regarding tuple and
+  vector types are worth noting:
+
+  - Since `Vector<`*n*, *T*`>` is the same type as `[`*T*, ⋯, *T*`]` of length *n*,
+    a cast from either of these types to the other is allowed but not required.
+  - If a tuple type `[`*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*`]`
+    [has a vector type](#subtyping-and-least-upper-bounds) `Vector<`*n*, *S*`>`,
+    then since the tuple type is a subtype of the vector type, a cast from the
+    tuple type to the vector type is allowed but not required.
+    For example, values of type `[Uint<8>, Uint<16>]` can be used where values of
+    type `Vector<2, Uint<16>>` are required.
+  - Since a vector type `Vector<`*n*, *T*`>` is a subtype of any tuple type
+    `[`*S<sub>1</sub>*, ⋯, *S<sub>n</sub>*`]` where *T* is a subtype
+    of each *S*, a cast from the vector type to the tuple type is allowed but not
+    required.
+    For example, values of type `Vector<2, Uint<8>>` can be used where
+    values of type `[Uint<16>, Uint<16>]` are required.
 
 #### Downcasts of `Field` and `Uint` types
 
-- `Uint` downcasts, i.e., casts from `Uint<m>` to `Uint<n>`, `m > n`, are always
-   allowed, always require run-time checks, and might require run-time conversions.
-   The same applies to `Field` to `Uint` casts where the maximum value of the
-   `Uint` type exceeds the maximum `Field` value, as well as `Uint` to `Field` casts
-   where the maximum value of the `Uint` type is less than or equal to the maximum
-   `Field` value.
+-  Any `Uint` downcast, i.e., any cast from `Uint<0..`*m*`>` to `Uint<0..`*n*`>`, *m* > *n*,
+   is allowed, requires a run-time check, and might require a run-time conversion.
+   The same applies to any `Field` to `Uint` casts where the maximum `Field` value
+   exceeds the maximum value of the `Uint` type, as well as any `Uint` to `Field`
+   casts where the maximum value of the `Uint` type exceeds the maximum `Field` value.
 
 #### Casts of `Boolean` to and from `Field` and `Uint`:
 
-- Casts from `Boolean` to `Field` or `Uint<0..m>` are always allowed, sometimes
-  require run-time checks, and require a run-time conversion (of `false` to `0`
+- Any cast from `Boolean` to `Field` or any `Uint` type is allowed, sometimes
+  requires a run-time check, and requires a run-time conversion (of `false` to `0`
   and `true` to `1`).
   A run-time check is required for `Uint<0..1>`.
-- Casts from `Field` or `Uint<0..m>` to `Boolean` are always allowed, cannot
-  result in run-time errors, and require a simple run-time conversion (of `0` to
+- Any casts from `Field` or any `Uint` type to `Boolean` is allowed, cannot
+  result in a dynamic error, and requires a simple run-time conversion (of `0` to
   `false` and any other value to `true`).
 
 #### Casts of Enum types to and from `Field` and `Uint`:
 
-- Casts from enum types with `n` elements to `Field` or `Uint<0..m>` are
-  always allowed, sometimes require run-time checks, and might require a run-time
-  conversion.
-  A run-time check is required for `Uint<0..m>`, `m <= n`.
-- Casts from `Field` or `Uint<0..m>` to an enum type with `n` elements are
-  always allowed, sometimes requires a run-time checks, and might require a run-time
+- Any cast from an enum type to `Field` or any `Uint` type is allowed,
+  sometimes requires a run-time check, and might require a run-time
   conversion.
-  A run-time check is required for `Field` and `Uint<0..m>`, `m > n + 1`.
+  A run-time check is required for a cast from an enum type with *n* elements
+  to `Uint<0..`*m*`>`, *n* > *m*.
+- Any cast from `Field` or any `Uint` type to an enum type is allowed,
+  sometimes requires a run-time check, and might require a run-time conversion.
+  A run-time check is required for casts from `Field`.
+  For an enum type with *n* elements, a run-type check is required for casts
+  from `Uint<0..`*m*`>`, *m* > *n*.
 
 #### Casts of `Bytes` to and from `Field` and `Uint`:
 
-- Casts from `Bytes<m>`, `m != 0`, to `Field` or `Uint<0..k>` are always allowed,
-  require a run-time check, and require a run-time conversion.
+- Any cast from `Bytes<`*m*`>`, *m* != 0, to `Field` or any `Uint` type is allowed,
+  requires a run-time check, and requires a run-time conversion.
   That is, the byte-vector value of the expression is converted into a `Field` or
-  `Uint<0..m>` with the least-significant byte of the result corresponding to the
+  `Uint` value with the least-significant byte of the result corresponding to the
   first byte in the byte vector.
-  A run-time error occurs if the result exceeds the maximum value of `Field`
-  or `Uint<0..m>`.
-- Casts from `Field` or `Uint<0..k>` to `Bytes<m>`, `m != 0`, are always allowed,
-  require a run-time check, and require a run-time conversion.
+  A dynamic error occurs if the result exceeds the maximum value of the `Field`
+  or `Uint` type.
+- Any cast from `Field` or any `Uint` type to `Bytes<`*m*`>`, *m* != 0, is allowed,
+  requires a run-time check, and requires a run-time conversion.
   That is, the integer value of the expression is converted into a byte vector
   with the first byte of the byte vector corresponding to the least-significant
   byte of the integer.
-  A run-time error occurs if the result does not fit in `m` bytes.
+  A dynamic error occurs if the result does not fit in *m* bytes.
 
 #### Casts of `Bytes` to and from `Vector` and tuple types:
 
-- Casts from `Bytes<m>` to `Vector<m, Field>` or `Vector<m, Uint<0..k>>`,
-  `k >= 256`, or `[U1, ..., Um]`, where each `Ui = Uint<0..j>` for some j >= are allowed, cannot cause a run-time error, but do require a
+- Any cast from `Bytes<`*m*`>` to `Vector<`*m*, `Field>` or
+  `Vector<`*m*, `Uint<0..`*k*`>>`, *k* ≥ 256 is allowed, cannot
+  cause a dynamic error, but does require a run-time conversion.
+- Any cast from `Bytes<`*m*`>` to tuple type `[`*T<sub>1</sub>*, ⋯, *T<sub>m</sub>*`]`,
+  where each *T<sub>i</sub>* is `Field` or `Uint<0..`*k*`>` for some *k* ≥ 256 is allowed,
+  cannot cause a dynamic error, but does require a run-time conversion.
+- Any cast from `Vector<`*m*, `Uint<0..`*k*`>>`, *k* ≤ 256, to `Bytes<`*m*`>`
+  is allowed, cannot cause a dynamic error, but does require a run-time conversion.
+- Any cast from tuple type `[`*T<sub>1</sub>*, ⋯, *T<sub>m</sub>*`]` to
+  `Bytes<`*m*`>`, where each *T<sub>i</sub>* is `Uint<0..`*k*`>` for some
+  *k* ≤ 256 is allowed, cannot cause a dynamic error, but does require a
   run-time conversion.
-- Casts from `Bytes<m>` to tuple type `[U1, ..., Um]`, where each `Ui` is
-  `Uint<0..j>` for some `j >= 256` are allowed, cannot cause a run-time error,
-  but do require a run-time conversion.
-- Casts from tuple type `[U1, ..., Um]` to `Bytes<m>`, where each `Ui` is
-  `Uint<0..j>` for some `j < 256` are allowed, cannot cause a run-time error,
-  but do require a run-time conversion.
-- Casts from `Vector<m, Uint<0..k>>`, `k < 256`, to `Bytes<m>` are allowed,
-  cannot cause a run-time error, but do require a run-time conversion.
 
 ### Ledger state operations
 
@@ -3047,10 +3048,10 @@ the ledger.
 There are two different forms of ledger operations.
 
 __Kernel operations__ are operations that do not depend on specific ledger
-state.  They can be invoked by expressions of the form `k.op(e, ...)`, where
-`k` is the name of a ledger field declared to have the special ledger-state type `Kernel`,
-`op` is the name of a builtin kernel operation, and
-`e, ...` is a comma separated sequence of zero or more argument expressions.
+state.  They can be invoked by expressions of the form *id*`.`*op*`(`*e*, ⋯, *e*`)`, where
+*id* is the name of a ledger field declared to have the special ledger-state type `Kernel`,
+*op* is the name of a builtin kernel operation, and
+*e*, ⋯, *e* is a comma separated sequence of zero or more argument expressions.
 The `CompactStandardLibrary` predefines the ledger field name `kernel` to have
 ledger type `Kernel`, so for example, the built-in `self` operation can be called
 from a circuit as follows:
@@ -3071,12 +3072,11 @@ order from left to right and then invoking the corresponding kernel operation
 with the argument values.
 
 __Ledger-state operations__ are operations on the contract's declared public ledger-state.
-In its simplest form, a ledger-state operation is an expression `F.op(e, ...)`, where `F`
-is a ledger field name
-([declared via a `ledger` field declaration](#declaring-and-maintaining-public-state)),
-`op` is the name of a ledger-state operator,
-and each `e` is an expression.
-`F` can also be another ledger-state operation, allowing ledger-state operations
+In its simplest form, a ledger-state operation is an expression
+*F*`.`*op*`(`*e*, ⋯, *e*`)`, where *F* is a ledger field name
+[declared via a `ledger` field declaration](#declaring-and-maintaining-public-state),
+*op* is the name of a ledger-state operator, and each *e* is an expression.
+*F* can also be another ledger-state operation, allowing ledger-state operations
 to be chained when the result of a ledger-state operation might itself have a
 ledger-state type.
 (Kernel operations cannot be chained, because the kernel is not a ledger-state
@@ -3092,49 +3092,49 @@ A ledger-state operation whose return type is a ledger-state type *must* be
 chained, i.e., immediately subject to another ledger-state operation.
 It is a static error if this is not the case.
 
-A ledger-state operation `F.op(e, ...)` is evaluated by evaluating `F` if `F`
+A ledger-state operation *F*`.`*op*`(`*e*, ⋯, *e*`)` is evaluated by evaluating *F* if *F*
 is itself a ledger-state operation, then evaluating the argument subexpressions
-from left to right, and then invoking the operation `op` with the argument
-values on the portion of the public ledger state identified by `F`.
+from left to right, and then invoking the operation *op* with the argument
+values on the portion of the public ledger state identified by *F*.
 
 ### Ledger-state-operation shorthands
 
 Compact supports several shorthands for common ledger-state operations.
 
 The simplest of these is a shorthand for the ledger-state operation
-`F.read()` where `F` is a ledger-state field name or itself a another
+*F*`.read()` where *F* is a ledger-state field name or itself a another
 ledger-state operation.
-If the type of `F` is a ledger-state type that supports the `read`
-operation, `F.read()` can be abbreviated, simply, to `F`.
+If the type of *F* is a ledger-state type that supports the `read`
+operation, *F*`.read()` can be abbreviated, simply, to *F*.
 
 The other shorthands all take the form of assignment statements and
-abbreviate the ledger operations `F.write(e)`, `F.increment(e), and
-`F.decrement(e)`, where `e` is an expression.
+abbreviate the ledger operations *F*`.write(`*e*`)`, *F*`.increment(`*e*`)`, and
+`F.decrement(`*e*`)`, where *e* is an expression.
 
-If the type of `F` is a ledger-state type that supports the `write`
-operation, `F.write(e)` can be abbreviated `F = e`.
-Similarly, if the type of `F` is a ledger-state type that supports the
-`increment` operation, `F.increment(e)` can be abbreviated `F += e`,
-and if the type of `F` is a ledger-state type that supports the
-`decrement` operation, `F.decrement(e)` can be abbreviated `F -= e`.
+If the type of *F* is a ledger-state type that supports the `write`
+operation, *F*`.write(`*e*`)` can be abbreviated *F* `=` *e*.
+Similarly, if the type of *F* is a ledger-state type that supports the
+`increment` operation, *F*`.increment(`*e*`)` can be abbreviated *F* `+=` *e*,
+and if the type of *F* is a ledger-state type that supports the
+`decrement` operation, *F*`.decrement(`*e*`)` can be abbreviated *F* `-=` *e*.
 
 The typing and evaluation rules for the abbreviations are identical
 to expressions they abbreviate.
 
 ### Asserts
 
-An assertion has the form `assert(e, "msg")` where `e` is an expression and `msg`
+An assertion has the form `assert(`*e*, *msg*`)` where *e* is an expression and *msg*
 is a string message.
-`e` must have a Boolean type, otherwise it is a static error.
+*e* must have a Boolean type, otherwise it is a static error.
 
 The type of every `assert` form is `[]`.
 
-Evaluation form proceeds by evaluating `e`.
-If the value of `e` is true (the assertion succeeds), the `assert` form produces
+Evaluation proceeds by evaluating *e*.
+If the value of *e* is true (the assertion succeeds), the `assert` form produces
 the value `[]`.
-If, however, the value of `e` is false (the assertion fails), the `assert` form
-halts computation of the enclosing top-level circuit or constructor with the
-message `msg`.
+If, however, the value of *e* is false (the assertion fails), it is a dynamic
+error, i.e., the `assert` form halts computation of the enclosing top-level
+circuit or constructor with the message *msg*.
 
 Each assertion is checked at runtime and constrained in-circuit.
 

From 2e0343689aa7b5346badf781012e77cd142135de Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Mon, 16 Mar 2026 11:07:04 +0100
Subject: [PATCH 23/41] latest lang-ref.mdx with supposedly proper typesetting
 of variable syntactic elements in italics

---
 docs/compact/reference/lang-ref.mdx | 141 +++++++++++++++-------------
 1 file changed, 74 insertions(+), 67 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index da3f32fe..a180c5b5 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -402,7 +402,7 @@ When the term "type" occurs in this document without any other qualifier, it mea
 either a primitive type, ledger-state type, a program-defined type, or a generic type
 parameter in scope.
 The use of ledger-state types is, at present, limited to typing the result of
-`default<T>` to obtain the default value of type `T`, and only constant bindings
+`default<`*T*`>` to obtain the default value of type *T*, and only constant bindings
 can have a ledger-state type.
 
 A generic type is not a valid type and so cannot, for example, be used as the
@@ -435,8 +435,8 @@ The following are the primitive types of Compact:
 - `Boolean` is the type of *Boolean* values.  There are only two values of
   `Boolean` type.  They are the values of the expressions `true` and `false`.
 
-- `Uint<m..n>`, where `m` is the literal `0` or generic natural-number parameter bound
-  to `0`, and where `n` is a non-zero natural number literal or a generic
+- `Uint<`*m*`..`*n*`>`, where *m* is the literal `0` or generic natural-number parameter bound
+  to `0`, and where *n* is a non-zero natural number literal or a generic
   natural-number parameter bound to a non-zero natural number, is the type of
   *bounded unsigned integer* values between `0` (inclusive) and `n` (exclusive).
   (While the lower bound is currently required to be `0`, this restriction might
@@ -451,13 +451,13 @@ The following are the primitive types of Compact:
   The current limit, if any, is given in
   [Implementation-specific limits](#implementation-specific-limits).
 
-- `Uint<n>`, where `n` is a non-zero natural number literal or generic natural-number
+- `Uint<`*n*`>`, where *n* is a non-zero natural number literal or generic natural-number
   parameter bound to a non-zero natural number, is the type of
-  *sized unsigned integer* values with binary representations using up to `n`
-  bits.  This is the same type as `Uint<0..m>` where `m` is equal to `2^n`.
+  *sized unsigned integer* values with binary representations using up to *n*
+  bits.  This is the same type as `Uint<0..`*m*`>` where *m* is equal to 2<sup>*n*</sup>.
   Sized integer types can be seen as a convenience for programmers.  `Uint<32>`,
   for example, can be more obvious and less error-prone than the equivalent
-  `Uint<0..4294967295>`.  Any Compact program that uses sized integer types can
+  `Uint<0..4294967296>`.  Any Compact program that uses sized integer types can
   be rewritten to one that uses only bounded integer types, but the converse is
   not true.
 
@@ -466,8 +466,8 @@ The following are the primitive types of Compact:
   The current maximum field value is given in
   [Implementation-specific limits](#implementation-specific-limits).
 
-- `[T, `⋯`]`, where `T`, ⋯ are zero or more comma-separated types, is the type
-  of *tuple* values with element types `T`, ⋯.
+- `[`*T*, ⋯, *T*`]`, where *T*, ⋯, *T* are zero or more comma-separated types,
+  is the type of *tuple* values with element types *T*, ⋯, *T*.
   Tuples are heterogeneous: any element type can differ from any of the others.
   The *length* of a tuple type is the number of element types.
   Two tuple types with different lengths are different types.
@@ -475,23 +475,23 @@ The following are the primitive types of Compact:
   element type of the other are also different types, though one of the tuple
   types might be a [subtype of the other](#subtyping-and-least-upper-bounds).
 
-- `Vector<n, T>`, where `n` is a natural number literal or generic natural-number
-  parameter and `T` is a type, is a shorthand notation for the tuple type
-  `[T, `⋯`]` with `n` occurrences of the type `T`.
+- `Vector<`*n*, *T*`>`, where *n* is a natural number literal or generic natural-number
+  parameter and *T* is a type, is a shorthand notation for the tuple type
+  `[`*T*, ⋯, *T*`]` with *n* occurrences of the type *T*.
   Note that a vector type and the corresponding tuple type are two different ways
   of writing exactly the same type.
   Unless otherwise specified, type rules for vector types are derived from the
   rules for the corresponding tuple type.
 
-- `Bytes<n>`, where `n` is a natural number literal or a generic natural-number parameter,
-  is the type of _byte vectors_ of length `n`.
+- `Bytes<`*n*`>`, where *n* is a natural number literal or a generic natural-number parameter,
+  is the type of _byte vectors_ of length *n*.
   `Bytes` types with different lengths are different types.
   `Bytes` types are used in the Compact standard library for hashing.
-  String literals in Compact also have a `Bytes` type, where `n` is the number
+  String literals in Compact also have a `Bytes` type, where *n* is the number
   of bytes in the UTF-8 encoding of the string.
 
-- `Opaque<s>`, where `s` is a string literal, is the type of _opaque_ values
-  with tag `s`.
+- `Opaque<`*s*`>`, where *s* is a string literal, is the type of _opaque_ values
+  with tag *s*.
   `Opaque` types with different tags are different types.
   Opaque values can be manipulated in witnesses but they are opaque to circuits.
   They are represented in circuits as their hash.
@@ -715,9 +715,9 @@ When a generic nominal type is specialized, the specialized type is a nominal ty
 ### Subtyping and least upper bounds
 
 Some Compact types are *related* to other types via subtyping.
-Informally, if a type `T` is a *subtype* of a type `S` (equivalently, `S` is a
-*supertype* of type `T`), then every value of type `T` is also a value of type `S`,
-i.e., any value of type `T` can be used where a value of type `S` is expected without
+Informally, if a type *T* is a *subtype* of a type *S* (equivalently, *S* is a
+*supertype* of type *T*), then every value of type *T* is also a value of type *S*,
+i.e., any value of type *T* can be used where a value of type *S* is expected without
 the need for an explicit cast.
 For example, a circuit or witness can be called with argument expressions whose
 types are subtypes of the corresponding parameter type annotations, and
@@ -726,34 +726,36 @@ expression whose type is a subtype of the type annotation.
 
 Subtyping is defined by the following rules:
 
-- Any type `T` is a subtype of itself (subtyping is reflexive)
-- `Uint<0..n>` is a subtype of `Uint<0..m>` if `n` is less than (or equal to) `m`
-- `Uint<0..n>` is a subtype of `Field` for all `n`
-- The tuple type `[T, `⋯`]` is a subtype of the tuple type `[S, `⋯`]`
-  if they have the same length and each type `T` is a subtype of the
-  corresponding type `S`.
+- Any type *T* is a subtype of itself (subtyping is reflexive)
+- `Uint<0..`*n*`>` is a subtype of `Uint<0..`*m*>` if *n* is less than (or equal to) *m*
+- `Uint<0..`*n*`>` is a subtype of `Field` for all *n*
+- The tuple type `[`*T*, ⋯, *T*`]` is a subtype of the tuple type `[`*S*, ⋯, *S*`]`
+  if they have the same length and each type *T* is a subtype of the
+  corresponding type *S*.
 
 The *least upper bound* (with respect to subtyping) of a non-empty set of types
-\{`T1`, ⋯, `Tn`} is a type `S` such that:
+\{*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*} is a type *S* such that:
 
-- **`S` is an upper bound:** `Ti` is a subtype of `S` for all `i` in
-    the range 1..`n`, and
-- **`S` is the least upper bound:** for all upper bounds `R` of the set of types
-    \{`T1`, ⋯, `Tn`}, `S` is a subtype of `R`.
+- __*S* is an upper bound:__ *T<sub>i</sub>* is a subtype of *S* for all *i* in
+    the range 1..*n*, and
+- __*S* is the least upper bound:__ for all upper bounds *R* of the set of types
+    \{*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*}, *S* is a subtype of *R*.
 
 Note that least upper bounds do not exist for all sets of types, because
 some types (such as `Boolean` and `Field`) are not related.
 
 **Tuple and vector types:** Every vector type has an equivalent tuple type:
-`Vector<n, T>` is equivalent to (in fact, the same type as) `[T1, `⋯`, Tn]`.
+`Vector<`*n*, *T*`>` is equivalent to (in fact, the same type as)
+`[`*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*`]`.
 The converse is not always true.
 For example, neither `[Boolean, Field]` nor `[Uint<8>, Uint<16>]` have an
 equivalent vector type.
 
-We say, however, that a tuple type `[T1, `⋯`, Tn]` with possibly distinct types `T1`, ⋯, `Tn`
-"*has a vector type*" if the least upper bound `S` of the set of types \{`T1`, ⋯, `Tn`}
+We say, however, that a tuple type `[`*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*`]` with
+possibly distinct types *T<sub>1</sub>*, ⋯, *T<sub>n</sub>* "*has a vector type*" if the
+least upper bound *S* of the set of types \{*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*}
 exists.
-In that case, the tuple type has the vector type `Vector<n, S>`.
+In that case, the tuple type has the vector type `Vector<`*n*, *S*`>`.
 Some operations over tuples (such as mapping and folding) require the tuple type
 to have a vector type.
 
@@ -765,8 +767,9 @@ vector type `Vector<2, Uint<16>>`, but the types are not equivalent.
 
 Every vector type is a subtype of the equivalent tuple type and possibly of some
 other tuple types.
-In general, a vector type `Vector<n, T>` is a subtype of a tuple type `[S1, `⋯`, Sn]`
-if `T` is a subtype of each of the types `S1`, ⋯, `Sn`.
+In general, a vector type `Vector<`*n*, *T*`>` is a subtype of a tuple type
+`[`*S<sub>1</sub>*, ⋯, *S<sub>n</sub>*`]` if *T* is a subtype of each of the
+types *S<sub>1</sub>*, ⋯, *S<sub>n</sub>*.
 The means, for instance, that a vector can often be passed to a circuit where a
 tuple is expected.
 
@@ -1026,7 +1029,7 @@ which takes the following form:
 </div>
 
 
-A module definition makes a binding from `module-name` to the module visible in
+A module definition makes a binding from *module-name* to the module visible in
 the program or module containing the module definition.
 Any bindings established by program elements within the module are not made
 visible, at least not until the module is imported.
@@ -1120,24 +1123,25 @@ import Identity<Field>;
 // id is now in scope, specialized to type Field
 ```
 
-When an import for some module *M* appears before any visible definition
-of *M*, the module is assumed to reside in the filesystem, and it is imported
+When *import-name* is an identifier and an import for *import-name* appears before any visible definition
+of *import-name*, the module is assumed to reside in the filesystem, and it is imported
 directly from there.
-If *M* is an identifier `M`, a definition for module `M` must be contained within
-the file `M.compact` in the same directory as the importing file or in one of the
+If *import-name* is an identifier *module-name*, a definition for module *module-name*
+must be contained within
+the file *module-name*`.compact` in the same directory as the importing file or in one of the
 directories in the compact path.
-If *M* is a string `"{prefix/}M"`, where `{prefix/}` is either empty or is
+If *import-name* is a string `"{`*prefix/*`}`*module-name*`" where `{`*prefix/*`}` is either empty or is
 a pathname ending in a directory separator, a definition for a module named
-`M` must be contained within a file `M.compact` that is either:
-- (a) if `{prefix/}M.compact` is an absolute pathname, then exactly at
-  `{prefix/}M.compact`, otherwise
-- (b) at `{prefix/}M.compact` relative to the directory of the importing
+*module-name* must be contained within a file *module-name*`.compact` that is either:
+- (a) if `{`*prefix/*`}`*module-name*`.compact` is an absolute pathname, then exactly at
+  `{`*prefix/*`}`*module-name*`.compact`, otherwise
+- (b) at `{`*prefix/*`}`*module-name*`.compact` relative to the directory of the importing
   file or to one of the directories in the compact path.
 Details on the search order and the mechanism for setting the compact path are
 given in [Compiler Usage](../compilation-and-tooling/compiler-usage).
 
-In any of these cases, it is a static error if `M.compact` is not found, if it
-does not contain a definition for a module named `M`, or if it contains anything
+In any of these cases, it is a static error if *module-name*`.compact` is not found, if it
+does not contain a definition for a module named *module-name*, or if it contains anything
 else other than comments and whitespace.
 
 Several examples follow.
@@ -1269,7 +1273,7 @@ It is a static error to export any other kind of binding from the top level.
 ## Include files
 
 Compact allows programs and modules to be split into multiple files and spliced
-together via `include` forms, which have the following syntax, where `file` is a
+together via `include` forms, which have the following syntax, where *file* is a
 string literal specifying a filesystem pathname for file to be included:
 
 <div className="lang-ref-table">
@@ -1279,7 +1283,7 @@ string literal specifying a filesystem pathname for file to be included:
 </div>
 
 
-`file` can be an absolute pathname, one that is relative to the directory
+*file* can be an absolute pathname, one that is relative to the directory
 of the including file, or one that is relative to one of the directories in the
 compact path.
 Details on the search order and the mechanism for setting the compact path are
@@ -1372,23 +1376,26 @@ export sealed ledger mapping: Map<Boolean, Field>;
 
 The following *ledger-state types* are supported.
 
-- `T`, for any regular Compact type `T`
+- *T*, for any regular Compact type *T*
 - `Counter`
-- `Set<T>`, for any Compact type `T`
-- `Map<K, T>`, for any Compact types `K` and `T`
-- `Map<K, V>`, for any Compact type `K` and ledger-state type `V` (see the following section)
-- `List<T>`, for any Compact type `T`
-- `MerkleTree<n, T>`, for a compile time integer 1 \< *n* ≤ 32, and any Compact
-  type `T`
-- `HistoricMerkleTree<n, T>`, for a compile time integer 1 \< *n* ≤ 32, and any
-  Compact type `T`
+- `Set<`*T*`>`, for any Compact type *T*
+- `Map<`*K*, *T*`>`, for any Compact types *K* and *T*
+- `Map<`*K*, *V*`>`, for any Compact type *K* and ledger-state type *V* (see the following section)
+- `List<`*T*`>`, for any Compact type *T*
+- `MerkleTree<`*n*, *T*`>`, for a compile time integer 1 \< *n* ≤ 32, and any Compact
+  type *T*
+- `HistoricMerkleTree<`*n*, *T*`>`, for a compile time integer 1 \< *n* ≤ 32, and any
+  Compact type *T*
 
 Each ledger type supports a set of operations, which can be invoked with
 
-`<field name>.<operation>(<arguments `⋯`>)`
+*F*`.`*op*(*e*, ⋯, *e*)
 
-A ledger field that is declared with a Compact type `T` implicitly has the type
-`Cell<T>`, which supports several operations, including `read`, `write`, and
+where *F* is a field name, *op* is the name of a ledger operation supported by
+the ledger-state type of *F*, and each *e* is an expression.
+
+A ledger field that is declared with a Compact type *T* implicitly has the type
+`Cell<`*T*`>`, which supports several operations, including `read`, `write`, and
 `reset_to_default`.
 For example:
 
@@ -1403,8 +1410,8 @@ export circuit getF(): Uint<16> {
 ```
 
 The `read` operation of the `Cell` ledger-state type can be abbreviated to,
-simply, a reference to the field name, and the `write` operation can be abbreviated
-to an assignment of the form `<field name> = expr`.
+simply, a reference to the field name, and the `write(`*e*`)` operation can be abbreviated
+to an assignment of the form *F* `=` *e*.
 So the above can be written more simply as:
 
 ```compact
@@ -1419,7 +1426,7 @@ export circuit getF(): Uint<16> {
 
 The `read` operation of the `Counter` type can be abbreviated in the same way,
 and its `increment` and `decrement` operations can be abbreviated to assignments
-of the form `<field name> += expr` and `<field name> -= expr`.
+of the form *F* `+=` *e* and *F* `-=` *e*.
 For example:
 
 ```compact
@@ -1516,7 +1523,7 @@ Notes:
 
 - Nesting is permitted only within `Map` values.  That is, nesting is not permitted in
   `Map` keys or within any ledger-state type other than `Map`.
-- Nested values must be initialized before first use.  The syntax `default<T>`
+- Nested values must be initialized before first use.  The syntax `default<`*T*`>`
   is used to create default ledger-state type values, just as it can be used to
   create default Compact type values.
 - Ledger state type values are not first-class objects, so when

From e22d9e725dd937f367024d00f475d709e3f7ee15 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Mon, 16 Mar 2026 15:14:32 +0100
Subject: [PATCH 24/41] latest versions of lang-ref, compact-grammar,
 compactkeywords, and ledger-adt

---
 docs/compact/reference/compact-grammar.mdx  | 1 +
 docs/compact/reference/compact-keywords.mdx | 1 +
 docs/compact/reference/lang-ref.mdx         | 2 +-
 docs/compact/reference/ledger-adt.mdx       | 8 +++++++-
 4 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index 1052c2c7..ece52555 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -2,6 +2,7 @@
 SPDX-License-Identifier: Apache-2.0
 copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 title: Compact grammar
+DO NOT EDIT: This file is automatically generated.
 ---
 
 # Compact grammar
diff --git a/docs/compact/reference/compact-keywords.mdx b/docs/compact/reference/compact-keywords.mdx
index 02e10527..d3ed4979 100644
--- a/docs/compact/reference/compact-keywords.mdx
+++ b/docs/compact/reference/compact-keywords.mdx
@@ -2,6 +2,7 @@
 SPDX-License-Identifier: Apache-2.0
 copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 title: Compact keywords
+DO NOT EDIT: This file is automatically generated.
 ---
 
 # Compact keywords
diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index a180c5b5..0a202584 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -2,7 +2,7 @@
 SPDX-License-Identifier: Apache-2.0
 copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 title: Compact reference
-DO NOT EDIT.  This file is automatically generated.
+DO NOT EDIT: This file is automatically generated.
 ---
 
 # Compact reference
diff --git a/docs/compact/reference/ledger-adt.mdx b/docs/compact/reference/ledger-adt.mdx
index ff524757..f7cb1c47 100644
--- a/docs/compact/reference/ledger-adt.mdx
+++ b/docs/compact/reference/ledger-adt.mdx
@@ -1,6 +1,12 @@
+SPDX-License-Identifier: Apache-2.0
+copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+title: Ledger data types
+DO NOT EDIT: This file is automatically generated.
+---
+
 # Ledger data types
 
-Compact language version 0.21.0, compiler version 0.29.101.
+Compact language version 0.22.0, compiler version 0.30.0.
 
 ## Kernel
 

From 10bb9bc3c43fafe24af67ec23991205901f2a304 Mon Sep 17 00:00:00 2001
From: JosephDenman <joseph.denman@iohk.io>
Date: Mon, 16 Mar 2026 10:20:17 -0400
Subject: [PATCH 25/41] EXPERIMENTING

Signed-off-by: JosephDenman <joseph.denman@iohk.io>
---
 docs/compact/reference/lang-ref.mdx | 32 ++++++++++++++---------------
 docs/compact/reference/writing.mdx  |  4 ++--
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 0a202584..0df36ad4 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -55,7 +55,7 @@ Compact deviates intentionally from TypeScript, however, in several important wa
   The basics of this are discussed in the
   [description of `disclose`](#explicit-disclosure), and a more thorough description
   and discussion appears in the separate document
-  [Explicit disclosure in Compact](explicit-disclosure).
+  [Explicit disclosure in Compact](./explicit-disclosure.mdx).
 
 Like TypeScript, Compact compiles into JavaScript, but it also produces a TypeScript
 definition file so it effectively also compiles into TypeScript.
@@ -86,9 +86,9 @@ statements and expressions that can appear within circuit and constructor
 bodies.
 Finally, it discusses the TypeScript target.
 
-[Writing a contract](writing) provides a small example of what a
+[Writing a contract](./writing.mdx) provides a small example of what a
 Compact program looks like.  It also introduces the basic building blocks of a
-Compact contract.  [The full grammar of Compact](compact-grammar) is provided
+Compact contract.  [The full grammar of Compact](./compact-grammar.mdx) is provided
 separately.
 
 ## Notation
@@ -195,7 +195,7 @@ reserved for future use in Compact, e.g., `self` and `class`.
 Still others, specifically every identifier that begins with `__compact`,
 are reserved for use by the compiler.
 A comprehensive list of keywords and reserved words is given
-in [keywords and reserved words](compact-keywords).
+in [keywords and reserved words](./compact-keywords.mdx).
 
 The remaining identifiers can be used to name specific instances of various kinds
 of entities, including modules, types, generic parameters, ledger fields, function
@@ -1138,7 +1138,7 @@ a pathname ending in a directory separator, a definition for a module named
 - (b) at `{`*prefix/*`}`*module-name*`.compact` relative to the directory of the importing
   file or to one of the directories in the compact path.
 Details on the search order and the mechanism for setting the compact path are
-given in [Compiler Usage](../compilation-and-tooling/compiler-usage).
+given in [Compiler Usage](../compilation-and-tooling/compiler-usage.mdx).
 
 In any of these cases, it is a static error if *module-name*`.compact` is not found, if it
 does not contain a definition for a module named *module-name*, or if it contains anything
@@ -1287,7 +1287,7 @@ string literal specifying a filesystem pathname for file to be included:
 of the including file, or one that is relative to one of the directories in the
 compact path.
 Details on the search order and the mechanism for setting the compact path are
-given in [Compiler Usage](../compilation-and-tooling/compiler-usage).
+given in [Compiler Usage](../compilation-and-tooling/compiler-usage.mdx).
 
 It is a static error if the file is not present or cannot be read.
 If present and readable, the file must contain a sequence of syntactically
@@ -1469,7 +1469,7 @@ not have the same value when the proof is checked as when the transaction is
 created, the proof fails and the transaction is rejected.
 
 A comprehensive description of ledger-state types and operations can be found in
-the Compact [ledger data type documentation](ledger-adt).
+the Compact [ledger data type documentation](./ledger-adt.mdx).
 
 ### Nested state types in the `Map` type
 
@@ -3072,7 +3072,7 @@ circuit f(): ContractAddress {
 
 The static type of a kernel operation expression is the return type of the
 corresponding kernel operation according to the
-the Compact [ledger data type documentation](ledger-adt).
+the Compact [ledger data type documentation](./ledger-adt.mdx).
 
 Kernel operations are evaluated by evaluating the argument subexpressions in
 order from left to right and then invoking the corresponding kernel operation
@@ -3093,7 +3093,7 @@ described below in [Ledger-state-operation shorthands](#ledger-state-operation-s
 
 The static type of a ledger-state operation is the return type of the
 corresponding ledger-state operation according to the
-the Compact [ledger data type documentation](ledger-adt).
+the Compact [ledger data type documentation](./ledger-adt.mdx).
 This might be a Compact type or it might be a ledger-state type.
 A ledger-state operation whose return type is a ledger-state type *must* be
 chained, i.e., immediately subject to another ledger-state operation.
@@ -3227,7 +3227,7 @@ scope of this document, but a few things are worth noting:
   input.
 
 More details are given in
-[Explicit Disclosure in Compact: The Midnight "Witness Protection Program"](explicit-disclosure).
+[Explicit Disclosure in Compact: The Midnight "Witness Protection Program"](./explicit-disclosure.mdx).
 
 ## Run-time data representation
 
@@ -3388,15 +3388,15 @@ These limits may change in future versions of the compiler.
 
 ### Compact formal grammar
 
-See [here](compact-grammar).
+See [here](./compact-grammar.mdx).
 
 ### Compact keywords and reserved words
 
-See [here](compact-keywords).
+See [here](./compact-keywords.mdx).
 
 ### Compact ledger-state types and operations
 
-See [here](ledger-adt).
+See [here](./ledger-adt.mdx).
 
 ### Runtime API
 
@@ -3404,12 +3404,12 @@ See [here](/api-reference/compact-runtime)
 
 ### Compiler usage
 
-See [here](../compilation-and-tooling/compiler-usage).
+See [here](../compilation-and-tooling/compiler-usage.mdx).
 
 ### Explicit disclosure in Compact
 
-See [here](explicit-disclosure).
+See [here](./explicit-disclosure.mdx).
 
 ### Writing a contract in Compact
 
-See [here](writing).
+See [here](./writing.mdx).
diff --git a/docs/compact/reference/writing.mdx b/docs/compact/reference/writing.mdx
index 15f28739..d1a2d1c6 100644
--- a/docs/compact/reference/writing.mdx
+++ b/docs/compact/reference/writing.mdx
@@ -89,7 +89,7 @@ export circuit get(): Uint<64> {
 
 Here `export` marks this circuit as an entry point to the smart contract, and
 `assert` ensures that it can only be used when the contract is in the correct
-state. The [language reference](./reference/lang-ref.mdx#circuits) details permissible contents
+state. The [language reference](./lang-ref.mdx#circuits) details permissible contents
 of `circuit`s.
 
 ## Local state and computations
@@ -238,7 +238,7 @@ being suitable for storage in a contract's `ledger` state.
 ## Next steps
 
 This section continues with a more detailed overview of the Compact language.
-Alternatively, you may wish to jump to a [more detailed example](../tutorials/beginner/bboard-contract.mdx)
+Alternatively, you may wish to jump to a [more detailed example](../../../tutorials/bboard/smart-contract.mdx)
 that showcases some more interesting things you can do with a DApp on Midnight.
 While this section has focused on the Compact language,
 the section about how Midnight works

From 47450bb0f1a2ed5449764dae2eb8878498483147 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Mon, 16 Mar 2026 21:04:04 +0100
Subject: [PATCH 26/41] latest versions of the generated language documents
 with DO NOT EDIT lines that don't make docusaurus choke.  also a change to
 custom.css: added a separate .lang-ref code { } section block so that choices
 we make for the language reference don't have to be adopted for the site as a
 whole. reverted the plain code {} section back to what is currently in main.

---
 docs/compact/reference/compact-grammar.mdx |  2 ++
 docs/compact/reference/lang-ref.mdx        | 24 ++--------------------
 src/css/custom.css                         | 17 ++++++++++++++-
 3 files changed, 20 insertions(+), 23 deletions(-)

diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index ece52555..74d5f1d1 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -5,6 +5,7 @@ title: Compact grammar
 DO NOT EDIT: This file is automatically generated.
 ---
 
+<div className="lang-ref">
 # Compact grammar
 
 Compact language version 0.22.0.
@@ -603,3 +604,4 @@ A version literal takes the form nat.nat representing major and minor versions o
 | *arrow-parameter-list* | &xrarr; | `(` [*optionally-typed-pattern*](#optionally-typed-pattern) `,` ⋯ `,` [*optionally-typed-pattern*](#optionally-typed-pattern) `,`<sup>opt</sup> `)` |
 </div>
 
+</div>
diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 0a202584..c1d48c0f 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -5,6 +5,7 @@ title: Compact reference
 DO NOT EDIT: This file is automatically generated.
 ---
 
+<div className="lang-ref">
 # Compact reference
 
 ## Overview
@@ -327,7 +328,6 @@ generic type parameters.
 |                 | \|      | [*tvar-name*](#terminal-names)                                                                                                                |
 </div>
 
-
 Generic entities must be *specialized* at the point of use to produce non-generic
 entities at compile time by supplying them with *generic arguments*.
 Any attempt to use a generic entity without specializing it is a static error.
@@ -343,7 +343,6 @@ numeric value of a generic parameter.
 |         | \|      | [*type*](#primitive-types)                                                                                                  |
 </div>
 
-
 The syntax of types allows for type references, including references to generic
 parameters, so any generic argument can pass along the value of a generic type
 or natural-number parameter that is visible at the point of specialization.
@@ -431,7 +430,6 @@ The following are the primitive types of Compact:
 |         | \|      | [*id*](#terminal-names)                                                                   |
 </div>
 
-
 - `Boolean` is the type of *Boolean* values.  There are only two values of
   `Boolean` type.  They are the values of the expressions `true` and `false`.
 
@@ -515,7 +513,6 @@ Structure types are defined via `struct` declarations with the following form:
 | *typed-id*           | &xrarr; | [*id*](#terminal-names) `:` [*type*](#primitive-types)                                                                                                                                                                                            |
 </div>
 
-
 A structure declaration has a sequence of named fields which must be separated
 either by commas or by semicolons.  Comma and semicolon separators cannot be
 mixed within a single structure declaration.  A trailing separator is allowed,
@@ -628,7 +625,6 @@ Enumeration types are defined via `enum` declarations with the following form:
 | *enum-declaration* | &xrarr; | `export`<sup>opt</sup> `enum` [*enum-name*](#terminal-names) `{` [*id*](#terminal-names) `,` ⋯¹ `,` [*id*](#terminal-names) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-
 An enumeration declaration has a non-empty sequence of named elements separated by commas.
 A trailing comma is allowed but not required.
 
@@ -661,7 +657,6 @@ Type aliases can be created via `type` declarations of the form:
 | *type-alias-declaration* | &xrarr; | `export`<sup>opt</sup> `new`<sup>opt</sup> `type` [*type-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> `=` [*type*](#primitive-types) `;` |
 </div>
 
-
 Within the scope of a type-alias declaration of *type-name* for *type*, *type-name*
 is itself a type.
 Type aliases are either structural or nominal, depending on whether the optional
@@ -788,7 +783,6 @@ are specified via patterns:
 |                      | \|      | [*id*](#terminal-names) `:` [*pattern*](#patterns-and-destructuring)                                                                              |
 </div>
 
-
 In its simplest form, a pattern is just an identifier.
 For example, in the code below, the parameter of `sumTuple` is the identifier
 `x` and the targets of the two const bindings are the identifiers `a` and `b`.
@@ -947,7 +941,6 @@ A compact program is a sequence of zero or more program elements.
 |                   | \|      | [*circuit-definition*](#circuit-definitions)                               |
 </div>
 
-
 Briefly:
 
 - A [pragma form](#pragmas) allows the program to declare the version of the compiler and/or the language that it requires
@@ -999,7 +992,6 @@ version (*id* = `compiler_version`) or the language version (*id* = `language_ve
 |                            | \|      | [*version*](#terminal-names)                                             |
 </div>
 
-
 *version* is a dot-separated pair or trio of natural numbers, so along
 with *nat* this allows *version* to be either a single natural number,
 a pair of natural numbers separated by a `.`, or a trio of natural numbers
@@ -1028,7 +1020,6 @@ which takes the following form:
 | *module-definition* | &xrarr; | `export`<sup>opt</sup> `module` [*module-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> `{` [*program-element*](#programs) ⋯ [*program-element*](#programs) `}` |
 </div>
 
-
 A module definition makes a binding from *module-name* to the module visible in
 the program or module containing the module definition.
 Any bindings established by program elements within the module are not made
@@ -1053,7 +1044,6 @@ from the module in one of two ways: (1) by prefixing the definition with the
 | *export-form* | &xrarr; | `export` `{` [*id*](#terminal-names) `,` ⋯ `,` [*id*](#terminal-names) `,`<sup>opt</sup> `}` `;`<sup>opt</sup> |
 </div>
 
-
 For example, the following module exports `G` and `S` but not `F`.
 
 ```compact
@@ -1088,7 +1078,6 @@ some or all of its exported bindings visible there, potentially with a prefix.
 | *import-prefix*    | &xrarr; | `prefix` [*id*](#terminal-names)                                                                                                                                                         |
 </div>
 
-
 For example:
 
 ```compact
@@ -1282,7 +1271,6 @@ string literal specifying a filesystem pathname for file to be included:
 | *include-form* | &xrarr; | `include` [*file*](#terminal-names) `;` |
 </div>
 
-
 *file* can be an absolute pathname, one that is relative to the directory
 of the including file, or one that is relative to one of the directories in the
 compact path.
@@ -1320,7 +1308,6 @@ provided by the TypeScript driver.
 | *simple-parameter-list* | &xrarr; | `(` [*typed-id*](#structure-types) `,` ⋯ `,` [*typed-id*](#structure-types) `,`<sup>opt</sup> `)`                                                                                                                                     |
 </div>
 
-
 Witness declarations can appear anywhere among the program elements of
 a module or the contract's top level.
 
@@ -1358,7 +1345,6 @@ top level.
 | *ledger-declaration* | &xrarr; | `export`<sup>opt</sup> `sealed`<sup>opt</sup> `ledger` [*id*](#terminal-names) `:` [*type*](#primitive-types) `;` |
 </div>
 
-
 A ledger declaration binds a ledger field name to one of a
 set of predefined [ledger-state types](#ledger-state-types).
 For instance:
@@ -1595,7 +1581,6 @@ program's top level.
 | *typed-pattern*          | &xrarr; | [*pattern*](#patterns-and-destructuring) `:` [*type*](#primitive-types)                                               |
 </div>
 
-
 The constructor, if any, is typically used to initialize public state
 and can also be used to initialize private state through witness
 calls.
@@ -1653,7 +1638,6 @@ Named circuit definitions have the following syntax:
 | *circuit-definition* | &xrarr; | `export`<sup>opt</sup> `pure`<sup>opt</sup> `circuit` [*function-name*](#terminal-names) [*gparams*](#generic-parameters-and-arguments)<sup>opt</sup> [*pattern-parameter-list*](#contract-constructor) `:` [*type*](#primitive-types) [*block*](#blocks) |
 </div>
 
-
 A circuit definition binds *function-name* to a circuit with the given parameters,
 type, and body.
 The optional `export` modifier indicates that the circuit binding should
@@ -1734,7 +1718,6 @@ A *block* is a group of statements enclosed in braces:
 | *block* | &xrarr; | `{` [*stmt*](#statements) ⋯ [*stmt*](#statements) `}` |
 </div>
 
-
 A block can be used in place of a single statement anywhere a single statement
 is allowed, which is useful for allowing multiple statements to be evaluated by the
 "then" and "else" parts of an `if` statement or the body of a `for` statement.
@@ -1771,7 +1754,6 @@ The syntax of Compact statements is summarized by the following grammar snippet:
 |                    | \|      | [*block*](#blocks)                                                                                                              |
 </div>
 
-
 The snippet shows that a statement (*stmt*) is either a one-armed `if` expression
 or some other kind of statement (*stmt<sub>0</sub>*).
 This structure is used to enforce the restriction that the "then" part of a
@@ -1815,7 +1797,6 @@ where each *cbinding* takes the following form:
 |                            | \|      | [*typed-pattern*](#contract-constructor)                                   |
 </div>
 
-
 A `const` statement is typed by typing each of its *cbinding* subforms.
 A *cbinding* subform is typed by typing the expression on the right-hand side
 of the `=`.
@@ -2061,7 +2042,6 @@ The syntax of Compact expressions is summarized by the following grammar snippet
 |                    | \|      | `...` [*expr*](#expressions)                                                                                                                                 |
 </div>
 
-
 Every Compact expression must be well-typed (free from static type errors).
 If any expression within a program contains a static type error, it is a static
 error: the Compact compiler reports the error and does not produce any target code
@@ -2772,7 +2752,6 @@ The function expression *fun* can take one of the following forms:
 | *return-type*          | &xrarr; | `:` [*type*](#primitive-types)                                                                                                             |
 </div>
 
-
 In the simplest form, *fun* is just a identifier *id* referring to a witness or
 named circuit.
 When *id* refers to a generic witness or circuit, it must be fully specialized via
@@ -3413,3 +3392,4 @@ See [here](explicit-disclosure).
 ### Writing a contract in Compact
 
 See [here](writing).
+</div>
diff --git a/src/css/custom.css b/src/css/custom.css
index 4af76798..1a581b92 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -522,13 +522,13 @@ a:hover {
 code {
   font-family: var(--ifm-font-family-monospace);
   font-variant-ligatures: none;
+  word-break: break-all;
   overflow-wrap: break-word;
   white-space: pre-wrap;
   vertical-align: baseline !important;
   background-color: transparent;
   padding: 0;
   border-radius: 0;
-  border: none;
 }
 
 pre {
@@ -651,6 +651,21 @@ pre {
   text-decoration: none !important;
 }
 
+/* The lang-ref code style is specific to the Compact language reference */
+/* DO NOT ALTER WITHOUT CHECKING WITH THE SHIELDED LANGUAGES TEAM. */
+/* The style essential to the readability of the language reference */
+.lang-ref code {
+  font-family: var(--ifm-font-family-monospace);
+  font-variant-ligatures: none;
+  overflow-wrap: break-word;
+  white-space: pre-wrap;
+  vertical-align: baseline !important;
+  background-color: transparent;
+  padding: 0;
+  border-radius: 0;
+  border: none;
+}
+
 /* The following table is specific to the Compact reference document */
 .lang-ref-table {
   border-collapse: separate;

From 59c7232090cdb983e3108f247ec4291a487bd069 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Mon, 16 Mar 2026 21:33:30 +0100
Subject: [PATCH 27/41] latest lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 39 +++++++++++++++--------------
 1 file changed, 20 insertions(+), 19 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 9a8d425d..96c7558b 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -44,6 +44,7 @@ Compact deviates intentionally from TypeScript, however, in several important wa
   [generic parameters](#generic-parameters-and-arguments), which include size as
   well as type parameters.
 - Because every Compact program must compile into a set of finite proving circuits,
+  the language is *bounded*:
   all Compact types have sizes that are fixed at compile time, loops are bounded either
   by constant bounds or by the size of an object of constant size, and recursion
   is disallowed.
@@ -56,7 +57,7 @@ Compact deviates intentionally from TypeScript, however, in several important wa
   The basics of this are discussed in the
   [description of `disclose`](#explicit-disclosure), and a more thorough description
   and discussion appears in the separate document
-  [Explicit disclosure in Compact](./explicit-disclosure.mdx).
+  [Explicit disclosure in Compact](explicit-disclosure).
 
 Like TypeScript, Compact compiles into JavaScript, but it also produces a TypeScript
 definition file so it effectively also compiles into TypeScript.
@@ -87,9 +88,9 @@ statements and expressions that can appear within circuit and constructor
 bodies.
 Finally, it discusses the TypeScript target.
 
-[Writing a contract](./writing.mdx) provides a small example of what a
+[Writing a contract](writing) provides a small example of what a
 Compact program looks like.  It also introduces the basic building blocks of a
-Compact contract.  [The full grammar of Compact](./compact-grammar.mdx) is provided
+Compact contract.  [The full grammar of Compact](compact-grammar) is provided
 separately.
 
 ## Notation
@@ -196,7 +197,7 @@ reserved for future use in Compact, e.g., `self` and `class`.
 Still others, specifically every identifier that begins with `__compact`,
 are reserved for use by the compiler.
 A comprehensive list of keywords and reserved words is given
-in [keywords and reserved words](./compact-keywords.mdx).
+in [keywords and reserved words](compact-keywords).
 
 The remaining identifiers can be used to name specific instances of various kinds
 of entities, including modules, types, generic parameters, ledger fields, function
@@ -343,7 +344,7 @@ numeric value of a generic parameter.
 |         | \|      | [*type*](#primitive-types)                                                                                                  |
 </div>
 
-The syntax of types allows for type references, including references to generic
+[The syntax of types](#compact-types) allows for type references, including references to generic
 parameters, so any generic argument can pass along the value of a generic type
 or natural-number parameter that is visible at the point of specialization.
 
@@ -636,7 +637,7 @@ enum Arrow { up, down, left, right };
 ```
 
 Within the scope of this declaration, a value of type `Arrow` can have one of
-three values, selected via `Arrow.up`, `Arrow.down`, `Arrow.left`, and `Arrow.right`.
+four values, selected via `Arrow.up`, `Arrow.down`, `Arrow.left`, and `Arrow.right`.
 
 Two enumeration types are the same if they have the same name and the same element
 names (in the same order) and distinct otherwise.
@@ -765,7 +766,7 @@ other tuple types.
 In general, a vector type `Vector<`*n*, *T*`>` is a subtype of a tuple type
 `[`*S<sub>1</sub>*, ⋯, *S<sub>n</sub>*`]` if *T* is a subtype of each of the
 types *S<sub>1</sub>*, ⋯, *S<sub>n</sub>*.
-The means, for instance, that a vector can often be passed to a circuit where a
+This means, for instance, that a vector can often be passed to a circuit where a
 tuple is expected.
 
 ## Patterns and destructuring
@@ -1127,7 +1128,7 @@ a pathname ending in a directory separator, a definition for a module named
 - (b) at `{`*prefix/*`}`*module-name*`.compact` relative to the directory of the importing
   file or to one of the directories in the compact path.
 Details on the search order and the mechanism for setting the compact path are
-given in [Compiler Usage](../compilation-and-tooling/compiler-usage.mdx).
+given in [Compiler Usage](../compilation-and-tooling/compiler-usage).
 
 In any of these cases, it is a static error if *module-name*`.compact` is not found, if it
 does not contain a definition for a module named *module-name*, or if it contains anything
@@ -1275,7 +1276,7 @@ string literal specifying a filesystem pathname for file to be included:
 of the including file, or one that is relative to one of the directories in the
 compact path.
 Details on the search order and the mechanism for setting the compact path are
-given in [Compiler Usage](../compilation-and-tooling/compiler-usage.mdx).
+given in [Compiler Usage](../compilation-and-tooling/compiler-usage).
 
 It is a static error if the file is not present or cannot be read.
 If present and readable, the file must contain a sequence of syntactically
@@ -1455,7 +1456,7 @@ not have the same value when the proof is checked as when the transaction is
 created, the proof fails and the transaction is rejected.
 
 A comprehensive description of ledger-state types and operations can be found in
-the Compact [ledger data type documentation](./ledger-adt.mdx).
+the Compact [ledger data type documentation](ledger-adt).
 
 ### Nested state types in the `Map` type
 
@@ -3051,7 +3052,7 @@ circuit f(): ContractAddress {
 
 The static type of a kernel operation expression is the return type of the
 corresponding kernel operation according to the
-the Compact [ledger data type documentation](./ledger-adt.mdx).
+the Compact [ledger data type documentation](ledger-adt).
 
 Kernel operations are evaluated by evaluating the argument subexpressions in
 order from left to right and then invoking the corresponding kernel operation
@@ -3072,7 +3073,7 @@ described below in [Ledger-state-operation shorthands](#ledger-state-operation-s
 
 The static type of a ledger-state operation is the return type of the
 corresponding ledger-state operation according to the
-the Compact [ledger data type documentation](./ledger-adt.mdx).
+the Compact [ledger data type documentation](ledger-adt).
 This might be a Compact type or it might be a ledger-state type.
 A ledger-state operation whose return type is a ledger-state type *must* be
 chained, i.e., immediately subject to another ledger-state operation.
@@ -3206,7 +3207,7 @@ scope of this document, but a few things are worth noting:
   input.
 
 More details are given in
-[Explicit Disclosure in Compact: The Midnight "Witness Protection Program"](./explicit-disclosure.mdx).
+[Explicit Disclosure in Compact: The Midnight "Witness Protection Program"](explicit-disclosure).
 
 ## Run-time data representation
 
@@ -3367,15 +3368,15 @@ These limits may change in future versions of the compiler.
 
 ### Compact formal grammar
 
-See [here](./compact-grammar.mdx).
+See [here](compact-grammar).
 
 ### Compact keywords and reserved words
 
-See [here](./compact-keywords.mdx).
+See [here](compact-keywords).
 
 ### Compact ledger-state types and operations
 
-See [here](./ledger-adt.mdx).
+See [here](ledger-adt).
 
 ### Runtime API
 
@@ -3383,13 +3384,13 @@ See [here](/api-reference/compact-runtime)
 
 ### Compiler usage
 
-See [here](../compilation-and-tooling/compiler-usage.mdx).
+See [here](../compilation-and-tooling/compiler-usage).
 
 ### Explicit disclosure in Compact
 
-See [here](./explicit-disclosure.mdx).
+See [here](explicit-disclosure).
 
 ### Writing a contract in Compact
 
-See [here](./writing.mdx).
+See [here](writing).
 </div>

From 04e26504575c841a3f5a66aa390998afd5af327e Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Mon, 16 Mar 2026 22:50:35 +0100
Subject: [PATCH 28/41] latest lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 40 +++++++++++++++++------------
 1 file changed, 23 insertions(+), 17 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 96c7558b..bf91348e 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -15,10 +15,11 @@ designed to be used in combination with TypeScript for writing smart contracts
 for the three-part structure of Midnight, where contracts have the following
 components:
 
-- a replicated component on a public ledger
-- a zero-knowledge circuit component, confidentially proving the correctness of
-  the former
-- a local, off-chain component that can perform arbitrary code
+- a replicated component on a public ledger,
+- a zero-knowledge circuit component that confidentially proofs the
+  replicated component resulted from a valid execution according to
+  the logic of the contract, and
+- a local, off-chain component that can perform arbitrary code.
 
 Each Compact program (also referred to as a *contract*) can contain several
 kinds of program elements:
@@ -460,15 +461,16 @@ The following are the primitive types of Compact:
   be rewritten to one that uses only bounded integer types, but the converse is
   not true.
 
-- `Field` represents the set of unsigned integer values up to the maximum value of
-  the scalar prime field of the ZK proving system.
+- `Field` represents the set of unsigned intergers with values up to the order of
+  the native prime field of the ZK proving system.
   The current maximum field value is given in
   [Implementation-specific limits](#implementation-specific-limits).
 
-- `[`*T*, ⋯, *T*`]`, where *T*, ⋯, *T* are zero or more comma-separated types,
-  is the type of *tuple* values with element types *T*, ⋯, *T*.
+- `[`*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*`]`, where *T<sub>1</sub>*, ⋯,
+  *T<sub>n</sub>* are zero or more comma-separated types, is the type of *tuple*
+  values with element types *T<sub>1</sub>*, ⋯, *T<sub>n</sub>*.
   Tuples are heterogeneous: any element type can differ from any of the others.
-  The *length* of a tuple type is the number of element types.
+  The *length* of a tuple type is the number *n* of element types.
   Two tuple types with different lengths are different types.
   Two tuple types where any element type of one differs from the corresponding
   element type of the other are also different types, though one of the tuple
@@ -724,10 +726,14 @@ Subtyping is defined by the following rules:
 
 - Any type *T* is a subtype of itself (subtyping is reflexive)
 - `Uint<0..`*n*`>` is a subtype of `Uint<0..`*m*>` if *n* is less than (or equal to) *m*
-- `Uint<0..`*n*`>` is a subtype of `Field` for all *n*
-- The tuple type `[`*T*, ⋯, *T*`]` is a subtype of the tuple type `[`*S*, ⋯, *S*`]`
-  if they have the same length and each type *T* is a subtype of the
-  corresponding type *S*.
+- `Uint<0..`*n*`>` is a subtype of `Field` if *n* is less than or equal to
+  the maximum field value.
+- `Field` is a subtype of `Uint<0..`*n*`>` if *n* is greater than or equal to
+  the maximum field value.
+- The tuple type `[`*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*`]` is a subtype of the
+  tuple type `[`*S<sub>1</sub>*, ⋯, *S<sub>n</sub>*`]`
+  if they have the same length and each type *T<sub>i</sub>* is a subtype of the
+  corresponding type *S<sub>i</sub>*.
 
 The *least upper bound* (with respect to subtyping) of a non-empty set of types
 \{*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*} is a type *S* such that:
@@ -742,7 +748,7 @@ some types (such as `Boolean` and `Field`) are not related.
 
 **Tuple and vector types:** Every vector type has an equivalent tuple type:
 `Vector<`*n*, *T*`>` is equivalent to (in fact, the same type as)
-`[`*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*`]`.
+`[`*T*, ⋯, *T*`]` with *n* occurrences of *T*.
 The converse is not always true.
 For example, neither `[Boolean, Field]` nor `[Uint<8>, Uint<16>]` have an
 equivalent vector type.
@@ -1430,10 +1436,10 @@ export circuit getF(): Uint<64> {
 }
 ```
 
-The ledger-state types are designed in to minimize the extent to which a circuit
+The ledger-state types are designed to minimize the extent to which a circuit
 proof depends upon the exact value of a ledger-state field as of when a transaction
-is created to minimize the chance of the transaction being rejected when the
-proof is checked on chain.
+is created in order to minimize the chance of the transaction being rejected when
+the proof is checked on chain.
 For example, `Counter` increment and decrement do not commit to the current value
 of the counter.
 While the preceding example could be written using a Cell instead:

From 0718800fa9cea5ebb3bddaf075afcb216ce0a844 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Mon, 16 Mar 2026 23:05:47 +0100
Subject: [PATCH 29/41] latest lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index bf91348e..f69be4de 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -3361,8 +3361,8 @@ Compact compiler version 1.0 limits certain datatype values and sizes:
 This value is dictated by the scalar field size of the ZK proving system.
 - The maximum value of a `Uint` value is
 452312848583266388373324160190187140051835877600158453279131187530910662655.
-This value is `(256^k)-1` where `k` is the number of bytes that fits in
-a scalar field value of the ZK proving system.
+This value is `(256^k)-1` where `k` is the number of bytes (31) that fits in
+a `Field`.
 - The maximum length of a vector or byte-vector is `2^24 = 16777216`.
 This value is chosen as a reasonable upper bound that helps prevent the compiler
 from looping indefinitely on programs that operate on excessively large vector

From 8a212c1dd1c1b79e58f42b27f3876eafed37dbb8 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Wed, 18 Mar 2026 00:06:32 +0100
Subject: [PATCH 30/41] latest lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 86 ++++++++++++++++-------------
 1 file changed, 48 insertions(+), 38 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index f69be4de..b72a3bb6 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -722,14 +722,14 @@ types are subtypes of the corresponding parameter type annotations, and
 a constant binding statement with a type annotation can be initialized with an
 expression whose type is a subtype of the type annotation.
 
-Subtyping is defined by the following rules:
+Subtyping is exclusively defined by the following rules:
 
 - Any type *T* is a subtype of itself (subtyping is reflexive)
 - `Uint<0..`*n*`>` is a subtype of `Uint<0..`*m*>` if *n* is less than (or equal to) *m*
-- `Uint<0..`*n*`>` is a subtype of `Field` if *n* is less than or equal to
-  the maximum field value.
-- `Field` is a subtype of `Uint<0..`*n*`>` if *n* is greater than or equal to
+- `Uint<0..`*n*`>` is a subtype of `Field` if *n-1* is less than or equal to
   the maximum field value.
+  (Whether `Field` is a subtype of `Uint<0..`*n*`>` if *n-1* is greater than
+  the maximum field value is currently unspecified.)
 - The tuple type `[`*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*`]` is a subtype of the
   tuple type `[`*S<sub>1</sub>*, ⋯, *S<sub>n</sub>*`]`
   if they have the same length and each type *T<sub>i</sub>* is a subtype of the
@@ -746,13 +746,24 @@ The *least upper bound* (with respect to subtyping) of a non-empty set of types
 Note that least upper bounds do not exist for all sets of types, because
 some types (such as `Boolean` and `Field`) are not related.
 
-**Tuple and vector types:** Every vector type has an equivalent tuple type:
-`Vector<`*n*, *T*`>` is equivalent to (in fact, the same type as)
+**Tuple and vector types:**
+Every vector type is equivalent to some tuple type.
+Specifically, as noted in the earlier section on [Primitive types](#primitive-types),
+the vector type `Vector<`*n*, *T*`>` is equivalent to the tuple type
 `[`*T*, ⋯, *T*`]` with *n* occurrences of *T*.
-The converse is not always true.
-For example, neither `[Boolean, Field]` nor `[Uint<8>, Uint<16>]` have an
-equivalent vector type.
 
+Thus the above subtyping rule for tuple types applies to vector types as well:
+every vector type is a subtype of the equivalent tuple type and possibly of some
+other tuple and vector types.
+In general, a vector type `Vector<`*n*, *T*`>` is a subtype of a tuple type
+`[`*S<sub>1</sub>*, ⋯, *S<sub>n</sub>*`]` if *T* is a subtype of each of the
+types *S<sub>1</sub>*, ⋯, *S<sub>n</sub>*.
+This means, for instance, that a vector can often be passed to a circuit where a
+tuple is expected.
+
+On the other hand, tuple types do not always have equivalent vector types.
+For example, neither `[Boolean, Field]` nor `[Uint<8>, Uint<16>]` is
+equivalent to any vector type.
 We say, however, that a tuple type `[`*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*`]` with
 possibly distinct types *T<sub>1</sub>*, ⋯, *T<sub>n</sub>* "*has a vector type*" if the
 least upper bound *S* of the set of types \{*T<sub>1</sub>*, ⋯, *T<sub>n</sub>*}
@@ -764,16 +775,8 @@ to have a vector type.
 When a tuple type has a vector type, the tuple type is a subtype of the vector
 type, but it might not be the same as the vector type.
 For example, `[Uint<16>, Uint<16>]` has the vector type `Vector<2, Uint<16>>`,
-and the two types are equivalent, whereas `[Uint<8>, Uint<16>]` also has the
-vector type `Vector<2, Uint<16>>`, but the types are not equivalent.
-
-Every vector type is a subtype of the equivalent tuple type and possibly of some
-other tuple types.
-In general, a vector type `Vector<`*n*, *T*`>` is a subtype of a tuple type
-`[`*S<sub>1</sub>*, ⋯, *S<sub>n</sub>*`]` if *T* is a subtype of each of the
-types *S<sub>1</sub>*, ⋯, *S<sub>n</sub>*.
-This means, for instance, that a vector can often be passed to a circuit where a
-tuple is expected.
+and the two types are the same, whereas `[Uint<8>, Uint<16>]` also has the
+vector type `Vector<2, Uint<16>>`, but the types are not the same.
 
 ## Patterns and destructuring
 
@@ -2398,31 +2401,37 @@ and If *v* is `false`, the value of the Boolean negation expression is `true`.
 ### Binary arithmetic expressions
 
 Binary arithmetic expressions have the form *e<sub>1</sub> op e<sub>2</sub>*,
-where *e<sub>1</sub>* and *e<sub>2</sub>* are expressions and *op* is one of
+where *e<sub>1</sub>* and *e<sub>2</sub>* are operand expressions and *op* is one of
 Compact's binary arithmetic operators.
 The binary arithmetic operators are **add** (`+`), **subtract** (`-`) and
 **multiply** (`*`).
 
-Arithmetic expressions require the types of both subexpressions to be numeric
-types, that is, either a `Field`, a `Uint`, or a type alias for a `Field` or
+Arithmetic expressions require the type of each operand to be a numeric
+type, that is, either a `Field`, a `Uint`, or a type alias for a `Field` or
 a `Uint`.
 Putting aside type aliases for now, the type of the result depends on the
-types of the subexpressions as follows:
+types of the operands as follows:
 
-- If either subexpression has type `Field`, the result has type `Field`.
-- Otherwise *e<sub>1</sub>* must have type `Uint<0..`*m*`>`, and
-  *e<sub>2</sub>* must have type `Uint<0..`*n*`>` for some bounds *m* and *n*.
-  The type of the result depends on the operation as follows:
+- If both operands have type `Field`, the result has type `Field`.
+- If both operands have `Uint` types, i.e., *e<sub>1</sub>* has type
+  `Uint<0..`*m*`>` for some *m* and *e<sub>2</sub>* has type `Uint<0..`*n*`>` for
+  some *n*, the type of the result depends on the operation as follows:
   - for add, the result has type `Uint<0..`*m+n*`>`,
   - for subtract, the result has type `Uint<0..`*m*`>`, and
   - for multiply, the result has type `Uint<0..`*m⋅n*`>`.
+- If one operand has type `Field` and the other has type `Uint<0..`*n*`>`
+  where *n-1* is less than or equal to the maximum field value, the `Uint`
+  operand is implicitly cast to `Field`, and the result has type `Field`.
+  (If *n-1* is greater than the maximum field value, the behavior of the
+  compiler is currently unspecified.)
 
 For arithmetic operations with `Uint` result types, it is a static error if
-the result's bound would be greater than the maximum unsigned integer.
+the result's bound would be greater than the
+[maximum unsigned integer, if any](#implementation-specific-limits).
 
 Evaluating an arithmetic expression *e<sub>1</sub> op e<sub>2</sub>* involves
 first evaluating *e<sub>1</sub>*, then evaluating *e<sub>2</sub>*.
-Integer addition, subtraction, or multiplication is then used on the subexpression
+Integer addition, subtraction, or multiplication is then used on the operand
 values.
 The overflow and underflow behavior differs for `Field` (either operand has
 type `Field`) and `Uint` operations (both operands have a `Uint` type):
@@ -2437,12 +2446,12 @@ type `Field`) and `Uint` operations (both operands have a `Uint` type):
   be negative, i.e., if the value of *e<sub>2</sub>* is greater the the value
   of *e<sub>1</sub>*.
 
-If the type of either subexpression is a structural type alias for a `Field` or
+If the type of either operand is a structural type alias for a `Field` or
 `Uint` it is treated identically to that `Field` or `Uint`, both in type checking
 and evaluation.
 
-On the other hand, if the type of either subexpression is a nominal type alias
-*T* for a `Field` or a `Uint`, the type of the other subexpression must also have
+On the other hand, if the type of either operand is a nominal type alias
+*T* for a `Field` or a `Uint`, the type of the other operand must also have
 type *T*, and the type of the result also has type *T*.
 Evaluation proceeds as if the two operands had the underlying `Field` or `Uint`
 type with the value cast back to *T*, which can result in a dynamic error if *T*
@@ -2977,8 +2986,9 @@ Any cast not covered by one of the rules is not allowed.
 -  Any `Uint` downcast, i.e., any cast from `Uint<0..`*m*`>` to `Uint<0..`*n*`>`, *m* > *n*,
    is allowed, requires a run-time check, and might require a run-time conversion.
    The same applies to any `Field` to `Uint` casts where the maximum `Field` value
-   exceeds the maximum value of the `Uint` type, as well as any `Uint` to `Field`
-   casts where the maximum value of the `Uint` type exceeds the maximum `Field` value.
+   exceeds the maximum value of the `Uint` type.
+   (If the maximum value of the `Uint` type exceeds the maximum `Field` value, the
+   behavior of the compiler is currently unspecified.)
 
 #### Casts of `Boolean` to and from `Field` and `Uint`:
 
@@ -3232,10 +3242,10 @@ This is necessary even when the caller or witness is written in properly
 typed TypeScript because some Compact types have size and range limits
 that are not expressible via the TypeScript type system:
 
-- `Field` values are limited by a maximum field value
-- `Uint` values are limited by the declared bounds
-- `Bytes` and tuple values are limited by their lengths
-- enum values are limited by the maximum index for the enum elements
+- `Field` values are limited by a maximum field value.
+- `Uint` values are limited by the declared bounds.
+- `Bytes`, `Vector`, and tuple values are limited by their lengths.
+- Enum values are limited by the maximum index for the enum elements.
 
 It is also necessary because compile-time type checks are easily
 defeated in TypeScript and are nonexistent when a caller or witness

From d52d08eac13a275bffde7905c75954baa78574b5 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Wed, 18 Mar 2026 00:26:20 +0100
Subject: [PATCH 31/41] revisions to .lang-ref code { } style

---
 src/css/custom.css | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/css/custom.css b/src/css/custom.css
index 1a581b92..b097338c 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -522,7 +522,6 @@ a:hover {
 code {
   font-family: var(--ifm-font-family-monospace);
   font-variant-ligatures: none;
-  word-break: break-all;
   overflow-wrap: break-word;
   white-space: pre-wrap;
   vertical-align: baseline !important;
@@ -657,7 +656,8 @@ pre {
 .lang-ref code {
   font-family: var(--ifm-font-family-monospace);
   font-variant-ligatures: none;
-  overflow-wrap: break-word;
+  word-break: normal;
+  overflow-wrap: normal;
   white-space: pre-wrap;
   vertical-align: baseline !important;
   background-color: transparent;

From 7745b17f78783805f1f249cf9bce21dfbd522dc8 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Wed, 18 Mar 2026 11:15:13 +0100
Subject: [PATCH 32/41] latest lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 35 +++++++++++++----------------
 1 file changed, 16 insertions(+), 19 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index b72a3bb6..3cdc016a 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -953,7 +953,7 @@ A compact program is a sequence of zero or more program elements.
 
 Briefly:
 
-- A [pragma form](#pragmas) allows the program to declare the version of the compiler and/or the language that it requires
+- A [pragma form](#pragmas) allows the program to declare the version of the compiler and/or the language that it requires.
 - A [module definition](#modules-exports-and-imports) defines a Compact module, which also
   contains a sequence of program elements in its own nested scope.
 - An [export form](#exports) exports bindings from a module or from [the program itself](#top-level-exports).
@@ -1128,15 +1128,15 @@ directly from there.
 If *import-name* is an identifier *module-name*, a definition for module *module-name*
 must be contained within
 the file *module-name*`.compact` in the same directory as the importing file or in one of the
-directories in the compact path.
-If *import-name* is a string `"{`*prefix/*`}`*module-name*`" where `{`*prefix/*`}` is either empty or is
+directories in the Compact path.
+If *import-name* is a string `"{`*prefix/*`}`*module-name*`"` where `{`*prefix/*`}` is either empty or is
 a pathname ending in a directory separator, a definition for a module named
 *module-name* must be contained within a file *module-name*`.compact` that is either:
 - (a) if `{`*prefix/*`}`*module-name*`.compact` is an absolute pathname, then exactly at
   `{`*prefix/*`}`*module-name*`.compact`, otherwise
 - (b) at `{`*prefix/*`}`*module-name*`.compact` relative to the directory of the importing
-  file or to one of the directories in the compact path.
-Details on the search order and the mechanism for setting the compact path are
+  file or to one of the directories in the Compact path.
+Details on the search order and the mechanism for setting the Compact path are
 given in [Compiler Usage](../compilation-and-tooling/compiler-usage).
 
 In any of these cases, it is a static error if *module-name*`.compact` is not found, if it
@@ -1283,8 +1283,8 @@ string literal specifying a filesystem pathname for file to be included:
 
 *file* can be an absolute pathname, one that is relative to the directory
 of the including file, or one that is relative to one of the directories in the
-compact path.
-Details on the search order and the mechanism for setting the compact path are
+Compact path.
+Details on the search order and the mechanism for setting the Compact path are
 given in [Compiler Usage](../compilation-and-tooling/compiler-usage).
 
 It is a static error if the file is not present or cannot be read.
@@ -1378,17 +1378,15 @@ The following *ledger-state types* are supported.
 - `Map<`*K*, *T*`>`, for any Compact types *K* and *T*
 - `Map<`*K*, *V*`>`, for any Compact type *K* and ledger-state type *V* (see the following section)
 - `List<`*T*`>`, for any Compact type *T*
-- `MerkleTree<`*n*, *T*`>`, for a compile time integer 1 \< *n* ≤ 32, and any Compact
-  type *T*
-- `HistoricMerkleTree<`*n*, *T*`>`, for a compile time integer 1 \< *n* ≤ 32, and any
-  Compact type *T*
+- `MerkleTree<`*n*, *T*`>`, for any *n*, 1 \< *n* ≤ 32, and any Compact type *T*
+- `HistoricMerkleTree<`*n*, *T*`>`, for any *n*, 1 \< *n* ≤ 32, and any Compact type *T*
 
 Each ledger type supports a set of operations, which can be invoked with
 
 *F*`.`*op*(*e*, ⋯, *e*)
 
 where *F* is a field name, *op* is the name of a ledger operation supported by
-the ledger-state type of *F*, and each *e* is an expression.
+the ledger-state type of *F*, and each *e* is an argument expression.
 
 A ledger field that is declared with a Compact type *T* implicitly has the type
 `Cell<`*T*`>`, which supports several operations, including `read`, `write`, and
@@ -1445,7 +1443,7 @@ is created in order to minimize the chance of the transaction being rejected whe
 the proof is checked on chain.
 For example, `Counter` increment and decrement do not commit to the current value
 of the counter.
-While the preceding example could be written using a Cell instead:
+While the preceding example could be written using a `Cell` instead:
 
 ```compact
 ledger F: Uint<64>;
@@ -1460,7 +1458,7 @@ export circuit getF(): Uint<64> {
 }
 ```
 
-A call to `incrF` or `decrF` involves an explicit read of `F`, and if `F` does
+a call to `incrF` or `decrF` involves an explicit read of `F`, and if `F` does
 not have the same value when the proof is checked as when the transaction is
 created, the proof fails and the transaction is rejected.
 
@@ -1657,7 +1655,7 @@ The optional `pure` modifier indicates that the
 [circuit is pure](#pure-and-impure-circuits).
 
 If any generic parameters are present (*gparams* is present and is nonempty),
-the circuit is [generic][#generic-parameters-and-arguments] and must be specialized
+the circuit is [generic](#generic-parameters-and-arguments) and must be specialized
 (provided with generic arguments) at the point of call.
 
 Circuits can take zero or more parameters.
@@ -1859,11 +1857,10 @@ circuit foo(a: Uint<16>): Field {
 ```
 
 Similarly, the reference to `x` in the first *cbinding* of the `const`
-statement below is also a static error.
+statement below is also a static error:
 
 ```compact
 const y = x, x = 7;
-}
 ```
 
 A `const` statement is evaluated by evaluating the *cbinding* subforms in order
@@ -1878,7 +1875,7 @@ as described earlier in [Patterns and destructuring](#patterns-and-destructuring
 Any variable bound by `const` may not be reused within a block, although a
 `const` binding in a nested block might [shadow it](#identifiers-bindings-and-scope).
 Variables are immutable, although the same variable might take on different values
-at different times if is contained within a block of code that is evaluated more
+at different times if it is contained within a block of code that is evaluated more
 than once, such as would be the case for the body of a circuit that is called
 more than once.
 
@@ -1974,7 +1971,7 @@ treated as if ended with `return;`.
 A `return` statement is always well-typed if it exits from an anonymous circuit
 without a declared return type.
 Otherwise, a `return` statement is well-typed if the type of *expr-seq*, or
-`[]` if no *expr-seq* is present, is a subtype the expected return type.
+`[]` if no *expr-seq* is present, is a subtype of the expected return type.
 If the `return` form exits from a named circuit or an anonymous circuit
 with a declared return type, the expected type is the declared return type,
 while if it exits from the constructor, the expected return type is `[]`.

From 0e9ce6d4cc584f9d24e5b4e1e04caff7fcd3ed4d Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Thu, 19 Mar 2026 10:03:37 +0100
Subject: [PATCH 33/41] latest lang-ref.mdx and ledger-adt.mdx

---
 docs/compact/reference/lang-ref.mdx   | 6 +++---
 docs/compact/reference/ledger-adt.mdx | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index 3cdc016a..ac6e625d 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -1647,7 +1647,7 @@ Named circuit definitions have the following syntax:
 </div>
 
 A circuit definition binds *function-name* to a circuit with the given parameters,
-type, and body.
+return type, and body.
 The optional `export` modifier indicates that the circuit binding should
 be exported from the enclosing module or the program itself, if the circuit
 is defined outside of any module.
@@ -3368,9 +3368,9 @@ Compact compiler version 1.0 limits certain datatype values and sizes:
 This value is dictated by the scalar field size of the ZK proving system.
 - The maximum value of a `Uint` value is
 452312848583266388373324160190187140051835877600158453279131187530910662655.
-This value is `(256^k)-1` where `k` is the number of bytes (31) that fits in
+This value is 256<sup>k</sup>-1 where *k* is the number of bytes (31) that fits in
 a `Field`.
-- The maximum length of a vector or byte-vector is `2^24 = 16777216`.
+- The maximum length of a vector or byte-vector is 16777216.
 This value is chosen as a reasonable upper bound that helps prevent the compiler
 from looping indefinitely on programs that operate on excessively large vector
 and byte-vector types.
diff --git a/docs/compact/reference/ledger-adt.mdx b/docs/compact/reference/ledger-adt.mdx
index f7cb1c47..b9b431f3 100644
--- a/docs/compact/reference/ledger-adt.mdx
+++ b/docs/compact/reference/ledger-adt.mdx
@@ -1,3 +1,4 @@
+---
 SPDX-License-Identifier: Apache-2.0
 copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 title: Ledger data types

From 36fee248199ca26ebf381b3f7cc2ea383e22fa64 Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Fri, 20 Mar 2026 16:50:05 +0100
Subject: [PATCH 34/41] latest lang-ref.mdx

---
 docs/compact/reference/lang-ref.mdx | 179 +++++++++++++++-------------
 1 file changed, 95 insertions(+), 84 deletions(-)

diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/lang-ref.mdx
index ac6e625d..68b35cd5 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/lang-ref.mdx
@@ -28,7 +28,8 @@ kinds of program elements:
 - declarations of the data that the contract stores in the public ledger,
 - declarations of *witnesses*, which are callback functions supplied by the TypeScript runner,
 - definitions of *circuits*, which are functions serving as the operational core of a smart contract, and
-- the definition of at most one *constructor*, which is a function used to initialize the public ledger.
+- the definition of at most one *constructor*, which is a function called when a contract
+  is created and can be used to initialize public and private state.
 
 Compact is similar to TypeScript: it has a syntax similar to that of JavaScript,
 and it layers a type system over the JavaScript syntax.
@@ -719,7 +720,7 @@ i.e., any value of type *T* can be used where a value of type *S* is expected wi
 the need for an explicit cast.
 For example, a circuit or witness can be called with argument expressions whose
 types are subtypes of the corresponding parameter type annotations, and
-a constant binding statement with a type annotation can be initialized with an
+a `const` binding statement with a type annotation can be given a value with an
 expression whose type is a subtype of the type annotation.
 
 Subtyping is exclusively defined by the following rules:
@@ -828,7 +829,7 @@ Here is a similar example that destructures a struct instead of a tuple:
 
 ```compact
 struct S { x: Uint<16>, y: Uint<32> }
-circuit sumStruct({x, y}: S): Field {
+circuit sumStruct({x, y}: S): Uint<64> {
   return x + y;
 }
 ```
@@ -841,7 +842,7 @@ even though the order of the pattern elements has been swapped:
 
 ```compact
 struct S { x: Uint<16>, y: Uint<32> }
-circuit sumStruct({y, x}: S): Field {
+circuit sumStruct({y, x}: S): Uint<64> {
   return x + y;
 }
 ```
@@ -853,7 +854,7 @@ for the structure elements:
 
 ```compact
 struct S { x: Uint<16>, y: Uint<32> }
-circuit sumStruct({x: a, y}: S): Field {
+circuit sumStruct({x: a, y}: S): Uint<64> {
   return a + y;
 }
 ```
@@ -866,7 +867,7 @@ Patterns can be arbitrarily nested, e.g.:
 
 ```compact
 struct S { x: Uint<16>, y: Uint<32> }
-circuit sumTupleStruct([{x: a1, y: b1}, {x: a2, y: b2}]: [S, S]): Field {
+circuit sumTupleStruct([{x: a1, y: b1}, {x: a2, y: b2}]: [S, S]): Uint<64> {
   return a1 + b1 + a2 + b2;
 }
 ```
@@ -876,7 +877,7 @@ or struct.
 
 ```compact
 struct S { x: Uint<16>, y: Uint<32> }
-circuit sumSomeYs([{y: b1}, , {y: b3}]: [S, S, S]): Field {
+circuit sumSomeYs([{y: b1}, , {y: b3}]: [S, S, S]): Uint<64> {
   return b1 + b3;
 }
 ```
@@ -892,7 +893,7 @@ For example:
 
 ```compact
 struct S { x: Uint<16>, y: Uint<32> }
-circuit sumStruct({x, y}: [Field, Field]): Field {
+circuit sumStruct({x, y}: [Uint<16>, Uint<32>]): Uint<64> {
   return x + y;
 }
 ```
@@ -901,7 +902,7 @@ fails because it tries to treat a tuple as a struct, while:
 
 ```compact
 struct S { x: Uint<16>, y: Uint<32> }
-circuit sumSomeYs([{y: b1}, , , {y: b3}]: [S, S, S]): Field {
+circuit sumSomeYs([{y: b1}, , , {y: b3}]: [S, S, S]): Uint<64> {
   return b1 + b3;
 }
 ```
@@ -911,7 +912,7 @@ two skipped elements) when it actually has only three, and:
 
 ```compact
 struct S { x: Uint<16>, y: Uint<32> }
-circuit sumSomeYs([{y: b1}, , {z: b3}]: [S, S, S]): Field {
+circuit sumSomeYs([{y: b1}, , {z: b3}]: [S, S, S]): Uint<64> {
   return b1 + b3;
 }
 ```
@@ -923,7 +924,7 @@ input and are ignored:
 
 ```compact
 struct S { x: Uint<16>, y: Uint<32> }
-circuit sumSomeYs([{y: b1,}, , {y: b3,},]: [S, S, S]): Field {
+circuit sumSomeYs([{y: b1,}, , {y: b3,},]: [S, S, S]): Uint<64> {
   return b1 + b3;
 }
 ```
@@ -1368,6 +1369,11 @@ sealed ledger u8list: List<Uint<8>>;
 export sealed ledger mapping: Map<Boolean, Field>;
 ```
 
+All ledger fields are initialized to the
+[default values of their ledger-state types](#default-values-of-a-type).
+The contract constructor, if any, runs after the default values are
+established, allowing the constructor to override the defaults.
+
 ### Ledger-state types
 
 The following *ledger-state types* are supported.
@@ -1380,6 +1386,8 @@ The following *ledger-state types* are supported.
 - `List<`*T*`>`, for any Compact type *T*
 - `MerkleTree<`*n*, *T*`>`, for any *n*, 1 \< *n* ≤ 32, and any Compact type *T*
 - `HistoricMerkleTree<`*n*, *T*`>`, for any *n*, 1 \< *n* ≤ 32, and any Compact type *T*
+- `Kernel`, a special type that yields access to ledger operations that do not depend
+  on a specific ledger state
 
 Each ledger type supports a set of operations, which can be invoked with
 
@@ -1437,13 +1445,10 @@ export circuit getF(): Uint<64> {
 }
 ```
 
-The ledger-state types are designed to minimize the extent to which a circuit
-proof depends upon the exact value of a ledger-state field as of when a transaction
-is created in order to minimize the chance of the transaction being rejected when
-the proof is checked on chain.
-For example, `Counter` increment and decrement do not commit to the current value
-of the counter.
-While the preceding example could be written using a `Cell` instead:
+The selection of an appropriate ledger-state type can reduce a transaction's
+dependency on the exact contents of the ledger state and thus reduce the chance
+of a transaction being rejected when the proof is checked on chain.
+For example, the preceding example could be written using a `Cell` instead:
 
 ```compact
 ledger F: Uint<64>;
@@ -1458,21 +1463,29 @@ export circuit getF(): Uint<64> {
 }
 ```
 
-a call to `incrF` or `decrF` involves an explicit read of `F`, and if `F` does
-not have the same value when the proof is checked as when the transaction is
-created, the proof fails and the transaction is rejected.
+`incrF` and `decrF` read the value of `F` before operating on it and writing
+it back to `F`.
+This read commits the transaction to the current value of the field.
+If `F` has the value, say, 27 when the transaction is created, `F` must still
+have the value 27 when the proof is checked on chain.
+The `Counter` versions, however, do not read the value but merely request
+that the current value be incremented or decremented; thus, it does not have
+any such constraint.
 
 A comprehensive description of ledger-state types and operations can be found in
 the Compact [ledger data type documentation](ledger-adt).
 
 ### Nested state types in the `Map` type
 
-The only ledger-state type in which values of other state types may be held is
-`Map`.
-The key values in a `Map` must be regular Compact types, but the mapped values
-may be counters, sets, lists, other maps, and so on.
+In most cases, legder-state types cannot be nested within other ledger-state types.
+However, while `Map` keys must have regular Compact types, `Map` values can have
+either regular Compact types or ledger-state types (except `Kernel`).
+
+Attempting to nest a ledger-state type anywhere but within a `Map` value is a
+static error.
+Attempting to nest the `Kernel` type within a `Map` value is also a static error.
 
-Here is a small example:
+Here is a small example showing two levels of nesting:
 
 ```compact
 import CompactStandardLibrary;
@@ -1515,14 +1528,14 @@ In this example,
 
 Notes:
 
-- Nesting is permitted only within `Map` values.  That is, nesting is not permitted in
-  `Map` keys or within any ledger-state type other than `Map`.
-- Nested values must be initialized before first use.  The syntax `default<`*T*`>`
-  is used to create default ledger-state type values, just as it can be used to
-  create default Compact type values.
+- Nested ledger-state values must be initialized before first use.
+  The syntax `default<`*T*`>` can be used to create default ledger-state type
+  values, just as it can be used to create default Compact type values.
+  Attempting to operate on a nested ledger-state value without first initializing
+  it is a dynamic error.
 - Ledger state type values are not first-class objects, so when
   accessing a nested value, the entire indirection chain must be
-  used.  For example, the following results in a compiler error:
+  used.  For example, the following is a static error:
 
   ```compact
   export circuit incrementNestedCounter(b: Boolean, n: Field, k: Uint<16>): [] {
@@ -1617,7 +1630,7 @@ constructor(v: Field) {
 }
 ```
 
-Each constructor parameter must be explicitly typed.
+Each constructor parameter must have an explicit type annotation.
 The type of each variable binding arising from the binding of identifiers in
 each parameter pattern to the corresponding pieces of the input is the type of
 the corresponding part of the declared type's structure.
@@ -1665,7 +1678,7 @@ In the simplest case, a pattern is just an identifier and is bound to the argume
 value as a whole.
 The bindings established by the parameters are visible within (and only within)
 the *block* that constitutes the body of the circuit.
-Each parameter must be explicitly typed, and at the point of every call to the
+Each parameter must have an explicit type annotation, and at the point of every call to the
 circuit, the type of the corresponding argument expression must be a subtype of
 that type.
 The type of each variable binding arising from the binding of identifiers in
@@ -1675,7 +1688,7 @@ For example, in the body of `sumStruct` below:
 
 ```compact
 struct S { x: Uint<16>, y: Uint<32> }
-circuit sumStruct({x, y}: S): Field {
+circuit sumStruct({x, y}: S): Uint<64> {
   return x + y;
 }
 ```
@@ -1913,7 +1926,7 @@ This restriction is motivated by the need for the compiler to generate
 finite proving circuits.
 
 Compact supports two kinds of `for` statements.
-The first iterates over vectors, tuples, and byte-vectors and takes the
+The first iterates over vectors, tuples, and byte vectors and takes the
 following form:
 
 `for (const` *x* `of` *expr*`)` *stmt*
@@ -2052,7 +2065,7 @@ The syntax of Compact expressions is summarized by the following grammar snippet
 Every Compact expression must be well-typed (free from static type errors).
 If any expression within a program contains a static type error, it is a static
 error: the Compact compiler reports the error and does not produce any target code
-(TypeScript or Zkir) for the program.
+(TypeScript or zkir) for the program.
 The static type of a well-typed expression is either a Compact type or a
 ledger-state type.
 
@@ -2120,7 +2133,7 @@ to make the default order of operations explicit.
 
 For example, `x + y * z` computes the product of `y` and `z` and adds `x` to the
 result, because `*` has higher precedence than `+`.
-`x + (y * z)` computes the same thing but more makes the order of operations more
+`x + (y * z)` computes the same thing but makes the order of operations more
 clear, while `(x + y) * z` computes the sum of `x` and `y` and multiplies it by `z`.
 
 The type of a parenthesized expression is the type of the embedded expression
@@ -2215,8 +2228,8 @@ The static type of a string literal of length *n* is `Bytes<`*n*`>`, and its
 value is a byte vector containing its UTF-8 encoding.
 
 A `pad` expression `pad(`*n*`,` *s*`)` is also a string literal, where `pad` is a reserved
-word, *n* is a natural number literal, and *s* is a simple string literal whose
-length must be less than or equal to *n*.
+word, *n* is a natural number literal, and *s* is a simple string literal.
+The length of *s* must be less than or equal to *n*; otherwise, it is a static error.
 The static type of a padded string literal `pad(`*n*`,` *s*`)` is `Bytes<`*n*`>`, and its
 value is a byte vector containing the UTF-8 encoding of *s* followed by `0`
 bytes up to the padded length *n*.
@@ -2247,9 +2260,8 @@ has static type *T* and evaluates to the default value of that type as follows:
 - `MerkleTree<`*n*`, `*T*`>`: an empty Merkle tree
 - `HistoricMerkleTree<`*n*`, `*T*`>`: an empty historic Merkle tree
 
-Default values are not defined for contract types or the `CompactStandardLibrary`
-`Kernel` type, so it is a static error if *T* in `default<`*T*`>` is one of
-these types.
+Default values are not defined for contract types or the `Kernel` ledger-state type,
+so it is a static error if *T* in `default<`*T*`>` is one of these types.
 
 ### Variable references
 
@@ -2306,9 +2318,11 @@ Equals and not equals require the types of *e<sub>1</sub>* and *e<sub>2</sub>*
 to be related.
 That is, the type of *e<sub>1</sub>* must be a subtype of the type of *e<sub>2</sub>*,
 or the type of *e<sub>2</sub>* must be a subtype of the type of *e<sub>1</sub>*.
+Otherwise, it is a static error.
 
 Less than, greater than, less than or equals, and greater than or equals require
 the types of *e<sub>1</sub>* and *e<sub>2</sub>* to be unsigned integer types.
+Otherwise, it is a static error.
 (Values of type `Field` cannot be compared with these operators.)
 
 The type of the result is `Boolean`.
@@ -2320,25 +2334,25 @@ comparing the resulting values as described below.
 **Equals and not equals**
 
 Equality depends on the types of the operands according to the following rules.
-The rules need not and therefore do not cover cases where one operand is not a subtype of
-the other.
+The rules need not and therefore do not cover cases where one operand is not
+a subtype of the other, as required by typing rules above.
 For example, if one operand has type `Boolean`, so does the other; if one
 operand has a `Bytes` type of length *n*, so does the other; and if one
 has a specific structure type, so does the other.
 
-- **`Boolean` == `Boolean`:**
+- **`Boolean`:**
   the values are equal if both are `true` or both are `false`.
-- **`Uint` or `Field` == `Uint` or `Field`:**
+- **`Field` and `Uint` types:**
   the values are equal if the integer values are equal.
 - **`Bytes`:**
   the values are equal if the corresponding bytes at each index are equal.
-- **`Tuple` and `Vector`:**
+- **`Vector` and tuple types:**
   the values are equal if the corresponding values at each index are equal.
 - **Structure types:**
   the values are equal if the values of the corresponding fields are equal.
 - **Enumeration types:**
   the values are equal if they are the same enumeration member.
-- **`Opaque types:`**
+- **`Opaque` types:**
   the values are equal if the runtime values are equal according to JavaScript's
   strict equality (`===`) operator.
 
@@ -2440,7 +2454,7 @@ type `Field`) and `Uint` operations (both operands have a `Uint` type):
 - `Uint` addition and multiplication cannot overflow: the static type of the
   result is always large enough to hold the result value.
 - `Uint` subtraction results in a dynamic error if the resulting value would
-  be negative, i.e., if the value of *e<sub>2</sub>* is greater the the value
+  be negative, i.e., if the value of *e<sub>2</sub>* is greater the value
   of *e<sub>1</sub>*.
 
 If the type of either operand is a structural type alias for a `Field` or
@@ -2484,12 +2498,12 @@ Otherwise, it is a static error.
 
 If *T* is a tuple type `[`*U<sub>1</sub>*, ⋯, *U<sub>n</sub>*`]`, the
 spread contributes *n* new elements of types *U<sub>1</sub>*, ⋯, *U<sub>n</sub>*
-to to the new tuple, i.e., the elements of the tuple value of *e*.
+to the new tuple, i.e., the elements of the tuple value of *e*.
 If *T* is a Vector type `Vector<`*n*, *U*`>`, the spread contributes
 *n* new elements of type *U* to the new tuple, i.e., the elements
 of the Vector value of *e*.
 If *T* is a Bytes type `Bytes<`*n*`>`, the spread contributes *n* new elements of
-type `Uint<8>` to to the new tuple, i.e., the elements of the byte-vector value
+type `Uint<8>` to the new tuple, i.e., the elements of the byte-vector value
 of *e*.
 
 The type of a tuple-creation expression is the tuple type whose elements are
@@ -2507,7 +2521,7 @@ New byte vectors are created with expressions of the form
 `Bytes [`*tuple-arg*, ⋯, *tuple-arg*`]`.
 Bytes creation is essentially the same as [tuple creation](#tuple-creation)
 except that the types of the contributed elements must all be subtypes of `Uint<8>`
-(if not, it is static error), and the result is a new byte vector of type
+(if not, it is a static error), and the result is a new byte vector of type
 `Bytes<`*n*`>` where *n* is the number of contributed elements.
 
 ### Tuple, vector, and byte-vector references
@@ -2569,6 +2583,7 @@ the fixed size of the slice, *e* is an expression, and *index* is a numeric
 literal, a generic natural-number parameter reference, or an expression that can be
 reduced to a numeric constant at compile time as described above in the section on
 [sequence references](#tuple-vector-and-byte-vector-references).
+It is a static error if *index* + *k* exceeds the length of the sequence value.
 
 The type of a byte-vector slice is `Bytes<`*k*`>`.
 The type of a vector slice where the vector has element type *T* is
@@ -2724,26 +2739,26 @@ The value of any structure field access *e*`.`*id* is the result of evaluating t
 subexpression *e* and extracting the value of the resulting structure's *id* field.
 
 Some expressions of the form *e*`.`*id* can also be
-[enumeration member accesses](#enumeration-member-access) or
+[enumeration member selection](#enumeration-member-selection) or
 [ledger-state operations](#ledger-state-operations).
 *e*`.`*id* is recognized as a structure field access only when the
 type of *e* is a structure type.
 
-### Enumeration member access
+### Enumeration member selection
 
 An expression of the form *E*`.`*id* where *E* is the name of an enumeration
-type and *id* is an identifier is an enumeration member access.
+type and *id* is an identifier is an enumeration member selection.
 It is a static error if *E* does not have a member named *id*.
 
-The type of any enumeration member access *E*`.`*id* is *E*.
+The type of any enumeration member selection *E*`.`*id* is *E*.
 
 *E*`.`*id* is a constant.
-That is, the value of any enumeration member access *E*`.`*id* is *E*`.`*id*.
+That is, the value of any enumeration member selection *E*`.`*id* is *E*`.`*id*.
 
 Some expressions of the form *E*`.`*id* can also be
 [structure field accesses](#structure-field-access) or
 [ledger-state operations](#ledger-state-operations).
-*E*`.`*id* is recognized as an enumeration member access only when the
+*E*`.`*id* is recognized as an enumeration member selection only when the
 type of *e* is an enumeration type.
 
 ### Circuit and witness calls
@@ -2858,18 +2873,16 @@ Compact supports expressions that perform the higher-order operations _map_ and
 and byte vectors.
 
 Map expressions have the form `map(`*fun*, *e*, ⋯¹, *e*`)` where `map` is a
-keyword, *fun* is a circuit or witness taking at least one argument, and each *e*
-is an expression.
-A circuit or witness taking *n* arguments can be mapped over *n* sequence values
-(vectors, tuples that have vector types, or byte-vectors) by providing *n*
-sequence-value subexpressions to the `map`.
+keyword, *fun* is a circuit or witness, and each *e* is an expression.
+The `map` operator creates a vector containing the results of applying *fun*
+to the corresponding elements of the sequence values of the expressions.
 
 Fold expressions have the form `fold(`*fun*, *init*, *e*, ⋯¹, *e*`)` where
-`fold` is a keyword, *fun* is a circuit or witness taking at least two arguments,
-*init* is an expression, and each *e* is an expression.
-A circuit or witness taking *n*+1 arguments can be folded over an initial value
-*init* and *n* sequence values by providing *n* sequence-value subexpressions to
-the `fold`.
+`fold` is a keyword, *fun* is a circuit or witness, *init* is an expression,
+and each *e* is an expression.
+The `fold` operator accumulates a value starting with the value of *init* and
+updating it by applying *fun* to the current value and the corresponding elements of
+the sequence values of the expressions in turn.
 
 A detailed description of the circuit or witness *fun* is given in
 [Circuit and witness calls](#circuit-and-witness-calls) above.
@@ -2887,7 +2900,7 @@ subexpression must have the vector type `Vector<`*n*, *S*`>` where *S* is a subt
 of *T*.
 The type of the `map` expression is `Vector<`*n*, *R*`>`; `map` produces a vector
 regardless of whether the input sequence-value subexpressions are vectors, tuples,
-byte-vectors, or some combination.
+byte vectors, or some combination.
 
 A fold expression is type-checked by checking the type of the witness or circuit
 *fun* to find its parameter types and its return type *R*.
@@ -2948,7 +2961,7 @@ If a check fails, a dynamic error is reported.
 TypeScript casts of the form `<`*T*`>`*e* are not supported in Compact.
 
 The following rules govern when casts are allowed, when casts might cause dynamic
-errors, and casts might require run-time conversions.
+errors, and when casts might require run-time conversions.
 Any cast not covered by one of the rules is not allowed.
 
 #### Upcasts
@@ -2976,7 +2989,7 @@ Any cast not covered by one of the rules is not allowed.
     of each *S*, a cast from the vector type to the tuple type is allowed but not
     required.
     For example, values of type `Vector<2, Uint<8>>` can be used where
-    values of type `[Uint<16>, Uint<16>]` are required.
+    values of type `[Uint<8>, Uint<16>]` are required.
 
 #### Downcasts of `Field` and `Uint` types
 
@@ -2987,7 +3000,7 @@ Any cast not covered by one of the rules is not allowed.
    (If the maximum value of the `Uint` type exceeds the maximum `Field` value, the
    behavior of the compiler is currently unspecified.)
 
-#### Casts of `Boolean` to and from `Field` and `Uint`:
+#### Casts of `Boolean` to and from `Field` and `Uint`
 
 - Any cast from `Boolean` to `Field` or any `Uint` type is allowed, sometimes
   requires a run-time check, and requires a run-time conversion (of `false` to `0`
@@ -2997,7 +3010,7 @@ Any cast not covered by one of the rules is not allowed.
   result in a dynamic error, and requires a simple run-time conversion (of `0` to
   `false` and any other value to `true`).
 
-#### Casts of Enum types to and from `Field` and `Uint`:
+#### Casts of Enum types to and from `Field` and `Uint`
 
 - Any cast from an enum type to `Field` or any `Uint` type is allowed,
   sometimes requires a run-time check, and might require a run-time
@@ -3010,7 +3023,7 @@ Any cast not covered by one of the rules is not allowed.
   For an enum type with *n* elements, a run-type check is required for casts
   from `Uint<0..`*m*`>`, *m* > *n*.
 
-#### Casts of `Bytes` to and from `Field` and `Uint`:
+#### Casts of `Bytes` to and from `Field` and `Uint`
 
 - Any cast from `Bytes<`*m*`>`, *m* != 0, to `Field` or any `Uint` type is allowed,
   requires a run-time check, and requires a run-time conversion.
@@ -3026,7 +3039,7 @@ Any cast not covered by one of the rules is not allowed.
   byte of the integer.
   A dynamic error occurs if the result does not fit in *m* bytes.
 
-#### Casts of `Bytes` to and from `Vector` and tuple types:
+#### Casts of `Bytes` to and from `Vector` and tuple types
 
 - Any cast from `Bytes<`*m*`>` to `Vector<`*m*, `Field>` or
   `Vector<`*m*, `Uint<0..`*k*`>>`, *k* ≥ 256 is allowed, cannot
@@ -3053,7 +3066,7 @@ state.  They can be invoked by expressions of the form *id*`.`*op*`(`*e*, ⋯, *
 *op* is the name of a builtin kernel operation, and
 *e*, ⋯, *e* is a comma separated sequence of zero or more argument expressions.
 The `CompactStandardLibrary` predefines the ledger field name `kernel` to have
-ledger type `Kernel`, so for example, the built-in `self` operation can be called
+ledger-state type `Kernel`, so for example, the built-in `self` operation can be called
 from a circuit as follows:
 
 ```compact
@@ -3075,12 +3088,10 @@ __Ledger-state operations__ are operations on the contract's declared public led
 In its simplest form, a ledger-state operation is an expression
 *F*`.`*op*`(`*e*, ⋯, *e*`)`, where *F* is a ledger field name
 [declared via a `ledger` field declaration](#declaring-and-maintaining-public-state),
-*op* is the name of a ledger-state operator, and each *e* is an expression.
+*op* is the name of a ledger-state operator, and each *e* is an argument expression.
 *F* can also be another ledger-state operation, allowing ledger-state operations
 to be chained when the result of a ledger-state operation might itself have a
 ledger-state type.
-(Kernel operations cannot be chained, because the kernel is not a ledger-state
-type and is not returned by any operation.)
 Compact also supports shorthands for certain ledger-state operations; these are
 described below in [Ledger-state-operation shorthands](#ledger-state-operation-shorthands).
 
@@ -3102,7 +3113,7 @@ values on the portion of the public ledger state identified by *F*.
 Compact supports several shorthands for common ledger-state operations.
 
 The simplest of these is a shorthand for the ledger-state operation
-*F*`.read()` where *F* is a ledger-state field name or itself a another
+*F*`.read()` where *F* is a ledger-state field name or itself another
 ledger-state operation.
 If the type of *F* is a ledger-state type that supports the `read`
 operation, *F*`.read()` can be abbreviated, simply, to *F*.
@@ -3147,7 +3158,7 @@ private data, if any, should be disclosed in the transcripts and public state
 of the contract, and how that private data should be encoded.
 
 Compact itself has no information about the nature of any private data and whether
-and how it is necessary to disclose it, the decision to to so rests with the
+and how it is necessary to disclose it, the decision to do so rests with the
 contract developer.
 Compact does, however, require that such disclosure be explicitly declared to
 prevent unintentional disclosure, so that privacy is the default and disclosure
@@ -3158,7 +3169,7 @@ data (exported circuit arguments, witness return values, and anything derived fr
 private data) must be acknowledged by wrapping an expression whose value contains
 private data in a `disclose()` wrapper before storing it in the public state, returning
 it from an exported circuit, or using it in conditional expressions that might
-affect what is stored in the public state or or returned from an exported circuit.
+affect what is stored in the public state or returned from an exported circuit.
 
 For example, the following contract attempts to disclose private data without
 explicitly declaring the disclosure when it stores the value of the exported
@@ -3370,7 +3381,7 @@ This value is dictated by the scalar field size of the ZK proving system.
 452312848583266388373324160190187140051835877600158453279131187530910662655.
 This value is 256<sup>k</sup>-1 where *k* is the number of bytes (31) that fits in
 a `Field`.
-- The maximum length of a vector or byte-vector is 16777216.
+- The maximum length of a vector or byte vector is 16777216.
 This value is chosen as a reasonable upper bound that helps prevent the compiler
 from looping indefinitely on programs that operate on excessively large vector
 and byte-vector types.

From a6185c08250b07eefc0b95cc55f83717586c7abd Mon Sep 17 00:00:00 2001
From: pataei <paris.ataei@gmail.com>
Date: Tue, 24 Mar 2026 09:56:02 -0600
Subject: [PATCH 35/41] lang-ref --> compact-reference

---
 CODEOWNERS                                     |  2 +-
 ...2-intro-to-web3-smart-contracts-compact.mdx |  4 ++--
 docs/compact/reference/compact-grammar.mdx     |  1 +
 docs/compact/reference/compact-keywords.mdx    |  1 +
 .../{lang-ref.mdx => compact-reference.mdx}    |  1 +
 docs/compact/reference/explicit-disclosure.mdx |  2 +-
 docs/compact/reference/ledger-adt.mdx          |  1 +
 docs/compact/reference/writing.mdx             | 18 ++++++++++++------
 docs/examples/_counter/contract-details.mdx    |  2 +-
 docs/relnotes/compact/compact-0-15-23-0.mdx    |  2 +-
 docs/relnotes/compact/compact-0-20-28-0.mdx    |  4 ++--
 .../guides/compact-javascript-runtime.mdx      |  2 +-
 .../develop/reference/compact/index.mdx        |  6 +++---
 .../tutorial/2-building/contract-details.mdx   |  2 +-
 packages/tests/pipelines-urls.json             |  2 +-
 sidebars.compact.js                            |  2 +-
 src/css/custom.css                             |  2 +-
 static-html/index.html                         |  2 +-
 static-html/llms.txt                           |  4 ++--
 static/llms.txt                                |  2 +-
 vercel.json                                    | 10 +++++-----
 21 files changed, 41 insertions(+), 31 deletions(-)
 rename docs/compact/reference/{lang-ref.mdx => compact-reference.mdx} (99%)

diff --git a/CODEOWNERS b/CODEOWNERS
index 6b410761..90363b1d 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -1,6 +1,6 @@
 * @midnightntwrk/mn-techwriting @midnightntwrk/mn-devrel @midnightntwrk/mn-codeowners-docs
 
-/docs/develop/reference/compact/lang-ref.mdx @midnightntwrk/mn-codeowners-compact @midnightntwrk/mn-codeowners-docs
+/docs/develop/reference/compact/compact-reference.mdx @midnightntwrk/mn-codeowners-compact @midnightntwrk/mn-codeowners-docs
 /.github/ISSUE_TEMPLATE/ @midnightntwrk/mn-security @midnightntwrk/mn-sre
 /.github/PULL_REQUEST_TEMPLATE/ @midnightntwrk/mn-security @midnightntwrk/mn-sre
 /.github/workflows/scan.yaml @midnightntwrk/mn-security @midnightntwrk/mn-sre
diff --git a/blog/2025-06-02-intro-to-web3-smart-contracts-compact.mdx b/blog/2025-06-02-intro-to-web3-smart-contracts-compact.mdx
index 1da070f0..13ee4daf 100644
--- a/blog/2025-06-02-intro-to-web3-smart-contracts-compact.mdx
+++ b/blog/2025-06-02-intro-to-web3-smart-contracts-compact.mdx
@@ -12,7 +12,7 @@ date: 2025-06-20
 
 As I continue my journey through the world of Web3, I’ve been digging into the building blocks that make privacy-first platforms like Midnight possible (you can catch up on previous posts in the Midnight Dev Diaries!). This week, I focused on two foundational pieces that go hand in hand: smart contracts on Midnight and the Compact language that powers them.
 
-Smart contracts aren’t new to blockchain, but Midnight’s approach is unique. Instead of executing code directly on-chain, Midnight uses smart contracts to define rules that are enforced off-chain through zero-knowledge proofs. At the center of this system is [Compact](https://docs.midnight.network/develop/reference/compact/lang-ref)—a purpose-built language designed to make writing these privacy-preserving contracts both secure and practical.
+Smart contracts aren’t new to blockchain, but Midnight’s approach is unique. Instead of executing code directly on-chain, Midnight uses smart contracts to define rules that are enforced off-chain through zero-knowledge proofs. At the center of this system is [Compact](https://docs.midnight.network/develop/reference/compact/compact-reference)—a purpose-built language designed to make writing these privacy-preserving contracts both secure and practical.
 
 To better understand how this works in practice, I also worked through [Module 2 of the Midnight Developer Academy](https://docs.midnight.network/academy/module-2), which covers key concepts such as contract structure, circuit types, and the relationship between the contract and the external logic that executes it.
 
@@ -74,6 +74,6 @@ Smart contracts are the foundation of decentralized applications—but at Midnig
 
 At Midnight, this isn’t just a theoretical improvement—it’s core to how the platform operates. Compact smart contracts let developers write verifiable, auditable logic while keeping inputs and execution off-chain. Combined with ZKPs and shielded transactions, they create an infrastructure that supports real-world use cases without compromising on privacy or decentralization.
 
-If you're learning how to build smart contracts in Web3—or just curious how these pieces fit together—I highly recommend diving into [Module 2 of the Midnight Developer Academy](https://docs.midnight.network/academy/module-2) and reviewing the [Compact Language Reference](https://docs.midnight.network/develop/reference/compact/lang-ref). These resources break down the concepts step by step and show how Midnight’s architecture turns advanced cryptography into practical developer tools.
+If you're learning how to build smart contracts in Web3—or just curious how these pieces fit together—I highly recommend diving into [Module 2 of the Midnight Developer Academy](https://docs.midnight.network/academy/module-2) and reviewing the [Compact Language Reference](https://docs.midnight.network/develop/reference/compact/compact-reference). These resources break down the concepts step by step and show how Midnight’s architecture turns advanced cryptography into practical developer tools.
 
 I’ll be back next week with more insights as I continue to unpack the pieces that make privacy-first systems work in the decentralized world.  
diff --git a/docs/compact/reference/compact-grammar.mdx b/docs/compact/reference/compact-grammar.mdx
index 74d5f1d1..52b34289 100644
--- a/docs/compact/reference/compact-grammar.mdx
+++ b/docs/compact/reference/compact-grammar.mdx
@@ -2,6 +2,7 @@
 SPDX-License-Identifier: Apache-2.0
 copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 title: Compact grammar
+sidebar_position: 100
 DO NOT EDIT: This file is automatically generated.
 ---
 
diff --git a/docs/compact/reference/compact-keywords.mdx b/docs/compact/reference/compact-keywords.mdx
index d3ed4979..aafbe12c 100644
--- a/docs/compact/reference/compact-keywords.mdx
+++ b/docs/compact/reference/compact-keywords.mdx
@@ -2,6 +2,7 @@
 SPDX-License-Identifier: Apache-2.0
 copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 title: Compact keywords
+sidebar_position: 102
 DO NOT EDIT: This file is automatically generated.
 ---
 
diff --git a/docs/compact/reference/lang-ref.mdx b/docs/compact/reference/compact-reference.mdx
similarity index 99%
rename from docs/compact/reference/lang-ref.mdx
rename to docs/compact/reference/compact-reference.mdx
index 68b35cd5..73ccfab3 100644
--- a/docs/compact/reference/lang-ref.mdx
+++ b/docs/compact/reference/compact-reference.mdx
@@ -2,6 +2,7 @@
 SPDX-License-Identifier: Apache-2.0
 copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 title: Compact reference
+sidebar_position: 05
 DO NOT EDIT: This file is automatically generated.
 ---
 
diff --git a/docs/compact/reference/explicit-disclosure.mdx b/docs/compact/reference/explicit-disclosure.mdx
index 8d0c87ba..bc3f1be2 100644
--- a/docs/compact/reference/explicit-disclosure.mdx
+++ b/docs/compact/reference/explicit-disclosure.mdx
@@ -158,4 +158,4 @@ The abstract interpreter evaluates the program as if the abstract values were ac
 
 ## Conclusion
 
-The `disclose()` wrapper in Compact enforces deliberate programming decisions when dealing with potentially sensitive private witness data and data derived from private information. Explicit disclosure requires Compact program assignments to declare an intention to use data that might be private before storing it in the public ledger, returning it from an exported circuit, or passing it to another contract. This makes privacy the default and disclosure an explicit exception, reducing the risk of accidental disclosure.
\ No newline at end of file
+The `disclose()` wrapper in Compact enforces deliberate programming decisions when dealing with potentially sensitive private witness data and data derived from private information. Explicit disclosure requires Compact program assignments to declare an intention to use data that might be private before storing it in the public ledger, returning it from an exported circuit, or passing it to another contract. This makes privacy the default and disclosure an explicit exception, reducing the risk of accidental disclosure.
diff --git a/docs/compact/reference/ledger-adt.mdx b/docs/compact/reference/ledger-adt.mdx
index b9b431f3..ea77dd89 100644
--- a/docs/compact/reference/ledger-adt.mdx
+++ b/docs/compact/reference/ledger-adt.mdx
@@ -2,6 +2,7 @@
 SPDX-License-Identifier: Apache-2.0
 copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
 title: Ledger data types
+sidebar_position: 15
 DO NOT EDIT: This file is automatically generated.
 ---
 
diff --git a/docs/compact/reference/writing.mdx b/docs/compact/reference/writing.mdx
index d1a2d1c6..b4184b62 100644
--- a/docs/compact/reference/writing.mdx
+++ b/docs/compact/reference/writing.mdx
@@ -1,13 +1,18 @@
 ---
 SPDX-License-Identifier: Apache-2.0
 copyright: This file is part of midnight-docs. Copyright (C) 2025 Midnight Foundation. Licensed under the Apache License, Version 2.0 (the "License"); You may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
-sidebar_position: 05
+title: Writing a contract
+sidebar_position: 01
 ---
 
 # Writing a contract
 
 This page walks
-through the construction of a simple smart contract, which manages a
+through the construction of a simple smart contract but it does not give
+an overview of the Compact language
+[Compact reference](compact-reference) provides a compelete and detailed
+overview of the Compact language.
+This simple contract manages a
 publicly accessible value and supports the operations `get`, `set`,
 and `clear`. Because the value is public, anyone can call `get`, but if
 the value is currently set, only the user that last called `set` can
@@ -30,7 +35,7 @@ enum State {
 
 In addition to the `enum` declaration, custom data can also be defined with
 `struct`s.  Details can be found in the 
-language reference.
+[language reference](./compact-reference.mdx#program-defined-types).
 
 ## The `ledger` section
 
@@ -89,7 +94,7 @@ export circuit get(): Uint<64> {
 
 Here `export` marks this circuit as an entry point to the smart contract, and
 `assert` ensures that it can only be used when the contract is in the correct
-state. The [language reference](./lang-ref.mdx#circuits) details permissible contents
+state. The [language reference](./compact-reference.mdx#circuit-definitions) details permissible contents
 of `circuit`s.
 
 ## Local state and computations
@@ -237,8 +242,9 @@ being suitable for storage in a contract's `ledger` state.
 
 ## Next steps
 
-This section continues with a more detailed overview of the Compact language.
-Alternatively, you may wish to jump to a [more detailed example](../../../tutorials/bboard/smart-contract.mdx)
+[Compact reference](compact-reference) provides a compelete and detailed overview
+of the Compact language.
+Alternatively, you may wish to jump to a [more detailed example](../../examples/dapps/bboard.mdx)
 that showcases some more interesting things you can do with a DApp on Midnight.
 While this section has focused on the Compact language,
 the section about how Midnight works
diff --git a/docs/examples/_counter/contract-details.mdx b/docs/examples/_counter/contract-details.mdx
index af8b4b72..77e3b505 100644
--- a/docs/examples/_counter/contract-details.mdx
+++ b/docs/examples/_counter/contract-details.mdx
@@ -32,7 +32,7 @@ To make sense of this Compact code, start in the middle, with the `ledger` field
 declaration. It says that the public state of the contract, visible on the
 Midnight blockchain, includes a field `round`. The Midnight ledger supports
 `Counter` as one of its [state
-types](../../reference/compact/lang-ref#ledger-state-types), and the field is
+types](../../reference/compact/compact-reference#ledger-state-types), and the field is
 declared to be of that type.
 
 In addition to declaring ledger fields, a contract can declare the functions
diff --git a/docs/relnotes/compact/compact-0-15-23-0.mdx b/docs/relnotes/compact/compact-0-15-23-0.mdx
index 37279d7d..2dbe5172 100644
--- a/docs/relnotes/compact/compact-0-15-23-0.mdx
+++ b/docs/relnotes/compact/compact-0-15-23-0.mdx
@@ -116,7 +116,7 @@ implemented correctly in the compiler-generated JavaScript code.  In addition to
 incorrect results, this could lead to an inability to submit transactions
 (because the proof used correct arithmetic).  This has now been fixed to work as
 described in the [language
-reference](https://docs.midnight.network/develop/reference/compact/lang-ref#binary-arithmetic-expressions).
+reference](https://docs.midnight.network/develop/reference/compact/compact-reference#binary-arithmetic-expressions).
 
 ### Fix for a crash due to incorrect common subexpression elimination
 
diff --git a/docs/relnotes/compact/compact-0-20-28-0.mdx b/docs/relnotes/compact/compact-0-20-28-0.mdx
index 9c2a99df..58ed6b16 100644
--- a/docs/relnotes/compact/compact-0-20-28-0.mdx
+++ b/docs/relnotes/compact/compact-0-20-28-0.mdx
@@ -335,8 +335,8 @@ Some of these changes are breaking changes:
 ## Links and references
 
 - The [Compact documentation portal](https://docs.midnight.network/compact),
-  including the [language reference](https://docs.midnight.network/compact/lang-ref) and
+  including the [language reference](https://docs.midnight.network/compact/compact-reference) and
   the [standard library documentation](https://docs.midnight.network/compact/compact-std-library)
 - The [Compact runtime TypeScript API](https://docs.midnight.network/api-reference/compact-runtime) for DApps
 - [Compact compiler usage](https://docs.midnight.network/compact/reference/tools/compiler-usage)
-- The [open-source project](https://github.com/LFDT-Minokawa/compact) on GitHub for bug reports and feature requests
\ No newline at end of file
+- The [open-source project](https://github.com/LFDT-Minokawa/compact) on GitHub for bug reports and feature requests
diff --git a/main_versioned_docs/version-0.0.0/develop/guides/compact-javascript-runtime.mdx b/main_versioned_docs/version-0.0.0/develop/guides/compact-javascript-runtime.mdx
index ff611774..55afe5a2 100644
--- a/main_versioned_docs/version-0.0.0/develop/guides/compact-javascript-runtime.mdx
+++ b/main_versioned_docs/version-0.0.0/develop/guides/compact-javascript-runtime.mdx
@@ -222,7 +222,7 @@ If you’re using TypeScript, the accompanying declaration file (`index.d.cts`)
 
 ### **2\. Instantiating the Contract**
 
-Every Compact contract implementation expects a [**witness object**](https://docs.midnight.network/develop/reference/compact/lang-ref#declaring-witnesses-for-private-state) when it’s created.  
+Every Compact contract implementation expects a [**witness object**](https://docs.midnight.network/develop/reference/compact/compact-reference#declaring-witnesses-for-private-state-management) when it’s created.
 This object typically contains references to cryptographic keys or helper functions that represent a party’s identity in the ZK system.
 
 Here’s a minimal example:
diff --git a/main_versioned_docs/version-0.0.0/develop/reference/compact/index.mdx b/main_versioned_docs/version-0.0.0/develop/reference/compact/index.mdx
index 2a58c4ed..73791dcd 100644
--- a/main_versioned_docs/version-0.0.0/develop/reference/compact/index.mdx
+++ b/main_versioned_docs/version-0.0.0/develop/reference/compact/index.mdx
@@ -12,10 +12,10 @@ usage hints in [the 'how Midnight works'](/docs/develop/how-midnight-works/index
 This section will provide a more in-depth breakdown of what makes up a Compact
 smart contract, starting with
 [a walkthrough of the main parts of a Compact program](/docs/develop/reference/compact/writing.mdx),
-followed by [a reference for the Compact language](/docs/develop/reference/compact/lang-ref.mdx) and 
+followed by [a reference for the Compact language](/docs/develop/reference/compact/compact-reference.mdx) and
 [the Compact standard library API reference](/compact/compact-std-library).
 
 The formal grammar for Compact and a specification of the API for
 `ledger` datatypes are available, as well (both externally generated):
-- [Compact formal grammar](https://docs.midnight.network/develop/reference/compact/lang-ref)
-- [Ledger data types](https://docs.midnight.network/develop/reference/midnight-api/compact-runtime/)
+- [Compact formal grammar](https://docs.midnight.network/develop/reference/compact/compact-grammar)
+- [Ledger data types](https://docs.midnight.network/develop/reference/ledger-adt)
diff --git a/main_versioned_docs/version-0.0.0/develop/tutorial/2-building/contract-details.mdx b/main_versioned_docs/version-0.0.0/develop/tutorial/2-building/contract-details.mdx
index af8b4b72..77e3b505 100644
--- a/main_versioned_docs/version-0.0.0/develop/tutorial/2-building/contract-details.mdx
+++ b/main_versioned_docs/version-0.0.0/develop/tutorial/2-building/contract-details.mdx
@@ -32,7 +32,7 @@ To make sense of this Compact code, start in the middle, with the `ledger` field
 declaration. It says that the public state of the contract, visible on the
 Midnight blockchain, includes a field `round`. The Midnight ledger supports
 `Counter` as one of its [state
-types](../../reference/compact/lang-ref#ledger-state-types), and the field is
+types](../../reference/compact/compact-reference#ledger-state-types), and the field is
 declared to be of that type.
 
 In addition to declaring ledger fields, a contract can declare the functions
diff --git a/packages/tests/pipelines-urls.json b/packages/tests/pipelines-urls.json
index 729efa94..38a75e47 100644
--- a/packages/tests/pipelines-urls.json
+++ b/packages/tests/pipelines-urls.json
@@ -32,7 +32,7 @@
     "/concepts/zero-knowledge-proofs",
     
     "/compact",
-    "/compact/reference/lang-ref",
+    "/compact/reference/compact-reference",
     "/compact/reference/compact-grammar",
     "/compact/reference/explicit-disclosure",
     "/compact/reference/all-keywords",
diff --git a/sidebars.compact.js b/sidebars.compact.js
index 76ce89c8..bf9f77ef 100644
--- a/sidebars.compact.js
+++ b/sidebars.compact.js
@@ -8,7 +8,7 @@ const sidebars = {
       link: { type: "doc", id: "index" },
       items: [
         "writing",               // docs/develop/reference/compact/writing.md(x)
-        "lang-ref",              // docs/develop/reference/compact/lang-ref.md(x)
+        "compact-reference",     // docs/develop/reference/compact/compact-reference.md(x)
         "compact-grammar",       // docs/develop/reference/compact/compact-grammar.md(x)
         "compact-keywords",      // docs/develop/reference/compact/compact-keywords.md(x)
         "ledger-adt",            // docs/develop/reference/compact/ledger-adt.md(x)
diff --git a/src/css/custom.css b/src/css/custom.css
index b097338c..e1a16413 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -650,7 +650,7 @@ pre {
   text-decoration: none !important;
 }
 
-/* The lang-ref code style is specific to the Compact language reference */
+/* The compact-reference code style is specific to the Compact language reference */
 /* DO NOT ALTER WITHOUT CHECKING WITH THE SHIELDED LANGUAGES TEAM. */
 /* The style essential to the readability of the language reference */
 .lang-ref code {
diff --git a/static-html/index.html b/static-html/index.html
index db11d2aa..ec0575f3 100644
--- a/static-html/index.html
+++ b/static-html/index.html
@@ -363,7 +363,7 @@ <h3>Compact Language Resources</h3>
           <li>
             <strong>Language Reference:</strong>
             <a
-              href="https://docs.midnight.network/develop/reference/compact/lang-ref"
+              href="https://docs.midnight.network/develop/reference/compact/compact-reference"
               >Complete syntax with examples</a
             >
           </li>
diff --git a/static-html/llms.txt b/static-html/llms.txt
index 67453634..d0267ba7 100644
--- a/static-html/llms.txt
+++ b/static-html/llms.txt
@@ -82,7 +82,7 @@ Compact is purpose-built for zero-knowledge applications. Unlike adapting existi
 
 **Documentation**:
 - https://docs.midnight.network/develop/reference/compact/ - Philosophy and design principles
-- https://docs.midnight.network/develop/reference/compact/lang-ref - Every syntax feature explained with examples
+- https://docs.midnight.network/develop/reference/compact/compact-reference - Every syntax feature explained with examples
 - https://docs.midnight.network/develop/reference/compact/compact-std-library/ - Built-in functions for cryptography, data structures, and blockchain interaction
 - https://docs.midnight.network/develop/reference/compact/compact-grammar - Precise specification for tools and advanced users
 
@@ -161,4 +161,4 @@ Midnight is currently in active development toward mainnet launch. The network i
 - Regular updates and improvements are ongoing
 - Partner-chains v1.5 upgrade with BLS proving system in progress
 
-This documentation reflects the current state of the technology and is updated as features are added and refined.
\ No newline at end of file
+This documentation reflects the current state of the technology and is updated as features are added and refined.
diff --git a/static/llms.txt b/static/llms.txt
index 427a0bdd..aab9f4d6 100644
--- a/static/llms.txt
+++ b/static/llms.txt
@@ -73,7 +73,7 @@ These tutorials are designed to take you from basic concepts to building product
 Compact is purpose-built for zero-knowledge applications. Unlike adapting existing languages, Compact was designed from scratch to make privacy-preserving programming natural and secure.
 
 - https://docs.midnight.network/develop/reference/compact/ - Philosophy and design principles
-- https://docs.midnight.network/develop/reference/compact/lang-ref - Every syntax feature explained with examples
+- https://docs.midnight.network/develop/reference/compact/compact-reference - Every syntax feature explained with examples
 - https://docs.midnight.network/develop/reference/compact/compact-std-library/ - Built-in functions for cryptography, data structures, and blockchain interaction
 - https://docs.midnight.network/develop/reference/compact/compact-grammar - Precise specification for tools and advanced users
 
diff --git a/vercel.json b/vercel.json
index 855183b0..ea5288be 100644
--- a/vercel.json
+++ b/vercel.json
@@ -161,13 +161,13 @@
         "permanent": true
       },
       {
-        "source": "/compact/lang-ref",
-        "destination": "/compact/reference/lang-ref",
+        "source": "/compact/compact-reference",
+        "destination": "/compact/reference/compact-reference",
         "permanent": true
       },
       {
-        "source": "/develop/reference/compact/lang-ref",
-        "destination": "/compact/reference/lang-ref",
+        "source": "/develop/reference/compact/compact-reference",
+        "destination": "/compact/reference/compact-reference",
         "permanent": true
       },
       {
@@ -206,4 +206,4 @@
         ]
       }
     ]
-  }
\ No newline at end of file
+  }

From bd8ff73386ab853eaa0672c7c7fd8920afac264d Mon Sep 17 00:00:00 2001
From: pataei <paris.ataei@gmail.com>
Date: Tue, 24 Mar 2026 10:25:38 -0600
Subject: [PATCH 36/41] latest changes of compact-reference

---
 docs/compact/reference/compact-reference.mdx | 337 ++++++++++---------
 1 file changed, 178 insertions(+), 159 deletions(-)

diff --git a/docs/compact/reference/compact-reference.mdx b/docs/compact/reference/compact-reference.mdx
index 73ccfab3..34cbaecc 100644
--- a/docs/compact/reference/compact-reference.mdx
+++ b/docs/compact/reference/compact-reference.mdx
@@ -463,7 +463,7 @@ The following are the primitive types of Compact:
   be rewritten to one that uses only bounded integer types, but the converse is
   not true.
 
-- `Field` represents the set of unsigned intergers with values up to the order of
+- `Field` represents the set of unsigned integers with values up to the order of
   the native prime field of the ZK proving system.
   The current maximum field value is given in
   [Implementation-specific limits](#implementation-specific-limits).
@@ -1478,7 +1478,7 @@ the Compact [ledger data type documentation](ledger-adt).
 
 ### Nested state types in the `Map` type
 
-In most cases, legder-state types cannot be nested within other ledger-state types.
+In most cases, ledger-state types cannot be nested within other ledger-state types.
 However, while `Map` keys must have regular Compact types, `Map` values can have
 either regular Compact types or ledger-state types (except `Kernel`).
 
@@ -1735,9 +1735,9 @@ Compact program by the Compact compiler.
 A *block* is a group of statements enclosed in braces:
 
 <div className="lang-ref-table">
-|         |         |                                                       |
-|---------|---------|-------------------------------------------------------|
-| *block* | &xrarr; | `{` [*stmt*](#statements) ⋯ [*stmt*](#statements) `}` |
+|         |         |                                                                           |
+|---------|---------|---------------------------------------------------------------------------|
+| *block* | &xrarr; | `{` [*stmt*](#syntax-of-statements) ⋯ [*stmt*](#syntax-of-statements) `}` |
 </div>
 
 A block can be used in place of a single statement anywhere a single statement
@@ -1759,48 +1759,53 @@ A block is evaluated by evaluating the statements in sequence.
 
 ## Statements
 
-The syntax of Compact statements is summarized by the following grammar snippet:
+Compact statements are used to perform computations or effects with the help of
+Compact expressions.
+
+Statements either do not have values or (in the case of
+[expression sequences serving as statements](#expression-sequences-used-as-statements))
+the values are ignored.
+Thus it is not necessary to talk about the type of a statement.
+Nevertheless, each statement has typing rules that must be followed, such as that
+the type of the test expression of an `if` statement must be `Boolean`.
+
+The first subsection of this section presents a grammar snippet that summarizes
+the syntax of Compact statements.
+The remaining subsections describe the typing and evaluation rules of the various
+kinds of statements.
+
+### Syntax of statements
 
 <div className="lang-ref-table">
-|                    |         |                                                                                                                                 |
-|--------------------|---------|---------------------------------------------------------------------------------------------------------------------------------|
-| *stmt*             | &xrarr; | `if` `(` [*expr-seq*](#expressions) `)` [*stmt*](#statements)                                                                   |
-|                    | \|      | [*stmt<sub>0</sub>*](#statements)                                                                                               |
-| *stmt<sub>0</sub>* | &xrarr; | [*expr-seq*](#expressions) `;`                                                                                                  |
-|                    | \|      | `const` [*cbinding*](#const-statements) `,` ⋯¹ `,` [*cbinding*](#const-statements)  `;`                                         |
-|                    | \|      | `if` `(` [*expr-seq*](#expressions) `)` [*stmt<sub>0</sub>*](#statements) `else` [*stmt*](#statements)                          |
-|                    | \|      | `for` `(` `const` [*id*](#terminal-names) `of` [*nat*](#terminal-names) `..` [*nat*](#terminal-names) `)` [*stmt*](#statements) |
-|                    | \|      | `for` `(` `const` [*id*](#terminal-names) `of` [*expr-seq*](#expressions) `)` [*stmt*](#statements)                             |
-|                    | \|      | `return` [*expr-seq*](#expressions) `;`                                                                                         |
-|                    | \|      | `return` `;`                                                                                                                    |
-|                    | \|      | [*block*](#blocks)                                                                                                              |
+|                    |         |                                                                                                                                                         |
+|--------------------|---------|---------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *stmt*             | &xrarr; | `if` `(` [*expr-seq*](#syntax-of-expressions) `)` [*stmt*](#syntax-of-statements)                                                                       |
+|                    | \|      | [*stmt<sub>0</sub>*](#syntax-of-statements)                                                                                                             |
+| *stmt<sub>0</sub>* | &xrarr; | [*expr-seq*](#syntax-of-expressions) `;`                                                                                                                |
+|                    | \|      | `const` [*cbinding*](#const-statements) `,` ⋯¹ `,` [*cbinding*](#const-statements)  `;`                                                                 |
+|                    | \|      | `if` `(` [*expr-seq*](#syntax-of-expressions) `)` [*stmt<sub>0</sub>*](#syntax-of-statements) `else` [*stmt*](#syntax-of-statements)                    |
+|                    | \|      | `for` `(` `const` [*id*](#terminal-names) `of` [*start*](#syntax-of-statements) `..` [*end*](#syntax-of-statements) `)` [*stmt*](#syntax-of-statements) |
+|                    | \|      | `for` `(` `const` [*id*](#terminal-names) `of` [*expr-seq*](#syntax-of-expressions) `)` [*stmt*](#syntax-of-statements)                                 |
+|                    | \|      | `return` [*expr-seq*](#syntax-of-expressions) `;`                                                                                                       |
+|                    | \|      | `return` `;`                                                                                                                                            |
+|                    | \|      | [*block*](#blocks)                                                                                                                                      |
+| *start*            | &xrarr; | [*tsize*](#primitive-types)                                                                                                                             |
+| *end*              | &xrarr; | [*tsize*](#primitive-types)                                                                                                                             |
 </div>
 
-The snippet shows that a statement (*stmt*) is either a one-armed `if` expression
+The grammar snippet above shows that a statement (*stmt*) is either a one-armed `if` statement
 or some other kind of statement (*stmt<sub>0</sub>*).
 This structure is used to enforce the restriction that the "then" part of a
-two-armed cannot be a one-armed `if` expression.
+two-armed `if` cannot be a one-armed `if`.
 This is often left ambiguous in a language grammar, with a separate note to say
 that the ambiguity is resolved by associating each "else" part with the closest
-enclosing `if` expression, but we prefer to make the constraint explicit in
-the grammar and avoid any ambiguity.
-
-The first kind of *stmt<sub>0</sub>* is *expr-seq*`;`.
-An *expr-seq*, or *expression sequence*, is a comma separated sequence of one
-or more expressions to be evaluated in sequence.
-This simply means that any expression or comma-separated sequence of expressions
-also qualifies as a statement.
-Expression sequences are described more fully in
-[their own section](#expression-sequences).
-
-The remaining subsections of this section describe each of the other kinds of
-statements.
-
-Statements either do not have a value or (in the case of expression sequences
-serving as statements) the type and value are ignored.
-Thus it is not necessary to talk about the type of a statement.
-Nevertheless, each statement has typing rules that must be followed, such as that
-the type of the test expression of an `if` statement must be `Boolean`.
+enclosing `if` statement, but here the constraint is explicit in the grammar.
+
+### Expression sequences used as statements
+
+Any *expression sequence* (*expr-seq*), i.e., comma-separated sequence of one or
+more expressions to be evaluated in sequence, can be used as a statement.
+Expression sequences are described in [their own section](#expression-sequences).
 
 ### `const` statements
 
@@ -1812,11 +1817,11 @@ Every `const` statement takes the following form:
 where each *cbinding* takes the following form:
 
 <div className="lang-ref-table">
-|                            |         |                                                                            |
-|----------------------------|---------|----------------------------------------------------------------------------|
-| *cbinding*                 | &xrarr; | [*optionally-typed-pattern*](#const-statements) `=` [*expr*](#expressions) |
-| *optionally-typed-pattern* | &xrarr; | [*pattern*](#patterns-and-destructuring)                                   |
-|                            | \|      | [*typed-pattern*](#contract-constructor)                                   |
+|                            |         |                                                                                      |
+|----------------------------|---------|--------------------------------------------------------------------------------------|
+| *cbinding*                 | &xrarr; | [*optionally-typed-pattern*](#const-statements) `=` [*expr*](#syntax-of-expressions) |
+| *optionally-typed-pattern* | &xrarr; | [*pattern*](#patterns-and-destructuring)                                             |
+|                            | \|      | [*typed-pattern*](#contract-constructor)                                             |
 </div>
 
 A `const` statement is typed by typing each of its *cbinding* subforms.
@@ -2000,68 +2005,7 @@ subsequent statements, and it returns to the caller the value of *expr-seq* or
 
 ## Expressions
 
-The syntax of Compact expressions is summarized by the following grammar snippet:
-
-<div className="lang-ref-table">
-|                    |         |                                                                                                                                                              |
-|--------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| *expr-seq*         | &xrarr; | [*expr*](#expressions)                                                                                                                                       |
-|                    | \|      | [*expr*](#expressions) `,` ⋯¹ `,` [*expr*](#expressions)  `,` [*expr*](#expressions)                                                                         |
-| *expr*             | &xrarr; | [*expr<sub>0</sub>*](#expressions) `?` [*expr*](#expressions) `:` [*expr*](#expressions)                                                                     |
-|                    | \|      | [*expr<sub>0</sub>*](#expressions) `=` [*expr*](#expressions)                                                                                                |
-|                    | \|      | [*expr<sub>0</sub>*](#expressions) `+=` [*expr*](#expressions)                                                                                               |
-|                    | \|      | [*expr<sub>0</sub>*](#expressions) `-=` [*expr*](#expressions)                                                                                               |
-|                    | \|      | [*expr<sub>0</sub>*](#expressions)                                                                                                                           |
-| *expr<sub>0</sub>* | &xrarr; | [*expr<sub>0</sub>*](#expressions) `\|\|` [*expr<sub>1</sub>*](#expressions)                                                                                 |
-|                    | \|      | [*expr<sub>1</sub>*](#expressions)                                                                                                                           |
-| *expr<sub>1</sub>* | &xrarr; | [*expr<sub>1</sub>*](#expressions) `&&` [*expr<sub>2</sub>*](#expressions)                                                                                   |
-|                    | \|      | [*expr<sub>2</sub>*](#expressions)                                                                                                                           |
-| *expr<sub>2</sub>* | &xrarr; | [*expr<sub>2</sub>*](#expressions) `==` [*expr<sub>3</sub>*](#expressions)                                                                                   |
-|                    | \|      | [*expr<sub>2</sub>*](#expressions) `!=` [*expr<sub>3</sub>*](#expressions)                                                                                   |
-|                    | \|      | [*expr<sub>3</sub>*](#expressions)                                                                                                                           |
-| *expr<sub>3</sub>* | &xrarr; | [*expr<sub>4</sub>*](#expressions) `<` [*expr<sub>4</sub>*](#expressions)                                                                                    |
-|                    | \|      | [*expr<sub>4</sub>*](#expressions) `<=` [*expr<sub>4</sub>*](#expressions)                                                                                   |
-|                    | \|      | [*expr<sub>4</sub>*](#expressions) `>=` [*expr<sub>4</sub>*](#expressions)                                                                                   |
-|                    | \|      | [*expr<sub>4</sub>*](#expressions) `>` [*expr<sub>4</sub>*](#expressions)                                                                                    |
-|                    | \|      | [*expr<sub>4</sub>*](#expressions)                                                                                                                           |
-| *expr<sub>4</sub>* | &xrarr; | [*expr<sub>4</sub>*](#expressions) `as` [*type*](#primitive-types)                                                                                           |
-|                    | \|      | [*expr<sub>5</sub>*](#expressions)                                                                                                                           |
-| *expr<sub>5</sub>* | &xrarr; | [*expr<sub>5</sub>*](#expressions) `+` [*expr<sub>6</sub>*](#expressions)                                                                                    |
-|                    | \|      | [*expr<sub>5</sub>*](#expressions) `-` [*expr<sub>6</sub>*](#expressions)                                                                                    |
-|                    | \|      | [*expr<sub>6</sub>*](#expressions)                                                                                                                           |
-| *expr<sub>6</sub>* | &xrarr; | [*expr<sub>6</sub>*](#expressions) `*` [*expr<sub>7</sub>*](#expressions)                                                                                    |
-|                    | \|      | [*expr<sub>7</sub>*](#expressions)                                                                                                                           |
-| *expr<sub>7</sub>* | &xrarr; | `!` [*expr<sub>7</sub>*](#expressions)                                                                                                                       |
-|                    | \|      | [*expr<sub>8</sub>*](#expressions)                                                                                                                           |
-| *expr<sub>8</sub>* | &xrarr; | [*expr<sub>8</sub>*](#expressions) `[` [*expr*](#expressions) `]`                                                                                            |
-|                    | \|      | [*expr<sub>8</sub>*](#expressions) `.` [*id*](#terminal-names)                                                                                               |
-|                    | \|      | [*expr<sub>8</sub>*](#expressions) `.` [*id*](#terminal-names) `(` [*expr*](#expressions) `,` ⋯ `,` [*expr*](#expressions) `,`<sup>opt</sup> `)`             |
-|                    | \|      | [*expr<sub>9</sub>*](#expressions)                                                                                                                           |
-| *expr<sub>9</sub>* | &xrarr; | [*fun*](#circuit-and-witness-calls) `(` [*expr*](#expressions) `,` ⋯ `,` [*expr*](#expressions) `,`<sup>opt</sup> `)`                                        |
-|                    | \|      | `map` `(` [*fun*](#circuit-and-witness-calls) `,` [*expr*](#expressions) `,` ⋯¹ `,` [*expr*](#expressions) `,`<sup>opt</sup> `)`                             |
-|                    | \|      | `fold` `(` [*fun*](#circuit-and-witness-calls) `,` [*expr*](#expressions) `,` [*expr*](#expressions) `,` ⋯¹ `,` [*expr*](#expressions) `,`<sup>opt</sup> `)` |
-|                    | \|      | `slice` `<` [*tsize*](#primitive-types) `>` `(` [*expr*](#expressions) `,` [*expr*](#expressions) `)`                                                        |
-|                    | \|      | `[` [*tuple-arg*](#expressions) `,` ⋯ `,` [*tuple-arg*](#expressions) `,`<sup>opt</sup> `]`                                                                  |
-|                    | \|      | `Bytes` `[` [*bytes-arg*](#expressions) `,` ⋯ `,` [*bytes-arg*](#expressions) `,`<sup>opt</sup> `]`                                                          |
-|                    | \|      | [*tref*](#primitive-types) `{` [*struct-arg*](#expressions) `,` ⋯ `,` [*struct-arg*](#expressions) `,`<sup>opt</sup> `}`                                     |
-|                    | \|      | `assert` `(` [*expr*](#expressions) `,` [*str*](#terminal-names) `)`                                                                                         |
-|                    | \|      | `disclose` `(` [*expr*](#expressions) `)`                                                                                                                    |
-|                    | \|      | [*term*](#expressions)                                                                                                                                       |
-| *term*             | &xrarr; | [*id*](#terminal-names)                                                                                                                                      |
-|                    | \|      | `true`                                                                                                                                                       |
-|                    | \|      | `false`                                                                                                                                                      |
-|                    | \|      | [*nat*](#terminal-names)                                                                                                                                     |
-|                    | \|      | [*str*](#terminal-names)                                                                                                                                     |
-|                    | \|      | `pad` `(` [*nat*](#terminal-names) `,` [*str*](#terminal-names) `)`                                                                                          |
-|                    | \|      | `default` `<` [*type*](#primitive-types) `>`                                                                                                                 |
-|                    | \|      | `(` [*expr-seq*](#expressions) `)`                                                                                                                           |
-| *struct-arg*       | &xrarr; | [*expr*](#expressions)                                                                                                                                       |
-|                    | \|      | [*id*](#terminal-names) `:` [*expr*](#expressions)                                                                                                           |
-|                    | \|      | `...` [*expr*](#expressions)                                                                                                                                 |
-| *bytes-arg*        | &xrarr; | [*tuple-arg*](#expressions)                                                                                                                                  |
-| *tuple-arg*        | &xrarr; | [*expr*](#expressions)                                                                                                                                       |
-|                    | \|      | `...` [*expr*](#expressions)                                                                                                                                 |
-</div>
+Compact expressions are used to compute values, to cause effects, or both.
 
 Every Compact expression must be well-typed (free from static type errors).
 If any expression within a program contains a static type error, it is a static
@@ -2075,9 +2019,74 @@ dynamic error, and it might have effects.
 The evaluation of an expression is defined in terms of the evaluation of its
 subexpressions.
 
-The first section below discusses how the grammar reflects the rules
-for precedence and associativity of operators, and the remaining sections
-describe the typing and evaluation rules for each kind of expression.
+The first subsection of this section provides a grammar snippet that summarizes the
+syntax of Compact expressions, and the second discusses how the grammar reflects
+the rules for precedence and associativity of operators.
+The remaining sections describe the typing and evaluation rules for each kind
+of expression.
+
+### Syntax of expressions
+
+<div className="lang-ref-table">
+|                    |         |                                                                                                                                                                                            |
+|--------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *expr-seq*         | &xrarr; | [*expr*](#syntax-of-expressions)                                                                                                                                                           |
+|                    | \|      | [*expr*](#syntax-of-expressions) `,` ⋯¹ `,` [*expr*](#syntax-of-expressions)  `,` [*expr*](#syntax-of-expressions)                                                                         |
+| *expr*             | &xrarr; | [*expr<sub>0</sub>*](#syntax-of-expressions) `?` [*expr*](#syntax-of-expressions) `:` [*expr*](#syntax-of-expressions)                                                                     |
+|                    | \|      | [*expr<sub>0</sub>*](#syntax-of-expressions) `=` [*expr*](#syntax-of-expressions)                                                                                                          |
+|                    | \|      | [*expr<sub>0</sub>*](#syntax-of-expressions) `+=` [*expr*](#syntax-of-expressions)                                                                                                         |
+|                    | \|      | [*expr<sub>0</sub>*](#syntax-of-expressions) `-=` [*expr*](#syntax-of-expressions)                                                                                                         |
+|                    | \|      | [*expr<sub>0</sub>*](#syntax-of-expressions)                                                                                                                                               |
+| *expr<sub>0</sub>* | &xrarr; | [*expr<sub>0</sub>*](#syntax-of-expressions) `\|\|` [*expr<sub>1</sub>*](#syntax-of-expressions)                                                                                           |
+|                    | \|      | [*expr<sub>1</sub>*](#syntax-of-expressions)                                                                                                                                               |
+| *expr<sub>1</sub>* | &xrarr; | [*expr<sub>1</sub>*](#syntax-of-expressions) `&&` [*expr<sub>2</sub>*](#syntax-of-expressions)                                                                                             |
+|                    | \|      | [*expr<sub>2</sub>*](#syntax-of-expressions)                                                                                                                                               |
+| *expr<sub>2</sub>* | &xrarr; | [*expr<sub>2</sub>*](#syntax-of-expressions) `==` [*expr<sub>3</sub>*](#syntax-of-expressions)                                                                                             |
+|                    | \|      | [*expr<sub>2</sub>*](#syntax-of-expressions) `!=` [*expr<sub>3</sub>*](#syntax-of-expressions)                                                                                             |
+|                    | \|      | [*expr<sub>3</sub>*](#syntax-of-expressions)                                                                                                                                               |
+| *expr<sub>3</sub>* | &xrarr; | [*expr<sub>4</sub>*](#syntax-of-expressions) `<` [*expr<sub>4</sub>*](#syntax-of-expressions)                                                                                              |
+|                    | \|      | [*expr<sub>4</sub>*](#syntax-of-expressions) `<=` [*expr<sub>4</sub>*](#syntax-of-expressions)                                                                                             |
+|                    | \|      | [*expr<sub>4</sub>*](#syntax-of-expressions) `>=` [*expr<sub>4</sub>*](#syntax-of-expressions)                                                                                             |
+|                    | \|      | [*expr<sub>4</sub>*](#syntax-of-expressions) `>` [*expr<sub>4</sub>*](#syntax-of-expressions)                                                                                              |
+|                    | \|      | [*expr<sub>4</sub>*](#syntax-of-expressions)                                                                                                                                               |
+| *expr<sub>4</sub>* | &xrarr; | [*expr<sub>4</sub>*](#syntax-of-expressions) `as` [*type*](#primitive-types)                                                                                                               |
+|                    | \|      | [*expr<sub>5</sub>*](#syntax-of-expressions)                                                                                                                                               |
+| *expr<sub>5</sub>* | &xrarr; | [*expr<sub>5</sub>*](#syntax-of-expressions) `+` [*expr<sub>6</sub>*](#syntax-of-expressions)                                                                                              |
+|                    | \|      | [*expr<sub>5</sub>*](#syntax-of-expressions) `-` [*expr<sub>6</sub>*](#syntax-of-expressions)                                                                                              |
+|                    | \|      | [*expr<sub>6</sub>*](#syntax-of-expressions)                                                                                                                                               |
+| *expr<sub>6</sub>* | &xrarr; | [*expr<sub>6</sub>*](#syntax-of-expressions) `*` [*expr<sub>7</sub>*](#syntax-of-expressions)                                                                                              |
+|                    | \|      | [*expr<sub>7</sub>*](#syntax-of-expressions)                                                                                                                                               |
+| *expr<sub>7</sub>* | &xrarr; | `!` [*expr<sub>7</sub>*](#syntax-of-expressions)                                                                                                                                           |
+|                    | \|      | [*expr<sub>8</sub>*](#syntax-of-expressions)                                                                                                                                               |
+| *expr<sub>8</sub>* | &xrarr; | [*expr<sub>8</sub>*](#syntax-of-expressions) `[` [*expr*](#syntax-of-expressions) `]`                                                                                                      |
+|                    | \|      | [*expr<sub>8</sub>*](#syntax-of-expressions) `.` [*id*](#terminal-names)                                                                                                                   |
+|                    | \|      | [*expr<sub>8</sub>*](#syntax-of-expressions) `.` [*id*](#terminal-names) `(` [*expr*](#syntax-of-expressions) `,` ⋯ `,` [*expr*](#syntax-of-expressions) `,`<sup>opt</sup> `)`             |
+|                    | \|      | [*expr<sub>9</sub>*](#syntax-of-expressions)                                                                                                                                               |
+| *expr<sub>9</sub>* | &xrarr; | [*fun*](#circuit-and-witness-calls) `(` [*expr*](#syntax-of-expressions) `,` ⋯ `,` [*expr*](#syntax-of-expressions) `,`<sup>opt</sup> `)`                                                  |
+|                    | \|      | `map` `(` [*fun*](#circuit-and-witness-calls) `,` [*expr*](#syntax-of-expressions) `,` ⋯¹ `,` [*expr*](#syntax-of-expressions) `,`<sup>opt</sup> `)`                                       |
+|                    | \|      | `fold` `(` [*fun*](#circuit-and-witness-calls) `,` [*expr*](#syntax-of-expressions) `,` [*expr*](#syntax-of-expressions) `,` ⋯¹ `,` [*expr*](#syntax-of-expressions) `,`<sup>opt</sup> `)` |
+|                    | \|      | `slice` `<` [*tsize*](#primitive-types) `>` `(` [*expr*](#syntax-of-expressions) `,` [*expr*](#syntax-of-expressions) `)`                                                                  |
+|                    | \|      | `[` [*tuple-arg*](#syntax-of-expressions) `,` ⋯ `,` [*tuple-arg*](#syntax-of-expressions) `,`<sup>opt</sup> `]`                                                                            |
+|                    | \|      | `Bytes` `[` [*bytes-arg*](#syntax-of-expressions) `,` ⋯ `,` [*bytes-arg*](#syntax-of-expressions) `,`<sup>opt</sup> `]`                                                                    |
+|                    | \|      | [*tref*](#primitive-types) `{` [*struct-arg*](#syntax-of-expressions) `,` ⋯ `,` [*struct-arg*](#syntax-of-expressions) `,`<sup>opt</sup> `}`                                               |
+|                    | \|      | `assert` `(` [*expr*](#syntax-of-expressions) `,` [*str*](#terminal-names) `)`                                                                                                             |
+|                    | \|      | `disclose` `(` [*expr*](#syntax-of-expressions) `)`                                                                                                                                        |
+|                    | \|      | [*term*](#syntax-of-expressions)                                                                                                                                                           |
+| *term*             | &xrarr; | [*id*](#terminal-names)                                                                                                                                                                    |
+|                    | \|      | `true`                                                                                                                                                                                     |
+|                    | \|      | `false`                                                                                                                                                                                    |
+|                    | \|      | [*nat*](#terminal-names)                                                                                                                                                                   |
+|                    | \|      | [*str*](#terminal-names)                                                                                                                                                                   |
+|                    | \|      | `pad` `(` [*nat*](#terminal-names) `,` [*str*](#terminal-names) `)`                                                                                                                        |
+|                    | \|      | `default` `<` [*type*](#primitive-types) `>`                                                                                                                                               |
+|                    | \|      | `(` [*expr-seq*](#syntax-of-expressions) `)`                                                                                                                                               |
+| *struct-arg*       | &xrarr; | [*expr*](#syntax-of-expressions)                                                                                                                                                           |
+|                    | \|      | [*id*](#terminal-names) `:` [*expr*](#syntax-of-expressions)                                                                                                                               |
+|                    | \|      | `...` [*expr*](#syntax-of-expressions)                                                                                                                                                     |
+| *bytes-arg*        | &xrarr; | [*tuple-arg*](#syntax-of-expressions)                                                                                                                                                      |
+| *tuple-arg*        | &xrarr; | [*expr*](#syntax-of-expressions)                                                                                                                                                           |
+|                    | \|      | `...` [*expr*](#syntax-of-expressions)                                                                                                                                                     |
+</div>
 
 ### Precedence and associativity
 
@@ -2354,7 +2363,7 @@ has a specific structure type, so does the other.
 - **Enumeration types:**
   the values are equal if they are the same enumeration member.
 - **`Opaque` types:**
-  the values are equal if the runtime values are equal according to JavaScript's
+  the values are equal if the run-time values are equal according to JavaScript's
   strict equality (`===`) operator.
 
 Otherwise the values are not equal.
@@ -2384,7 +2393,7 @@ The logical expression itself also has type `Boolean`.
 Evaluating *e<sub>1</sub> op e<sub>2</sub>* involves first evaluating
 *e<sub>1</sub>*, then:
 
-- For `||`, if *v* is `true`, *e<sub>2</sub>* is *not* evaluated, 
+- For `||`, if *v* is `true`, *e<sub>2</sub>* is *not* evaluated,
   and the value of the entire expression is `true`.
   Otherwise, *e<sub>2</sub>* *is* evaluated, and its value is the
   value of the entire expression.
@@ -2771,14 +2780,14 @@ and *e*, ⋯, *e* is a sequence of zero or more comma-separated argument express
 The function expression *fun* can take one of the following forms:
 
 <div className="lang-ref-table">
-|                        |         |                                                                                                                                            |
-|------------------------|---------|--------------------------------------------------------------------------------------------------------------------------------------------|
-| *fun*                  | &xrarr; | [*id*](#terminal-names) [*gargs*](#generic-parameters-and-arguments)<sup>opt</sup>                                                         |
-|                        | \|      | [*arrow-parameter-list*](#circuit-and-witness-calls) [*return-type*](#circuit-and-witness-calls)<sup>opt</sup> `=>` [*block*](#blocks)     |
-|                        | \|      | [*arrow-parameter-list*](#circuit-and-witness-calls) [*return-type*](#circuit-and-witness-calls)<sup>opt</sup> `=>` [*expr*](#expressions) |
-|                        | \|      | `(` [*fun*](#circuit-and-witness-calls) `)`                                                                                                |
-| *arrow-parameter-list* | &xrarr; | `(` [*optionally-typed-pattern*](#const-statements) `,` ⋯ `,` [*optionally-typed-pattern*](#const-statements) `,`<sup>opt</sup> `)`        |
-| *return-type*          | &xrarr; | `:` [*type*](#primitive-types)                                                                                                             |
+|                        |         |                                                                                                                                                      |
+|------------------------|---------|------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *fun*                  | &xrarr; | [*id*](#terminal-names) [*gargs*](#generic-parameters-and-arguments)<sup>opt</sup>                                                                   |
+|                        | \|      | [*arrow-parameter-list*](#circuit-and-witness-calls) [*return-type*](#circuit-and-witness-calls)<sup>opt</sup> `=>` [*block*](#blocks)               |
+|                        | \|      | [*arrow-parameter-list*](#circuit-and-witness-calls) [*return-type*](#circuit-and-witness-calls)<sup>opt</sup> `=>` [*expr*](#syntax-of-expressions) |
+|                        | \|      | `(` [*fun*](#circuit-and-witness-calls) `)`                                                                                                          |
+| *arrow-parameter-list* | &xrarr; | `(` [*optionally-typed-pattern*](#const-statements) `,` ⋯ `,` [*optionally-typed-pattern*](#const-statements) `,`<sup>opt</sup> `)`                  |
+| *return-type*          | &xrarr; | `:` [*type*](#primitive-types)                                                                                                                       |
 </div>
 
 In the simplest form, *fun* is just a identifier *id* referring to a witness or
@@ -2797,7 +2806,7 @@ with an optional type annotation `:` *type*.
 Finally, *fun* can be a parenthesized function `(`*fun*`)`.
 
 Because circuits and witnesses are not first class, *fun* cannot be a variable
-name or arbitary expresison.
+name or arbitrary expression.
 
 Anonymous circuits cannot have generic parameters.
 Since they appear only in contexts where they are directly called, the circuit
@@ -2974,7 +2983,7 @@ Any cast not covered by one of the rules is not allowed.
   Upcasts are never required: it is always possible to use a value of type *T*
   as a value of a supertype of *T*.
 
-  This rule is straightfoward, but some implications regarding tuple and
+  This rule is straightforward, but some implications regarding tuple and
   vector types are worth noting:
 
   - Since `Vector<`*n*, *T*`>` is the same type as `[`*T*, ⋯, *T*`]` of length *n*,
@@ -3065,7 +3074,7 @@ __Kernel operations__ are operations that do not depend on specific ledger
 state.  They can be invoked by expressions of the form *id*`.`*op*`(`*e*, ⋯, *e*`)`, where
 *id* is the name of a ledger field declared to have the special ledger-state type `Kernel`,
 *op* is the name of a builtin kernel operation, and
-*e*, ⋯, *e* is a comma separated sequence of zero or more argument expressions.
+*e*, ⋯, *e* is a comma-separated sequence of zero or more argument expressions.
 The `CompactStandardLibrary` predefines the ledger field name `kernel` to have
 ledger-state type `Kernel`, so for example, the built-in `self` operation can be called
 from a circuit as follows:
@@ -3148,7 +3157,7 @@ If, however, the value of *e* is false (the assertion fails), it is a dynamic
 error, i.e., the `assert` form halts computation of the enclosing top-level
 circuit or constructor with the message *msg*.
 
-Each assertion is checked at runtime and constrained in-circuit.
+Each assertion is checked at run time and constrained in-circuit.
 
 ### Explicit disclosure
 
@@ -3236,7 +3245,7 @@ More details are given in
 
 ## Run-time data representation
 
-The TypeScript type representing a Compact type is defined in [Representations
+The TypeScript representation of a Compact type is defined in [Representations
 in TypeScript](#representations-in-typescript).
 
 Compact represents values exactly as TypeScript represents values, i.e., as
@@ -3264,32 +3273,34 @@ Certain values to be stored in public state require size, length, and other
 properties to be maintained explicitly, because these properties cannot
 be determined solely from the JavaScript representation of the value.
 For this purpose, the `@midnight/compact-runtime` package provides explicit
-runtime types satisfying the `CompactType<T>` interface, where `T` is the
+run-time types satisfying the `CompactType<`*T*`>` interface, where `T` is the
 corresponding TypeScript type.
 This representation is *not* user-facing most of the time, except
 when replicating the behavior of the operations implemented
 in `@midnight/compact-runtime`.
 
-The following constructors can be used to create a `CompactType` instance
+The following types or constructors can be used to create a `CompactType` instance
 for a primitive type:
 
-- `Boolean` - `new CompactTypeBoolean()`
-- `Field` - `new CompactTypeField()`
-- `Uint<0..n>` - `new CompactTypeUnsignedInteger(n, length)`, where
-  `length` is the number of bytes required to store `n`
-- `Uint<n>` - as `Uint<0..(2 ** n) - 1>`
-- `Bytes<n>` - `new CompactTypeBytes(n)`
-- `Vector<n, T>` - `new CompactTypeVector(n, rt_T)`, where `rt_T` is the runtime
-  type of `T`
-- `Opaque<"String">` - `new CompactTypeString()`
-- `Opaque<"Uint8Array">` - `new CompactTypeUint8Array()`.
+- `Boolean` - `CompactTypeBoolean`
+- `Field` - `CompactTypeField`
+- `Uint<0..`*n*`>` - `new CompactTypeUnsignedInteger(`*n*`, `*length*`)`, where
+  *length* is the number of bytes required to store *n*
+- `Uint<`*n*`>` - same as `Uint<0..(2 ^ `*n*`)>`
+- `Bytes<`*n*`>` - `new CompactTypeBytes(`*n*`)`
+- `Vector<`*n*`, `*T*`>` - `new CompactTypeVector(`*n*`, `*rt_T*`)`, where *rt_T* is the run-time
+  type of *T*
+- `Opaque<"String">` - `CompactTypeString`
+- `Opaque<"Uint8Array">` - `CompactTypeUint8Array`
+- `JubjubPoint` - `CompactTypeJubjubPoint`.
+
 
 For program-defined types, structures are not currently easily
-constructed at runtime and require implementing `CompactType<T>`
+constructed at run time and require implementing `CompactType<`*T*`>`
 manually or using compiler internals.  Enumerations are exposed
-through `new CompactTypeEnum(maxValue, length)`, where `maxValue` is
-the maximum permissible integer assignable, and `length` its
-representation length in bytes (almost always 1).
+through `new CompactTypeEnum(`*maxValue*`, `*length*`)`, where *maxValue* is
+the maximum permissible integer assignable, and *length* its
+representation length in bytes (almost always `1`).
 
 ## TypeScript target
 
@@ -3302,7 +3313,8 @@ TypeScript, in the form of a `index.js` JavaScript implementation file and a
 `index.d.ts` type declaration file. For most uses, it is recommended to rely on the
 information and interface provided in `index.d.ts`.
 
-For each of the impure circuits, a zero-knowledge prover/verifier key pair is also
+
+For each of the impure circuits that touches the public ledger, a zero-knowledge prover/verifier key pair is also
 generated, as well as instructions for proof generation. These can be found
 in the output directory's `keys` and `zkir` subdirectories respectively.
 
@@ -3317,35 +3329,42 @@ A contract exports the following in the TypeScript module:
 
 - The TypeScript type corresponding to each program-defined type exported from the
   contract's top level
-- A `Witnesses<T>` type, which describes the format external witnesses must
+- A `Witnesses<PS>` type, which describes the format external witnesses must
   satisfy to instantiate the contract
-- A `ImpureCircuits<T>` type, which describes the set of impure circuits exported
+- A `ImpureCircuits<PS>` type, which describes the set of impure circuits exported
   from the contract's top level
+- A `ProvableCircuits<PS>` type, which describes the set of circuits exported
+  from the contract's top level that have verifier keys (i.e., exported circuits
+  that touch the public ledger)
 - A `PureCircuits` type, which describes the set of pure circuits exported from
   the contract's top level
-- A `Circuits<T>` type, which describes the set of all exported circuits
-- A `Contract<T, W extends Witnesses<T> = Witnesses<T>>` class, which:
+- A `Circuits<PS>` type, which describes the set of all exported circuits
+- A `Contract<PS = any, W extends Witnesses<PS> = Witnesses<PS>>` class, which:
   - can be constructed by passing in an instance of `W`
-  - exposes members `circuits: Circuits<T>` and `impureCircuits: ImpureCircuits<T>`
+  - exposes members `circuits: Circuits<PS>`, `impureCircuits: ImpureCircuits<PS>`,
+    and `provableCircuits: ProvableCircuits<PS>`
   - provides initial contract states via
-    `initialState(privateState: T): [T, runtime.ContractState]`
+    `initialState(context: __compactRuntime.ConstructorContext<PS>, `*x*`: `*T*`, `*y*`: `*T*`, ...): runtime.ConstructorResult<PS>`
+    where *x*`: `*T*`, `*y*`: `*T*`, ...` are the contract constructor parameters and their
+    type declarations if they exist
 - A constant `pureCircuits: PureCircuits` object, providing all pure circuits
   as pure functions
 - A `Ledger` type, providing views into a current ledger state, by permitting
   direct calls of all read functions of `ledger` objects, as well of some
   TypeScript specific ones that cannot be called from Compact, such as iterators
-- A `ledger(state: runtime.StateValue): Ledger` constructor of the `Ledger` type,
+- A `ledger(state: runtime.StateValue | runtime.ChargedState): Ledger`
+  constructor of the `Ledger` type,
   giving access to the values of exported ledger fields.
 
-The argument `T` for a number of these should be interpreted as the type of the
+The argument `PS` for a number of these should be interpreted as the type of the
 local/private state. For the most part, `circuit` and `witness` functions are
 translated simply by translating their Compact types into corresponding
 TypeScript types for parameters and return values. For `PureCircuits`, this is
 all that happens, for the other `_Circuits` instances, they receive an
-additional first parameter of type `runtime.CircuitContext<T>`, and their result
-type `R` is wrapped in `runtime.CircuitResults<T, R>`. For `Witnesses`, they
+additional first parameter of type `runtime.CircuitContext<PS>`, and their result
+type *R* is wrapped in `runtime.CircuitResults<PS, `*R*`>`. For `Witnesses`, they
 receive an additional first parameter of type `runtime.WitnessContext<Ledger,
-T>`, and their result type `R` is wrapped in `[T, R]`. See the [runtime API
+PS>`, and their result type *R* is wrapped in `[PS, `*R*`]`. See the [runtime API
 docs](/api-reference/compact-runtime) for the
 details of these types. This wrapping makes the entirety of the contract code
 *functional*, ensuring calls have no hidden side effects.
@@ -3355,17 +3374,17 @@ details of these types. This wrapping makes the entirety of the contract code
 Compact's primitive types are represented in TypeScript as follows:
 
 - `Boolean` - `boolean`
-- `Field` - `bigint` with runtime bounds checks
-- `Uint<n>` / `Uint<0..n>` - `bigint` with runtime bounds checks
-- `[T, ...]` - the TypeScript tuple type `[S, ...]` or else the TypeScript array
-  type `S[]` with runtime length checks, where `S` is the TypeScript
-  representation of the corresponding type `T`
-- `Bytes<n>` - `Uint8Array` with runtime length checks
+- `Field` - `bigint` with run-time bounds checks
+- `Uint<`*n*`>` / `Uint<0..`*n*`>` - `bigint` with run-time bounds checks
+- `[`*T*`, ...]` - the TypeScript tuple type `[`*S*`, ...]` or else the TypeScript array
+  type *S*`[]` with run-time length checks, where *S* is the TypeScript
+  representation of the corresponding type *T*
+- `Bytes<`*n*`>` - `Uint8Array` with run-time length checks
 - `Opaque<"string">` - `string`
 - `Opaque<"Uint8Array">` - `Uint8Array`
 
 Program-defined types are represented in TypeScript as follows:
-- `enum` instances - a `number` with runtime membership checks
+- `enum` instances - a `number` with run-time membership checks
 - `struct` instances with fields `a: A, b: B, ...` - an object `{ a: A, b: B, ... }`
   where `A`, `B`, ... are the TypeScript representations of the Compact types.
 

From f850fc24fd8951dbb32e12745d94959824e6f37b Mon Sep 17 00:00:00 2001
From: pataei <paris.ataei@gmail.com>
Date: Tue, 24 Mar 2026 11:39:34 -0600
Subject: [PATCH 37/41] small edit

---
 docs/compact/reference/writing.mdx | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/docs/compact/reference/writing.mdx b/docs/compact/reference/writing.mdx
index 948121cd..6de8ec03 100644
--- a/docs/compact/reference/writing.mdx
+++ b/docs/compact/reference/writing.mdx
@@ -8,11 +8,7 @@ sidebar_position: 01
 # Writing a contract
 
 This page walks
-through the construction of a simple smart contract but it does not give
-an overview of the Compact language
-[Compact reference](compact-reference) provides a compelete and detailed
-overview of the Compact language.
-This simple contract manages a
+through the construction of a simple smart contract, which manages a
 publicly accessible value and supports the operations `get`, `set`,
 and `clear`. Because the value is public, anyone can call `get`, but if
 the value is currently set, only the user that last called `set` can

From 5b1a33f89994f443c19822f50e19386016b106f5 Mon Sep 17 00:00:00 2001
From: pataei <paris.ataei@gmail.com>
Date: Tue, 24 Mar 2026 12:28:32 -0600
Subject: [PATCH 38/41] apply David's feedback

---
 vercel.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/vercel.json b/vercel.json
index 5de3e623..a1688a59 100644
--- a/vercel.json
+++ b/vercel.json
@@ -161,12 +161,12 @@
         "permanent": true
       },
       {
-        "source": "/compact/compact-reference",
+        "source": "/compact/lang-ref",
         "destination": "/compact/reference/compact-reference",
         "permanent": true
       },
       {
-        "source": "/develop/reference/compact/compact-reference",
+        "source": "/develop/reference/compact/lang-ref",
         "destination": "/compact/reference/compact-reference",
         "permanent": true
       },

From 2dbf9d230a120dd709715d7da125a4dcf1310362 Mon Sep 17 00:00:00 2001
From: pataei <paris.ataei@gmail.com>
Date: Tue, 24 Mar 2026 13:03:37 -0600
Subject: [PATCH 39/41] add padding to code snippets in lang ref

---
 src/css/custom.css | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/css/custom.css b/src/css/custom.css
index e1a16413..8783cd90 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -661,7 +661,7 @@ pre {
   white-space: pre-wrap;
   vertical-align: baseline !important;
   background-color: transparent;
-  padding: 0;
+  padding: 4px;
   border-radius: 0;
   border: none;
 }

From b4e5583e3701e5e353a0ed80c63835c74102869f Mon Sep 17 00:00:00 2001
From: Kent Dybvig <18339284+dybvig@users.noreply.github.com>
Date: Tue, 24 Mar 2026 20:16:29 +0100
Subject: [PATCH 40/41] increased code {} and lang-ref code {} padding to 2px;
 added border: node to code{}; added <div className="lang-ref"> ... </div>
 around the content of explicit-disclosure.mdx and writing.mdx.

---
 docs/compact/reference/explicit-disclosure.mdx | 2 ++
 docs/compact/reference/writing.mdx             | 2 ++
 src/css/custom.css                             | 5 +++--
 3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/docs/compact/reference/explicit-disclosure.mdx b/docs/compact/reference/explicit-disclosure.mdx
index bc3f1be2..45204bd6 100644
--- a/docs/compact/reference/explicit-disclosure.mdx
+++ b/docs/compact/reference/explicit-disclosure.mdx
@@ -5,6 +5,7 @@ title: Explicit disclosure
 sidebar_position: 10
 ---
 
+<div className="lang-ref">
 # Explicit disclosure in Compact: The Midnight "Witness Protection Program"
 
 ## Introduction
@@ -159,3 +160,4 @@ The abstract interpreter evaluates the program as if the abstract values were ac
 ## Conclusion
 
 The `disclose()` wrapper in Compact enforces deliberate programming decisions when dealing with potentially sensitive private witness data and data derived from private information. Explicit disclosure requires Compact program assignments to declare an intention to use data that might be private before storing it in the public ledger, returning it from an exported circuit, or passing it to another contract. This makes privacy the default and disclosure an explicit exception, reducing the risk of accidental disclosure.
+</div>
diff --git a/docs/compact/reference/writing.mdx b/docs/compact/reference/writing.mdx
index 6de8ec03..a985ae8d 100644
--- a/docs/compact/reference/writing.mdx
+++ b/docs/compact/reference/writing.mdx
@@ -5,6 +5,7 @@ title: Writing a contract
 sidebar_position: 01
 ---
 
+<div className="lang-ref">
 # Writing a contract
 
 This page walks
@@ -249,3 +250,4 @@ provides more detail about Midnight's ledger and how it functions.
 [^1] The name *witness* comes from zero-knowledge literature; the etymology is
 roughly that it's the evidence you need to believe a statement. In this
 example, it's the evidence you need to believe that a `clear` was permissible.
+</div>
diff --git a/src/css/custom.css b/src/css/custom.css
index 8783cd90..f322e3a8 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -526,8 +526,9 @@ code {
   white-space: pre-wrap;
   vertical-align: baseline !important;
   background-color: transparent;
-  padding: 0;
+  padding: 2px;
   border-radius: 0;
+  border: none;
 }
 
 pre {
@@ -661,7 +662,7 @@ pre {
   white-space: pre-wrap;
   vertical-align: baseline !important;
   background-color: transparent;
-  padding: 4px;
+  padding: 2px;
   border-radius: 0;
   border: none;
 }

From addd34f32759bba09c55ca8fa74549ee1a12348e Mon Sep 17 00:00:00 2001
From: pataei <paris.ataei@gmail.com>
Date: Wed, 25 Mar 2026 10:19:09 -0600
Subject: [PATCH 41/41] fix broken link

---
 CODEOWNERS | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CODEOWNERS b/CODEOWNERS
index 90363b1d..aaea9eac 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -1,6 +1,6 @@
 * @midnightntwrk/mn-techwriting @midnightntwrk/mn-devrel @midnightntwrk/mn-codeowners-docs
 
-/docs/develop/reference/compact/compact-reference.mdx @midnightntwrk/mn-codeowners-compact @midnightntwrk/mn-codeowners-docs
+/docs/compact/ @midnightntwrk/mn-codeowners-compact @midnightntwrk/mn-codeowners-docs
 /.github/ISSUE_TEMPLATE/ @midnightntwrk/mn-security @midnightntwrk/mn-sre
 /.github/PULL_REQUEST_TEMPLATE/ @midnightntwrk/mn-security @midnightntwrk/mn-sre
 /.github/workflows/scan.yaml @midnightntwrk/mn-security @midnightntwrk/mn-sre