New features:

• Support binary literals for Natural and Integer literals

  You can now use 0b… notation for Natural literals and ±0b… notation for
  Integer literals to write them out in binary.

  For example:

  0b101010  -- Same as: 42
  +0b1011   -- Same as: +11
  -0b111    -- Same as: -7

• Add Prelude.Function.composeList

Other changes:

• Fixes and improvements to the standard:
  • Fix reference implementation to not emit extra minus sign
  • Fix the standard grammar
  • Several assorted fixes to the standard
• Fixes and improvements to the standard test suite:
  • Fix an import test

Breaking changes:

• New support for Bytes literals

  You can now store Bytes within Dhall, which comprises two changes to the
  language:

  • A new Bytes type

  • Support for Bytes literals of the form 0x"…"

  For example, the following Dhall literal represents a valid sequence of four
  bytes:

  0x"00FF12DE"

  This is a technically breaking change because Bytes is now a reserved
  identifier.

• New {Date,Time,TimeZone}/show builtins

  You can now render temporal literals as Text representing valid Dhall
  source code:

  Date/show : Date → Text
  
  Time/show : Time → Text
  
  TimeZone/show : TimeZone → Text

  For example:

  ⊢ Date/show 2000-01-01
  
  "2000-01-01"
  
  ⊢ Time/show 11:59:59
  
  "11:59:59"
  
  ⊢ TimeZone/show -08:00
  
  "-08:00"

  This is a technically breaking change because Date/show, Time/show, and
  TimeZone/show are now reserved identifiers.

New features:

• Add dhall to-directory-tree related definitions

  This adds several utilities underneath a new Prelude.DirectoryTree
  hierarchy for working with the dhall to-directory-tree subcommand.
  Specifically, the sucommand now supports setting metadata on generated paths
  and the utilities support working with this new metadata-related
  functionality.

• Add Prelude.List.mapMaybe and Prelude.Map.mapMaybe

  These come in handy when transforming Lists in Maps when you also want to
  filter out keys.

Other changes:

• Fixes and improvements to the standard:
  • Remove Unicode char ± from ABNF
• Fixes and improvements to the standard test suite:
  • Fix None-related teest
  • Add test for changing type of field inside Optional

Breaking changes:

• New showConstructor keyword for converting union alternative to Text

  You can now render the constructor name for a union alternative using the
  showConstructor keyword, like this:

  let Example = < A : Bool | B >
  
  in  [ showConstructor (Example.A True), showConstructor Example.B ]

  … which evaluates to:

  [ "A", "B" ]

  showConstructor also works on Optional and Bool values, too:

  >>> showConstructor (None Bool)
  "None"
  >>> showConstructor (Some True)
  "Some"
  >>> showConstructor True
  "True"
  >>> showConstructor False
  "False"

• Require non-empty whitespace after let binding

  Before this change an expression like this was permitted:

  let x = 3let y = x in y

  … because the grammar did not require non-empty whitespace in between let
  bindings. Now the grammar requires non-empty whitespace in between bindings
  so the above expression is no longer permitted.

New features:

• Add with support for modifying Optional values

  You can now use a path component named ? to modify values nested inside of
  Optional types, like this:

  >>> { x = Some { y = 2 } } with x.?.y = 3
  { x = Some { y = 3 } }

  You can even use this to update an Optional value without any record fields:

  >>> Some 0 with ? = 1
  Some 1

• Add Prelude.List.filterMap

Other changes:

• Fixes and improvements to the standard:
  • Fix empty lines inside the definition of rules
  • Fix reference implementation of α-normalization
  • Fix reference implementation of shift
  • Fix reference implementation of Natural/build
  • Fix reference implementation of Text/replace
  • Fix typos in binary encoding spec
  • Correct type for header configuration
• Fixes and improvements to the standard test suite:
  • Add test for importing relative to the home directory
  • Add test for Some label in with expression
  • Fix header forwarding test

New features:

• Fix merge and toMap annotations to behave the same as ordinary type annotations

  Before this change an expression like this:

  λ(x : <>) → merge {=} x : ∀(a : Type) → a

  … would not have type-checked as it would have been parsed as:

  λ(x : <>) → (merge {=} x) : ∀(a : Type) → a

  … where the ∀(a : Type) → a is treated as an ordinary type annotation and
  not a merge-specific annotation used to handle the special case of an empty
  merge.

  After this change, the type annotations that are specially-associated with
  merge and toMap expressions to handle their empty cases behave the same as
  ordinary type annotations.

• Permit a trailing line comment without a newline

• Add Prelude.Text.shell-escape

• Add Prelude.XML support for non-escaped Text

Other changes:

• Fixes and improvements to the standard:

  • Remove unused date-time and full-time abnf rules
  • Fix logic for inferring type of constructor
  • Fix judgment for origin-based header support
  • Fix parent imports when resolving headers.dhall

Breaking changes:

• Standardize support for dates / times / time zones

  Dhall now provides language support for time types and literals, including
  almost all combinations of dates, time, and time zones.

  For example, these are all valid temporal literals and their corresponding
  types:

  2020-01-01                : Date
  00:00:00                  : Time
  +00:00                    : TimeZone
  2020-01-01T00:00:00       : { date : Date, time : Time }
  00:00:00+00:00            : { time : Time, timeZone : TimeZone }
  2020-01-01T00:00:00+00:00 : { date : Date, time : Time, timeZone : TimeZone }

  Currently there are not yet built-in functions associated with temporal
  values. This change only adds the new types and support for projecting out
  components of complex literals as record fields.

  This is a breaking change because Date / Time / TimeZone are now
  reserved identifier names.

• Change ? to only fall back on absent imports

  The ? operator will no longer recover from type errors, parse errors,
  hash mismatches, or cyclic imports found within the first import. The second
  import will only be tried if the first import cannot be retrieved at all
  (either from cache or the specified location).

  This is a breaking change because some Dhall programs which used to succeed
  will now fail. Specifically, a program which relied on the ? operator to
  recover from non-import-related errors will now begin to fail.

Other changes:

• Fixes and improvements to the standard test suite:
  • Add parser failure test for whitespace before with
  • Fix Prelude test files to use .dhall suffix
  • Test changes for dhall-purescript

New features:

• Add support for origin-based header configuration

  You can now customize headers out-of-band by creating a headers.dhall file
  in one of the following locations:

  • ~/.config/dhall/headers.dhall
  • ${XDG_CONFIG_HOME}/dhall/headers.dhall
  • env:DHALL_HEADERS

  This headers file has type Map Text (Map Text Text) and might look something
  like this:

  toMap {
    `raw.githubusercontent.com:443` = toMap { Authorization = "TOKEN" }
  }

  Where each outer Map key is of the form host:port and the nner Map
  contains custom header-value pairs. These custom headers are supplied
  to any imports destined for tht origin.

  These out-of-band custom headers work in conjunction with the in-band custom
  headers supplied by the using keyword, but the out-of-band custome headers
  take precedence. For example, if one were to import:

  https://raw.githubusercontent.com/example.dhall using
    ( toMap
      { Authorization = "ANOTHER TOKEN"
      , User-Agent = "dhall"
      }
    )

  … then the User-Agent header would now also be set to "dhall", but the
  Authorization would still be "TOKEN".

• Add Prelude support for NonEmpty lists

New features:

• Add support for Unix shebangs

  Dhall files can now begin with any number of lines starting with #!.

  This comes in handy if you want to specify how to interpret the file using the
  Unix shebang convention, like this:

  #!/usr/bin/env -S dhall text --file
  
  "Hello, world!"

  See also: Add support for extra Unix shebangs

• Add Prelude.Text.{lower,upper}ASCII utilities

  You can now uppercase and lowercase ASCII characters in Text using these
  two new Prelude utilities

• Add Prelude.List.foldLeft

  This lets you fold a list in the opposite direction of Prelude.List.fold

Other changes:

• Fixes and improvements to the standard:

  • Fix typo in syntax.md
  • Add reference implementation of parser
  • Add CORS tests
  • More CORS tests
  • Add tests for Text/replace ""
  • Add a batch of tests

• Fixes and improvements to the Prelude:

  • Change */fold examples to use different accumulator type
  • Prelude: Escape XML text using the &…; method

New features:

• Improve Prelude.JSON.render output

  Prelude.JSON.render now renders $ as itself instead of \u0024

Other changes:

• Expand literate Haskell semantics

Breaking changes:

• Text/replace waits to replace interpolated Text

  Text/replace will now not reduce if the Text literal to replace has any
  interpolated subexpressions.

  For example, before this change, the following expression:

  λ(x : Text) → Text/replace "a" "b" "a${x}"

  … would normalize to:

  λ(x : Text) → "b${x}"

  After this change, the former expression is in normal form and won't reduce
  further so long as the interpolated expression remains abstract.

  This change was made to fix the fact that the old behavior for Text/replace
  was not confluent, meaning that the behavior would change depending on which
  order normalization rules were applied. For example, the following
  expression would give different results:

  let x = "a" in Text/replace "a" "b" "b${x}"

  … depending on whether or not x was substituted into the interpolated
  Text literal before or after Text/replace performed the replacement.

  This is a technically breaking change because it would change the integrity
  check for any expression replacing a Text literal with abstract
  interpolated subexpressions. In practice, you are unlikely to be affected by
  this change.

• Normalize Text/replace when "needle" is empty and other arguments are abstract

  Text/replace will now always normalize if the first argument is the empty
  string, regardless of whether or not the other two arguments are abstract.

  Or in other words:

  Text/replace "" replacement haystack

  … will always reduce to:

  haystack

  This is a technically breaking change along the same lines as the previous
  change and is also unlikely to affect you in practice.

• Prelude.XML.render now correctly escapes unsanitized input

  The new version of the utility uses Text/replace to escape unsanitized
  input, in order to guarantee that the rendered XML is always well-formed.

  This is a breaking change because the rendered output will be different if the
  input contained special characters (like <). However, it's more likely that
  this change will fix your code rather than break it (unless you were depending
  on the old behavior as an escape hatch for XML injection).

New features:

• if expressions can now return types and kinds

  For example, the following expressions are now valid:

  if b then Natural else Integer

  if b then Type → Type else Type

  This makes the behavior of if expressions consistent with the behavior of
  the equivalent merge expression for a union of type < True | False >.

• Add Prelude.JSON.renderCompact

Other changes:

• Fixes and improvements to the standard:

  • Fix typo in re-escaping rule of multiline strings
  • Literate Haskell Semantics - Syntax

• Fixes and improvements to the standard test suite:

  • Fix two type inference tests

Breaking changes:

• Implement with directly rather than via desugaring

  The standard now defines with directly, rather than via a
  desugaring step. This changes the normalization behaviour of with
  expressions in three ways: first, with expressions on abstract
  variables such as

  λ(r : { foo : Text }) → r with bar = "baz"

  will now remain unchanged after normalization, whereas previously
  this expression would have normalised to:

  λ(r : { foo : Text }) → r ⫽ { bar = "baz" }

  The second way normalization has changed is a consequence of the
  above: certain with expressions used to take advantage of
  simplification of ⫽ expressions. For example:

  (e with k = v).k

  used to normalize to v, but now normalizes to itself.

  The third change to normalization is that it is no longer a type
  error to add multiple layers of nesting into a record at once:

  {} with x.y.z = 3

  This expression normalizes to:

  { x = { y = { z = 3 }}}

  which can also be written:

  { x.y.z = 3 }

  This is technically a breaking change due to the changes to
  normalization; this also means that the semantic hash of files which
  contain with expressions may change.

New features:

• New Text/replace builtin

  This change adds a builtin Text/replace which makes it possible to
  replace substrings inside a Text literal. It has type Text → Text → Text. For example, the following expression normalizes to
  "Hello, world!":

  Text/replace "Hey" "Hello" "Hey, world!"

  For more information, see the Text/replace documentation.

• Add Prelude/Optional/concatMap

• Add function versions of built-in operators

Breaking changes:

• Enable with optimizations

  The standard now gives implementations more freedom to optimize the
  β-reduction of with expressions, mainly in order to avoid pathological
  time and space complexity when interpreting chained with expressions, like:

  r with x.y = a with z = b

  Along the way, this changes how with expressions are encoded in the
  binary representation, which means that this is a technically breaking
  change.

  In practice, you are unlikely to to be affected by this change, except for the
  rare case where you protect an import with a semantic integrity check and the
  contents of the protected import contain a with expression where the
  left-hand side of the with expression is abstract, such as this one:

  λ(x: { a : Natural}) → x with a = 42 

  Other than that, semantic integrity checks are not affected because the
  interpreter will β-normalize away the with expression, which will then
  not affect the final hash.

New features:

• Add Prelude/Map/unpackOptionals

Other changes:

• Fixes and improvements to the Prelude:

  • Use dhall-docs comment format for Prelude
  • Amend relative import expressions on Prelude to use .dhall extensions