v3.0.0

Breaking changes:

• New Some/None constructors for Optional values

  Including: Prelude: Use new Some and None constructors

  You can now use Some and None to build Optional values, and Some
  does not require providing the type:

  -- The type annotations are optional, but provided for clarity
  
  Some 1 : Optional Natural
  
  None Natural : Optional Natural

  This is a breaking change because Some and None are now reserved
  keywords. For example, the following code breaks as a result of this
  change:

  λ(Some : Type) → Some

  This is also a breaking change because it removes Optional/Some and
  Optional/None from the Prelude

• Add kind-polymorphism

  Including: Fix to allow type-level functions as record fields

  This adds support for kind-level programming by adding a new type-checking
  constant named Sort above Kind in the hierarchy of types:

  Type : Kind : Sort

  This is a breaking change because Sort is now a reserved keyword. For
  example, the following code breaks as a result of this change:

  λ(Sort : Type) → Sort

• Update versioning policy for the standard and binary protocol

  This changes how the standard versions the binary protocol. The protocol
  now shares the same version number as the rest of the standard.

  That is not the breaking change, though, since it does not forbid older
  versions of the standard using the older protocol version string.

  The actual breaking change is that compliant interpreters can no longer
  mix language features from different versions of the standard within a
  single run of the interpreter. For example, you would not be able to an
  interpret an expression containing a new language feature alongside an
  import protected by a semantic integrity check preceding that language
  feature. Either the new language feature of the semantic integrity check
  would fail depending on which standard version the interpreter was
  implementing. Previously newer language features were compatible with
  older semantic integrity checks.

• Normalize record types and literals generated by operators

  This ensures that records generated by operators have their fields sorted.

  For example, before this change, the following expression:

  { foo = 1 } ∧ { bar = True }

  ... would β-normalize to:

  { foo = 1, bar = True }

  ... and now β-normalizes to:

  { bar = True, foo = 1 }

  This is technically a breaking change in the sense that the standard no
  longer guarantees that record equality is order insensitive, although in
  practice records are usually only compared after they have been
  β-normalized (and therefore had their fields sorted).

New features:

• Prelude: Add {Integer,Natural}/toDouble

  This ensures consistency with the rest of the Prelude by re-exporting two
  built-ins that were missing

• Specify associativity for repeated elements

  Including: Prelude: Parenthesize right-associative output

  The grammar now specifies the associativity of repeated elements (such as
  operators).

  This is not a breaking change because the behavior was not previously
  standardized. Also, all operators are associative, so the associativity
  does not affect their behavior.

Other changes:

• Clarify the binary encoding of text literals

• Fix typo