1.31.1

• BUG FIX: Allow whitespace after record pun entry
  • The record pun feature introduced in the previous release did not
    correctly parse record puns with trailing whitespace, which this change
    fixes.
• Expose {default,}InputNormalizer
  • The previous version introduced a breaking change to the autoWith type
    that required access to the implementation of InputNormalizer, which was
    not exported. This change fixes that.
• Build against latest dependencies
  • QuickCheck-2.14
  • haskell-lsp-0.21
  • repline-0.3 / haskeline-0.8
  • template-haskell-2.16
• Prefer to format using record puns when possible
  • dhall format will now reformat code to use record puns when applicable
• Fixes and improvements to error messages:
  • #1721

1.31.0

• Supports version 15.0.0 of the standard
  • Implement with keyword
    • You can now write someRecord with a.b.c = x to update a nested
      fields
  • Add support for record puns
    • You can now write { x, y } as a shorthand for { x = x, y = y }
• BREAKING CHANGE TO THE API: Auto-derive Generic/FromDhall/ToDhall with Template Haskell
  • Now the Dhall.TH.makeHaskell* utilities will include these derived
    instances in the generated declarations
  • This is a breaking change since users were likely already generating these
    instances separately, which will now conflict with the included instances
• BREAKING CHANGE TO THE API: From/ToDhall no longer takes InterpretOptions argument
  • The types of the autoWith and injectWith methods have changed to
    take an InputNormalizer instead of an InterpretOptions
    • Note that InputNormalizer is a subset of InterpretOptions
  • This is a breaking change to how derived FromDhall / ToDhall instances
    are customized to more closely match how other Haskell packages customize
    derived instances (e.g. aeson with FromJSON / ToJSON)
    • Previously you would customize the behavior globally by passing in
      a top-level InterpretOptions record to autoWith
    • Now you can customize the behavior locally on a per-instance basis
  • This change enables the following change ...
• Add Dhall.Deriving module for deriving-via helpers
  • Now you can take advantage of the -XDerivingVia language extension to
    customize derived FromDhall/ToDhall instances, like this:
    • deriving (FromDhall, ToDhall) via Codec (SetSingletonConstructors Bare) Name
• BREAKING CHANGE TO THE LANGUAGE: Match standard with respect to using toMap
  • https://example.com using toMap customHeaders is now a parse error
    and needs to be explicitly parenthesized as
    https://example.com using (toMap customHeaders)
  • The language standard had always required the parentheses, but the Haskell
    implementation was not correctly matching the standard
• Fix formatting of indented comments containing empty lines
  • dhall format was previously not idempotent when formatting indented
    comments with empty lines
  • Specifically, the formatter kept indenting things further with each
    format, which this change fixes
• Fix pretty-printer to preserve original numeric literals
  • Now dhall format will preserve numeric literals exactly how you wrote
    them
  • For example, 0xFF will no longer be reformatted as 255
• Add dhall to-directory-tree support for Maps
  • Maps are now converted to directories (just like records)
• Add manpage
  • ... mainly for the benefit of people packaging Dhall for various
    distributions
• Group commands in CLI
  • The command-line --help output now groups commands into useful
    sections
• Fix numeric parsing for GHCJS
  • The GHCJS backend for Dhall was failing to parse numbers, which this
    change fixes
• Fixes and improvements to error messages:
  • #1656
  • #1698
  • #1702
• Fixes and improvements to the haddocks:
  • #1708
  • #1712

1.30.0

• Supports version 14.0.0 of the standard
• BREAKING CHANGE TO THE API: Add --check flag to dhall {lint,freeze}
  • You can now use the --check flag to verify that a file has already been
    linted or frozen
  • This is a breaking change to the types used by the Dhall.Format module
• BREAKING CHANGE TO THE LANGUAGE: Disallow Natural literals with leading zeros
  • Now a literal like 042 is no longer valid
  • See the changelog for standard version 14.0.0 for more details
• BUG FIX: Fix parsing of Double literal trailing whitespace
  • Certain expressions using Double literals would fail to parse, which this
    change fixes
• BUG FIX: Use DeriveLift instead of GHC Generics to derive Lift
  • This fixes a build failure on GHC 8.10
• Drop support for GHC 7.10.3
  • GHC 8.0.2 is now the earliest supported version
• Add support for dotted field syntax
  • { x.y.z = 1 } now legal syntax for nested fields
  • See the changelog for standard version 14.0.0 for more details
• Add support for duplicate record fields
  • This combines with the previous feature to let you write
    { x.y = 1, x.z = True }, which is equivalent to
    { x = { y = 1, z = True } }
  • See the changelog for standard version 14.0.0 for more details
• Add dhall lint support for deprecating Optional/{fold,build}
  • The Optional/{fold,build} built-ins are deprecated and can be implemented
    in terms of other language features
  • Optional/fold can be implemented in terms of merge (which now works on
    Optional values)
  • Optional/build could always be implemented using Some/None
  • dhall lint now transforms the deprecated built-ins to use their
    equivalent built-in-free versions
• Support Template Haskell for multiple datatypes
  • This extends the Template Haskell support added in the previous release to
    work for datatypes that refer to one another
• Add support for custom substitutions
  • You can now add custom substitutions, which are like let bindings that
    propagate to transitive imports
• Small formatting fixes

dhall-1.29.0

• Supports version 13.0.0 of the standard
• BREAKING CHANGE: Generate Haskell datatype declarations from Dhall types
  • You can now use the makeHaskellTypeFromUnion Template Haskell utility
    to generate a Haskell datatype declaration from a Dhall union type
  • This helps ensure that your Haskell types and Dhall types stay in sync,
    when you want the Dhall type to be the source of truth
  • This is a breaking change because the default InterpretOptions changed
    the default handling of singleton constructors from Wrapped to Smart
  • You can preserve the old behavior using:
    autoWith defaultInterpretOptions{ singletonConstructors = Wrapped }
• BUG FIX: Fix dhall freeze --cache and dhall lint to preserve let-related comments
  • Now they match the behavior of dhall format with regard to preserving
    these comments
• BUG FIX: Fix escaping of significant leading whitespace when formatting code
  • The formatter would sometimes unnecessarily escape significant leading
    whitespace for the final line of multiline string literals, which this
    change fixes
• BUG FIX: Fix dhall encode --json for Double values
• NEW FEATURE: dhall to-directory-tree command
  • You can now generate a directory tree from a Dhall expression
  • Specifically:
    • records are converted to directories
    • Text fields are converted to files named after the field
    • Optional values are omitted if None
    • Everything else is rejected
• NEW FEATURE: Hexadecimal literals
  • See the changelog for standard version 13.0.0 for more details
• NEW FEATURE: merge works on Optional values
  • See the changelog for standard version 13.0.0 for more details
• Improve formatter
  • dhall format will now render expressions nested inside record fields or
    alternatives more compactly, including:
    • Records
    • Record completion expressions
    • Expressions wrapped in Some
    • Lists
• Exclude the using ... suffix from imports listed by dhall resolve
  • Specifically when using the --{immediate,transitive}-dependencies flags

dhall-1.28.0

• Supports version 12.0.0 of the standard
• BREAKING CHANGE: Add Integer/{clamp,negate} built-ins
  • This is a technically breaking change API since this adds a new
    constructor to the Expr type
  • This is also a technically breaking change to the language. See the changelog for standard version 12.0.0 for more details
• BREAKING CHANGE: Remove support for fusion
  • This is also a technically breaking change to the language. See the changelog for standard version 12.0.0 for more details
• BREAKING CHANGE: Parse whitespace more precisely
  • The Haskell implementation now matches the official grammar much more
    closely, but as a result will now reject some programs that it used to
    accept
  • For example, 1:Natural used to be valid and now is no longer valid as
    the standard requires mandatory whitespace after the :
  • Consult the standard grammar if you run into a new parsing error as a result of this change
  • This is also a parsing performance regression (specifically for parsing
    comments), but should not be noticeable in practice. See #1512 for more details
• BREAKING CHANGE: Rename Type to Decoder and InputType to Encoder #1483 / #1489
• BUG FIX: Fix dhall format --check
  • Before this change dhall format --check would fail due to attempting to
    read all of standard input in twice
• BUG FIX: Fix dhall freeze to always re-freeze an import
  • Before this fix, dhall freeze would not attempt to refreeze an already
    frozen import
• Permit spaces around completion operator
  • See the changelog for standard version 12.0.0 for more details
• Make missing referentially transparent
  • missing can now be imported transitively via a remote import
  • Normally resolving missing would still still fail, except for
    missing as Location, which is now a valid transitive import
  • See the changelog for standard version 12.0.0 for more details
• Write cache files atomically
  • This is a resilience improvement so that the cache is not left in a
    corrupt state in the event of a power outage or exhausting disk/memory
• New Dhall.function utility
  • This is provides the same functionality as the Interpret instance for
    (->), except without the use of typeclasses
• New dhall haskell-syntax-tree command
  • This command displays the Haskell syntax tree of an expression
    (primarily for debugging purposes)
  • Note that this is highly-volatile and subject to change, so don't depend
    on this programmatically. We may break the output of this command without
    any notice.
• Add instance Show Ann
• Move normalization code from Dhall.Core to Dhall.Normalize
  • Note that this is not a breaking change. The relocated utilities are
    still re-exported from Dhall.Core
• Fix dhall resolve --transitive-dependencies to list dependencies in "post-order"
• Performance improvements
  • #1500
  • #1522
  • #1568
  • #1580
• Fixes and improvements to code formatting
  • #1460
  • #1466
  • #1508
  • #1527
  • #1422
  • #1552
  • #1543
  • #1554
  • #1569
• Fixes and improvements to code linting
  • #1518
  • #1531
• Fixes and improvements to error messages
  • #1443
  • #1448
  • #1482
  • #1519
  • #1556
  • #1528
• Fixes and improvements to the parser
  • #1473
  • #1549
  • #1563
  • #1584
• Fixes and improvements to diffs
  • #1585
• Fixes and improvements to the REPL
  • #1573
• Fixes and improvements to documentation
  • #1530

dhall-1.27.0

• Supports version 11.0.0 of the standard
• BREAKING CHANGE: Rename Inject/Interpret to ToDhall/FromDhall
  • This change ConstraintKinds to minimize disruption by keeping around
    Inject/Interpret as synonyms for ToDhall/FromDhall
  • In other words, constraints and derived instances using Inject or
    Interpret will still work
  • However, manual instances using Inject or Interpret won't work
    unless you rename them to ToDhall/FromDhall or enable the
    TypeSynonymInstances extension
• BREAKING CHANGE: Fix Eq instance for Exprs with special Doubles
  • This fixes the Eq instance for Exprs to match the standard regarding
    Double comparisons
  • Specifically: NaN == NaN and -0.0 /= 0.0
  • This is a breaking change because the DoubleLit constructor of Expr
    now stores a DhallDouble instead of a Double
• BREAKING CHANGE: Add --file option for dhall hash
  • This is a breaking change because it also removes the Dhall.Hash module,
    which wasn't really carrying its own weight
• Add support for leading separators
  • See the changelog for standard version 11.0.0 for more details
• Add record completion operator
  • See the changelog for standard version 11.0.0 for more details
• Add dhall tags subcommand
  • This generates an ETags file from an input file or directory
• Add dhall lint support for fixing malformed assertions
  • dhall lint now fixes let example = foo === bar to be
    let example = assert : foo === bar
• Normalize inferred types #1337
• New FromDhall/ToDhall (previously Interpret/Inject) instances for:
  • Void
  • Map #1391 / #1412
  • HashMap
  • Set and HashSet
  • ()
• Add --output option to dhall
• Move syntax things from Dhall.Core to a new Dhall.Syntax module
  • This is not a breaking change. Dhall.Core still re-exports the same
    API as before
• Performance improvements
  • #1362
  • #1366
  • #1368
  • #1397
  • #1401
• Fixes and improvements to code formatting
  • #1360
  • #1372
  • #1380
  • #1415

dhall-1.26.1

• TECHNICALLY BREAKING CHANGES: Simplify ⫽ within projection / Simplify nested record projections
  • These are technically breaking changes because you will need to update
    integrity checks that protect code simplified in this way
  • We're not bumping the major version since the likelihood that you're
    affected is quite low
• BUG FIX: Fix performance regression
  • This change fixes the performance regression introduced in the previous
    release (version 1.26.0)
• BUG FIX: Prevent REPL from inserting inferred Sorts into context
  • This protects the REPL from getting hosed if you define an expression
    using :let that has an inferred type of Sort
• NEW FEATURE: Improved Inject/Interpret support for 1-field constructors - (#1315 / #1321)
  • This adds a new singletonConstructors field to InterpretOptions that
    lets you control what Dhall type 1-field Haskell constructors correspond
    to
  • The default (Wrapped) is backwards compatible with the old behavior
  • The Smart option is probably what you want: it will strip the
    Haskell constructor from the Dhall type if the constructor has one
    anonymous field
  • The Bare option always strips 1-field Haskell constructors from the
    Dhall type
• NEW FEATURE: --censor flag that disables source code display (#1312 / #1329)
  • Use this flag when you don't want sensitive Text literals showing up in
    parsing or type-checking error messages
• Format record fields more compactly if they fit on 1 line
  • The formatter will now format record fields on a field-by-field basis to
    avoid unnecessary vertical sprawl of formatted records
  • Specifically, record fields that fit on one line will now be formatted
    on one line
• Add --quiet option to dhall type
  • This lets you use dhall type in "check only" mode (e.g. for CI for
    for development feedback)
• Improved GHCJS support - (#1311 / #1330)
• Fix all executables to accept --version
  • Note that the dhall version subcommand is still supported, too
• New Dhall.Version module
• Don't normalize inferred types
  • This fixes dhall type to more accurately follow the standard
• Initial changes for GHC 8.8 support
• Fix Haddock formatting for dhallFromJSON

dhall-1.26.0

• Supports version 10.0.0 of the standard
• BREAKING CHANGE TO THE LANGUAGE: Remove old union literal syntax
  • Union literals of the form < x = e | ... > are no longer valid
  • For more details, see: Migration: Deprecation of old union literal syntax
  • Also see the changelog for standard version 10.0.0 for more details
• BREAKING CHANGE TO THE API: Change X to be a type synonym for Data.Void
  • This is a breaking change if you were previously pattern matching on the
    X constructor. You can replace that with the use of Data.Void.absurd
• BREAKING CHANGE TO THE API: Treat multi-lets as syntactic sugar
  • This is a breaking change because the Let constructor now only stores
    one Binding instead of a NonEmpty list of Bindings
• PERFORMANCE REGRESSION & TECHNICALLY BREAKING CHANGE TO THE LANGUAGE: Dependent types
  • You can now write functions from terms to types
  • There is also now language support for tests of the form
    assert : x === y
  • This deteriorates the performance of large multi-let expressions
    (See: #1306)
  • Splitting large multi-let expressions into smaller files may mitigate
    the problem as a work-around for now
  • Follow #1129
    for work to fix this performance regression
  • This is also a technically breaking change because assert is now a
    reserved keyword
  • See the changelog for standard version 10.0.0 for more details
• TECHNICALLY BREAKING CHANGE TO THE LANGUAGE: Add Natural/subtract built-in
  • The language now supports machine subtraction, which can be used to
    support several other high-performance operations (like Natural
    comparisons)
  • This is a technically breaking change if you used Natural/subtract as an
    identifier in your code
  • See the changelog for standard version 10.0.0 for more details
• TECHNICALLY BREAKING CHANGE TO THE LANGUAGE: More simplifications for field selection
  • Now the interpreter will more intelligently simplify certain field
    projections
  • For example: λ(x : { a : Bool, b : Bool }) → (x ⫽ { c = 0 }).{ a, c }.c
    will now simplify to λ(x : { a : Bool, b : Bool }) → 0
  • This is a technically breaking change because you will need to update
    integrity checks that protect code simplified in this way
  • See the changelog for standard version 10.0.0 for more details
• TECHNICALLY BREAKING CHANGE TO THE LANGUAGE: Simplify ⫽ when its arguments are equivalent
  • This is a technically breaking change for the same reason: this will
    perturb semantic integrity checks for affected code
  • See the changelog for standard version 10.0.0 for more details
• NEW FEATURE: Restore support for records containing both types and terms
  • In other words { foo = 1, bar = Bool } is now valid again
  • This means that you now can export a single package containing both types
    and terms
  • See the changelog for standard version 10.0.0 for more details
• dhall format now preserves let comments
  • dhall format will now preserve comments in the following locations of
    a let binding:
  • let {- HERE -} x {- HERE -} : {- HERE -} Bool = {- HERE -} True in x
  • This support handles both single-line and multi-line comments and also
    takes care of correctly indenting/dedenting them
  • Note that comments before the let keyword are still not preserved
    (unless it is the beginning of the file)
• Add API support for marshalling recursive types
  • You can now marshal recursive types from Dhall into Haskell using the
    newly-added utilities
  • See also: #1298
• New :help command for dhall repl
• New --no-cache flag
  • You can now disable use of the cache with this flag
  • This comes in handy if you want to disable α-normalization for imports
    protected by a semantic integrity check
• Bug fixes
  • Fix isNormalized for field selections
  • Simplify Natural/subtract when its arguments are equivalent
  • Fix NaN to be judgmentally equivalent to itself
  • Fix Inject instance for lists
  • Fix typechecking of toMap
• Performance optimizations
  • Optimize a few Set instances
  • Remove some redundant sorting during normalization
• Improvements to error messages
  • Improve error reporting for failed remote imports
  • Improve HTTP errors
• Improvements to formatting
  • Indent function arguments when formatting
  • Prefer unquoted URLs
  • Strip leading whitespace
• Improvements to diffs
  • Fix diffs for lists
  • Improve diff for non-empty lists
  • Small fixes to dhall diff
• Improvements to documentation
  • Fix documentation for UnionInputType
  • Document support for caching protected imports
• Improvements to command-line interface
  • Improve description of dhall lint
  • Change dhall type to resolve imports

dhall-1.25.0

• Supports version 9.0.0 of the standard
  • See: https://github.com/dhall-lang/dhall-lang/releases/tag/v9.0.0
• BREAKING CHANGE: Remove support for old-style List-like Optional literals
  • List-like Optional Literals (i.e. [ 1 ] : Optional Natural) are no
    longer valid
  • See: #1002
• BREAKING CHANGE: Add support for semi-semantic caching
  • This change significantly improves the performance of imports
  • This change also automatically caches imports without an integrity check
  • This changes several types in Dhall.Import to support this new
    feature
  • See: #1113
• BREAKING CHANGE: Implement new Unicode braced escape sequence
  • Escape sequences encoding surrogate pairs are no longer valid
  • Instead, characters previously encoded as surrogate pairs can instead be
    encoded as a braced sequence
  • For example: "\uD834\uDD1E" must now be written as "\u{1D11E}"
  • See: #987
  • See: #1104
• BREAKING CHANGE: Make the type of extract richer:
  • Dhall.extract can now return a detailed error instead of just a Maybe
  • This is a breaking chnage because the type of extract changed
  • See: #1011
• BREAKING CHANGE: Add support for importing expressions as Location
  • This is a breaking change because a new Location constructor was added
    to ImportMode
  • See: #1019
• BREAKING CHANGE: Switch Var to use an Int
  • This is a performance improvement, but also a breaking change since the
    Integer in the Var constructor was changed to an Int
  • See: #1044
• BREAKING CHANGE: Add new toMap keyword
  • This is a breaking change to the API because a new ToMap constructor
    was added to the Expr type
  • This is also a technically breaking change to the language because toMap
    is now a reserved keyword, although most code should be unaffected in
    practice
  • See: #1041
• BREAKING CHANGE: Sort the fields of a record projection during normalization
  • This is a technically breaking change to the language because any
    expressions with an uninterpreted record projection will have a different
    semantic integrity check. However, most could should be unaffected in
    practice
  • See: #1111
• BUG FIX: Fix substitution into record projection by type
  • An expression like this one was being incorrectly rejected:
    let e = { a = 10, b = "Text" } let s = { a : Natural } in e.(s), which
    this change fixes
  • See: #1012
• BUG FIX: Reject record projection when there is a field type mismatch
  • Record projection by type was previously not checking the expected
    field types, which this change fixes
  • See: #1027
• BUG FIX: Fix linting of unused let bindings
  • Certain let bindings were not correctly detected as unused, which this
    change fixes
  • See: #1001
• BUG FIX: Fix --file option
  • The --file option from the previous release did not work, due to not
    computing relative paths correctly, which this change fixes
  • See: #1004
• BUG FIX: Minor fix to dhall diff
  • dhall diff was incorrectly displaying spurious differences for
    identical lists that were function arguments, which this change fixes
  • See: #1006
• BUG FIX: Allow Sort as type annotation
  • This should have been implemented in the previous release as part of
    supporting version 8.0.0 of the standard, but was missed
  • See: #1024
• BUG FIX: Dhall.Map: Reflect original key ordering in Ord instance
  • Dhall.Map now considers key order when comparing Maps, which it should
    have done before, but didn't
  • See: #1050
• BUG FIX: Consistently format multi-line strings
  • The formatter now formats naked multi-line strings the same as nested
    multi-line strings
  • Specifically, naked multi-line strings can now be formatted on a single
    (just like nested multi-line strings)
  • See: #1056
• BUG FIX: Make isNormalized consistent with normalize
  • See: #1115
• BUG FIX: Make normalizeWithM consistent with normalize
  • See: #1126
• BUG FIX: Fix import alternatives to recover from type errors
  • See: #1152
• Feature: Semi-semantic caching
  • The Haskell implementation now implicitly caches all local imports, not
    just imports frozen by integrity checks, so that you don't have to freeze
    them when doing local development
  • These cached imports are still correctly invalidated if they or any of
    their dependencies change
  • This new implicit cache is stored underneath ~/.cache/dhall-haskell by
    default
  • See: #1154
• Feature: New dhall text subcommand
  • This new subcommand supersedes the old dhall-to-text executable
• Feature: Add instance Lift (Expr s a)
  • See: #1119
• Fixes and improvements to error messages:
  • See: #1030
  • See: #1137
• Fixes and improvements to tests:
  • See: #1155
  • See: #1159
• Performance improvements
  • See: #1036
  • See: #1051
  • See: #1048
  • See: #1057
  • See: #1065
  • See: #1066
  • See: #1085

dhall-1.24.0

• Supports version 8.0.0 of the standard
  • See: https://github.com/dhall-lang/dhall-lang/releases/tag/v8.0.0
• BREAKING CHANGE: Allow tabs and blank lines in multi-line strings
  • Blank lines are now ignored for the purpose of dedenting multiline strings
  • Lines with leading tabs (or mixed tabs and spaces) are now dedented, too,
    so long as they all share the same prefix
  • This is technically a breaking change, but unlikely to affect programs
    in practice, especially if they were formatted with dhall format. This
    change mainly affects programs that were not indented correctly.
  • See the changelog for standard version 8.0.0 for more details
• BREAKING CHANGE: Simplify bare interpolations
  • Expressions like λ(x : Text) → "${x}" now simplify to λ(x : Text) → x
  • This is a technically breaking change because it changes how these sorts
    of expressions are serialized. This does not affect semantic integrity
    checks and the new simplified expressions are extensionally equivalent to
    their older counterpart expressions.
  • See the changelog for standard version 8.0.0 for more details
• BREAKING CHANGE: Encode integrity check as multihash
  • Semantic integrity checks are now encoded using the multihash spec
  • This is a technically breaking change that does not perturb the hash for
    user-facing semantic integrity checks. This only affects how expressions
    with unresolved imports are serialized, but semantic integrity checks are
    only computed for fully-resolved imports.
  • See the changelog for standard version 8.0.0 for more details
• BUG FIX: Fix type-checker to reject invalid record type annotations
  • e.g. { x = 1 } : { x : Text } was not properly rejected by the type
    checker
  • See: #965
• BUG FIX: Custom header forwarding fixed
  • Forwarding custom headers could previously fail in various ways, such as:
    • Cyclic imports leading to endless network requests
    • Resolving a non-existent import for the custom headers
    • Resolving an existing but incorrect import for the custom headers
  • This change fixes that by forwarding custom headers by value instead of
    by reference
  • See: #967
• BUG FIX: Fix GHCJS support
  • Natural/fold was broken in version 1.22, which this change fixes
  • Specifically, it would hang for Natural numbers greater than 1
  • See: #985
• BUG FIX: dhall diff no longer double-prints key-value separators
  • See: #952
• Feature: Record projection by expression
  • You can now project out a subset of record fields by the expected type
  • let t = { x : Natural } let p = { x = 1, y = 2 } in p.(t) = { x = 1 }
  • See the changelog for standard version 8.0.0 for more details
• Feature: Inline headers
  • You no longer need to specify custom headers in a separate import. You
    can now specify them inline within the same file.
  • e.g.: https://example.com/x using [ { header = "Foo", value = "Bar" } ]
  • See the changelog for standard version 8.0.0 for more details
• Feature: Allow Sort as a type annotation
  • An expression such as Kind → Kind : Sort will now type-check
  • Sort is still disallowed outside of a type annotation
  • See the changelog for standard version 8.0.0 for more details
• Feature: Allow self-describe-cbor when decoding
  • Dhall expressions serialized as CBOR can be tagged to describe themselves
    as CBOR without affecting decoding
  • See the changelog for standard version 8.0.0 for more details
• Feature: New --file option for dhall commands
  • In other words, instead of dhall <<< './some/file you can now use
    dhall --file some/file
  • See: #949
• Feature: New --cache flag for dhall freeze command
  • This automates the idiom used by the Prelude to optimistically cache
    imports but gracefully degrade if the semantic integrity check fails
  • See: #980
• Feature: Add :clear command to dhall repl
  • This deletes previous bindings from the history so that they can be
    garbage collected
  • See: #966
• Feature: New chunkExprs Traversal added to Dhall.Core
  • See: #954
• Feature: New Dhall.Optics module
  • This re-exports some convenient @lens@ utilities used internally for
    packages trying to avoid a @lens@ dependency
  • See: #986
• More GHC 8.8 support
  • See: #961