packages feed

dhall 1.2.0 → 1.42.3

raw patch · 3593 files changed

This diff is very large; some files are shown as “too large to diff”. Download the raw patch for the complete diff.

Files

CHANGELOG.md view
@@ -1,3 +1,2008 @@+1.42.3++* [Fix the typechecking rule for `Optional` + `with`](https://github.com/dhall-lang/dhall-haskell/pull/2650)+* [Add `*WithIndex` instances for `Map`](https://github.com/dhall-lang/dhall-haskell/pull/2633)+* [`dhall package`: Add support for automatic sub-packags](https://github.com/dhall-lang/dhall-haskell/pull/2639)+* [`dhall to-directory-tree`: Add `binary-file` support](https://github.com/dhall-lang/dhall-haskell/pull/2641)+* [Support GHC 9.12.1](https://github.com/dhall-lang/dhall-haskell/pull/2649)+* [`dhall to-directory-tree`: create parents of files when using fixpoint representation](https://github.com/dhall-lang/dhall-haskell/pull/2653)++1.42.2++* [Supports standard version 23.1.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v23.1.0)+  * [Allow `Natural` and `Integer` literals in binary notation](https://github.com/dhall-lang/dhall-haskell/pull/2540)+* Fix macOS build [[#2561](https://github.com/dhall-lang/dhall-haskell/pull/2561)] / [[#2586](https://github.com/dhall-lang/dhall-haskell/pull/2586)]+* [`dhall to-directory-tree`: Fix support for empty `Map`s](https://github.com/dhall-lang/dhall-haskell/pull/2609)+* [`Dhall.TH`: Improve recompilation checking](https://github.com/dhall-lang/dhall-haskell/pull/2620)+  * `Dhall.TH` utilities now use `addDependentFile` internally so that GHC will recompile if any Dhall dependencies change+* Performance improvements+  * Optimize `Natural/fold`: [[#2585](https://github.com/dhall-lang/dhall-haskell/pull/2585)] / [[#2596](https://github.com/dhall-lang/dhall-haskell/pull/2596)]+  * [Improve `Dhall.Map.traverseWithKey` performance](https://github.com/dhall-lang/dhall-haskell/pull/2589)+    * The fold will now short-circuit if it reaches a fixed point+  * [#2611](https://github.com/dhall-lang/dhall-haskell/pull/2611)+* Fixes and improvements to test suite+  * [#2593](https://github.com/dhall-lang/dhall-haskell/pull/2593)+* Fixes and improvements to haddocks+  * [#2546](https://github.com/dhall-lang/dhall-haskell/pull/2546)+* Fixes and improvements to code formatting+  * [#2608](https://github.com/dhall-lang/dhall-haskell/pull/2608)++1.42.1++* Add several new entrypoints to `Dhall` module [[#2534](https://github.com/dhall-lang/dhall-haskell/pull/2534)] / [[#2544](https://github.com/dhall-lang/dhall-haskell/pull/2544)]+* Build against latest versions of:+  * [`ansi-terminal`](https://github.com/dhall-lang/dhall-haskell/pull/2521)+  * [`optparse-applicative`](https://github.com/dhall-lang/dhall-haskell/pull/2543)+  * [`optparse-generic`](https://github.com/dhall-lang/dhall-haskell/pull/2519)+  * [`lens`](https://github.com/dhall-lang/dhall-haskell/pull/2539)+  * `template-haskell` [[#2532](https://github.com/dhall-lang/dhall-haskell/pull/2532)] / [[#2542](https://github.com/dhall-lang/dhall-haskell/pull/2542)]+  * [`unix-compat`](https://github.com/dhall-lang/dhall-haskell/pull/2532)+1.42.0++* [Supports standard version 23.0.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v23.0.0)+  * [BREAKING CHANGE TO THE API AND LANGUAGE: Language support for `Bytes` literals](https://github.com/dhall-lang/dhall-haskell/pull/2499)+    * This is a breaking change to the API due to adding new `Bytes` and `BytesLiteral` constructors to the `Expr` type+    * This is a breaking change to the language now that `Bytes` is a reserved identifier+  * [BREAKING CHANGE TO THE API AND LANGUAGE: New `{Date,Time,TimeZone}/show` builtins](https://github.com/dhall-lang/dhall-haskell/pull/2493)+    * This is a breaking change to the API due to adding new `{Date,Time,TimeZone}Show` constructors to the `Expr` type+    * This is a breaking change to the language now that `{Date,Time,TimeZone}/show` are not reserved identifiers+* [BREAKING CHANGE: `dhall lint` no longer sorts `let` bindings](https://github.com/dhall-lang/dhall-haskell/pull/2503)+  * This had to be removed because the old behavior was not always correct+  * The old behavior would sometimes change the behavior of a Dhall program or break the program+  * Out of an abundance of caution we're disabling the feature until it can be properly fixed (which is't trivial)+* [BUG FIX: Fix pretty-printing of `Time` literals](https://github.com/dhall-lang/dhall-haskell/pull/2466)+  * The pretty-printer was stripping leading zeros from the fractional component+    of seconds+* [BUG FIX: Fix custom normalizers to work for things other than functions](https://github.com/dhall-lang/dhall-haskell/pull/2464)+  * Before this change you could extend the language with custom functions, but+    not custom values (e.g. `foo = 1`)+* [BUG FIX: Don't URL encode path components](https://github.com/dhall-lang/dhall-haskell/pull/2505)+  * The pretty-printer was URL-encoding path components, which is not correct (according to the standard)+  * URL path components are supposed to be already URL-encoded by the user and left undisturbed by the interpreter (which is now what it correctly does)+* New `dhall package` command: [#2478](https://github.com/dhall-lang/dhall-haskell/pull/2487), [#2508](https://github.com/dhall-lang/dhall-haskell/pull/2508)+  * This command makes it easier to turn a directory full of Dhall expressions+    into a dhall package (e.g. `package.dhall`)+* [Improved `dhall to-directory-tree` subcommand](https://github.com/dhall-lang/dhall-haskell/pull/2437)+  * The `dhall to-directory-tree` subcommand now optionally supports specifying+    metadata for generated paths+  * For a worked example, see: https://github.com/dhall-lang/dhall-haskell/blob/main/dhall/examples/to-directory-tree.dhall+* `dhall freeze --cache --all` is now idempotent: [#2486](https://github.com/dhall-lang/dhall-haskell/pull/2486), [#2500](https://github.com/dhall-lang/dhall-haskell/pull/2500)+  * Before this change a second run would fail due to attempting to resolve+    the `missing` import it would generate+* [New Template Haskell options for adding strictness annotations to generated Haskell types](https://github.com/dhall-lang/dhall-haskell/pull/2504)+* [Template Haskell can now generate higher-kinded Haskell types from higher-kinded Dhall types](https://github.com/dhall-lang/dhall-haskell/pull/2506)+* [New `Dhall.Freeze` utilities for working with custom evaluators](https://github.com/dhall-lang/dhall-haskell/pull/2478)+* [Add `Data` instances for `Import` and various other types](https://github.com/dhall-lang/dhall-haskell/pull/2462)+* [Add `Eq` instances for `InvalidDecoder` and `ExtractError`](https://github.com/dhall-lang/dhall-haskell/pull/2482)++1.41.2++* [BUG FIX: Fix `:hash` REPL command to α-normalize input](https://github.com/dhall-lang/dhall-haskell/pull/2420)+* [Add `{From,To}Dhall` instances for `DayOfWeek`](https://github.com/dhall-lang/dhall-haskell/pull/2413)+* [Add `{From,To}Dhall` instances for `ShortText`](https://github.com/dhall-lang/dhall-haskell/pull/2413)+* Performance improvements+  * [#2423](https://github.com/dhall-lang/dhall-haskell/pull/2423)+* Fixes and improvements to haddocks+  * [#2396](https://github.com/dhall-lang/dhall-haskell/pull/2396)+* Fixes and improvements to test suite+  * [#2342](https://github.com/dhall-lang/dhall-haskell/pull/2382)+  * [#2394](https://github.com/dhall-lang/dhall-haskell/pull/2394)+* Build against newer dependencies+  * [`pretty-simple-4.1`](https://github.com/dhall-lang/dhall-haskell/pull/2408)+  * [`aeson-2.1`](https://github.com/dhall-lang/dhall-haskell/pull/2424)+  * [`vector-0.13`](https://github.com/dhall-lang/dhall-haskell/pull/2427)+  * [`turtle-1.6`](https://github.com/dhall-lang/dhall-haskell/pull/2431)++1.41.1++* [BUG FIX: Don't escape `?` path component when pretty-printing `with` expressions](https://github.com/dhall-lang/dhall-haskell/pull/2392)++1.41.0++* [Support standard version 22.0.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v22.0.0)+  * [Allow `with` expressions to update `Optional` values using `?`](https://github.com/dhall-lang/dhall-haskell/pull/2386)+  * [Add `showConstructor` keyword](https://github.com/dhall-lang/dhall-haskell/pull/2384)+* [BUG FIX: Fix pretty-printing of time zones](https://github.com/dhall-lang/dhall-haskell/pull/2379)+  * Timezones with a negative offset were previously being rendered with two+    leading minus signs instead of one+* [BUG FIX: `dhall freeze --cache` to work with standard version 21.0.0](https://github.com/dhall-lang/dhall-haskell/pull/2350)+  * `dhall freeze` will now use `missing sha256:…` for the first import so that+    the latter import will be tried if the import is not in cache+  * The old behavior is incompatible with standard version 21.0.0 because the+    new behavior of the `?` operator doesn't fall back on hash mismatches+* [BUG FIX: Allow `with` expression to update a field named `Some`](https://github.com/dhall-lang/dhall-haskell/pull/2354)+  * This fixes a discrepancy between the Haskell implementation and the standard+    where the Haskell implementation would not permit+    `{ Some = 0 } with Some = 1 `+* [Fix `dhall {format,lint,freeze}` to preserve leading shebangs](https://github.com/dhall-lang/dhall-haskell/pull/2364)+* [Add `FromDhall` instances for `Int{8,16,32,64}`](https://github.com/dhall-lang/dhall-haskell/pull/2349)++1.40.2++* [Supports standard version 21.1.0](https://github.com/dhall-lang/dhall-haskell/pull/2236)+    * [The interpreter now supports customizing headers using a `headers.dhall`+      configuration file](https://github.com/dhall-lang/dhall-haskell/pull/2236)+    * [Generalize grammar for certain annotations](https://github.com/dhall-lang/dhall-haskell/pull/2320)+    * [Add support for a trailing line comment without a newline](https://github.com/dhall-lang/dhall-haskell/pull/2309)+* [BUG FIX: `dhall repl` no longer ignores type annotations on `:let` commands](https://github.com/dhall-lang/dhall-haskell/pull/2297)+    * Before this fix, `:let x : T = 3` would ignore the `: T` type annotation+* [BUG FIX: Don't accept a bar after an empty union](https://github.com/dhall-lang/dhall-haskell/pull/2338)+    * Before this fix, the interpreter would accept something like `<>|`, which+      is not valid according to the standard grammar+* New `FromDhall`/`ToDhall` instances for `Day`/`TimeOfDay`/`TimeZone` [#2294](https://github.com/dhall-lang/dhall-haskell/pull/2294) [#2300](https://github.com/dhall-lang/dhall-haskell/pull/2300)+    * These types correspond to the recent temporal literals added to the+      language+* [New `subExpressionsWith` `Traversal`](https://github.com/dhall-lang/dhall-haskell/pull/2302)+* [Add Template Haskell support for modifying field names in generated Haskell+  types](https://github.com/dhall-lang/dhall-haskell/pull/2285)+    * This adds a new `makeHaskellTypesWith` utility with takes a+      `GenerateOptions` function argument for customizing the code-generation+      logic+    * This comes in handy when Dhall fields have names are reserved keywords in+      Haskell code.  You can now transform the Haskell field names to avoid+      collisions+* [Support GHC 9.2](https://github.com/dhall-lang/dhall-haskell/pull/2328)+* Fixes and improvements to documentation+    * [#2290](https://github.com/dhall-lang/dhall-haskell/pull/2290)+* Fixes and improvements to error messages+    * [#2303](https://github.com/dhall-lang/dhall-haskell/pull/2303)++1.40.1++* [BUG FIX: Fix equivalence check for `Date` / `Time` / `TimeZone`](https://github.com/dhall-lang/dhall-haskell/pull/2291)+    * This fixes a serious bug in the recently introduced support for temporal+      literals where they would fail to type-check when given a correct type+      annotation or when they were checked against an existing type+    * For example, `00:00:00 : Time` was failing to type-check++1.40.0++* [Almost supports version 20.2.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v20.2.0)+    * The main thing that is missing is support for the `headers.dhall` file+    * [BREAKING CHANGE TO THE LANGUAGE: Add support for `Date` / `Time` / `TimeZone` ](https://github.com/dhall-lang/dhall-haskell/pull/2247)+        * This is a breaking change because `Date`, `Time`, and `TimeZone` are+          now reserved identifiers+    * [Improved fallback behavior for `?`](https://github.com/dhall-lang/dhall-haskell/pull/2203)+* [BREAKING CHANGE TO THE LANGUAGE: Require whitespace before `with`](https://github.com/dhall-lang/dhall-haskell/pull/2213)+    * The parser now requires whitespace before the `with` keyword, which brings+      the Haskell implementation into closer compliance with the standard+    * In practice this is a technically breaking change which will not affect+      most programs+* [New `FromDhall` instances for `Predicate`, `Equivalence`, and `Op`](https://github.com/dhall-lang/dhall-haskell/pull/2278)+* [`dhall lint` will now sort `let` bindings with imports](https://github.com/dhall-lang/dhall-haskell/pull/2205)+    * `dhall lint` now reorders `let` bindings to move imports to the top so+      long as doing so does not change the behavior of the program+* Fixes and improvements to code formatting+    * [#2280](https://github.com/dhall-lang/dhall-haskell/pull/2280)+* Fixes and improvements to error messages+    * [#2244](https://github.com/dhall-lang/dhall-haskell/pull/2244)+    * [#2238](https://github.com/dhall-lang/dhall-haskell/pull/2238)++1.39.0++* [Supports version 20.2.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v20.2.0)+    * [Add support for Unix shebangs](https://github.com/dhall-lang/dhall-haskell/pull/2175)+* [BREAKING CHANGE TO THE API: `dhall {format,freeze,lint}` now accept multiple+  files](https://github.com/dhall-lang/dhall-haskell/pull/2169)+    * The `--inplace` flag is no longer necessary and you can now specify+      multiple files to update in place on the command line, like+      `dhall format foo.dhall bar.dhall`+    * The `--inplace` flag is still accepted, but does nothing, and will emit a+      warning+    * This is a breaking change to the API for formatting/freezing/linting files+      because now you can specify multiple inputs instead of one input+* [BREAKING CHANGE: Pre-6.0.0 hashes are no longer supported](https://github.com/dhall-lang/dhall-haskell/pull/2190)+    * The interpreter no longer provides backwards compatibility for integrity+      checks computed before standard version 6.0.0+    * This is a breaking change to the API of the `Dhall.Binary` module, where+      certain utilities are no longer parameterized on a `StandardVersion`+    * This is also a breaking change to any Dhall code that depended on these+      really old integrity checks+* [BUG FIX: Formatting `≡` now correctly preserves the original character set](https://github.com/dhall-lang/dhall-haskell/pull/2176)+* [BUG FIX: Don't panic on `Text/replace ""`](https://github.com/dhall-lang/dhall-haskell/pull/2184)+* [Quasiquotation support for Dhall](https://github.com/dhall-lang/dhall-haskell/pull/2198)+    * You can now convert a Dhall expression to the corresponding syntax tree+      using a quasiquoter like this: `[dhall| \x -> x + 2 ]`+* [New `Dhall.Marshal.{Encode,Decode}` modules](https://github.com/dhall-lang/dhall-haskell/pull/2193)+    * These modules split up the `Dhall` module into two smaller modules for+      encoding and decoding logic, respectively+    * The `Dhall` module still re-exports the same functionality as before, so+      this is not a breaking change+* [Support GHC 9.0.1](https://github.com/dhall-lang/dhall-haskell/pull/2154)+* Fixes and improvements to code formatting+    * [Improve pretty-printing of `sha256`](https://github.com/dhall-lang/dhall-haskell/pull/2189)++1.38.1++* [Add `INLINABLE` annotations in more places](https://github.com/dhall-lang/dhall-haskell/pull/2164)+    * This may improve performance by enabling more specializations+* [Fix `hashable`-related test failures](https://github.com/dhall-lang/dhall-haskell/pull/2152)+* [Fix support for GHC 8.4.4](https://github.com/dhall-lang/dhall-haskell/pull/2143)+    * … by using `GeneralizedNewtypeDeriving` (with a `z`)+* [Allow doctest-0.18](https://github.com/dhall-lang/dhall-haskell/pull/2148)+* [Allow bytestring-0.11](https://github.com/dhall-lang/dhall-haskell/pull/2144)++1.38.0++* [BREAKING CHANGE: Detect preferred character set from input](https://github.com/dhall-lang/dhall-haskell/pull/2108)+    * `dhall format` will now preserve the character set of the formatted file+      by default.  In other words, if the file uses ASCII punctuation then+      `dhall format` will format the file using ASCII punctuation.+    * If the file contains both ASCII and Unicode punctuation it will prefer+      Unicode by default+    * This is a breaking change because the `Lam` / `Pi` / `Combine` /+      `CombineTypes`, and `Prefer` constructors now take an additional argument+      to record which character set was used+* [BUG FIX: Fix CORS compliance check](https://github.com/dhall-lang/dhall-haskell/pull/2121)+    * Previous versions were not correctly enforcing CORS compliance+    * This implies that some imports that would have worked previously by+      accident will now fail; specifically: an import from one domain+      transitively importing something from another domain that has not opted+      into CORS+* [Add `ToDhall (Fix f)` instance](https://github.com/dhall-lang/dhall-haskell/pull/2122)+* Fixes and improvements to error messages+    * [#2130](https://github.com/dhall-lang/dhall-haskell/pull/2130)++1.37.1++* [Fix performance regression for `with` expressions](https://github.com/dhall-lang/dhall-haskell/pull/2112)++1.37.0++* [Supports version 20.0.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v20.0.0)+    * [Implement revised `Text/replace` β-normalization](https://github.com/dhall-lang/dhall-haskell/pull/2072)+    * [Allow `Text/replace ""` to support an abstract haystack](https://github.com/dhall-lang/dhall-haskell/pull/2084)+    * [Support `if` expressions returning a type or kind](https://github.com/dhall-lang/dhall-haskell/pull/2080)+* BREAKING CHANGE TO THE API: [Improve error message for duplicate projection label](https://github.com/dhall-lang/dhall-haskell/pull/2097)+    * This also makes the implementation more standards-compliant, by treating+      a duplicate label as a type error instead of a parse error+    * This is a breaking change since the `Project` constructor now stores a+      `[Text]` instead of `Set Text`+* [Add `--cache` flag to `dhall hash`](https://github.com/dhall-lang/dhall-haskell/pull/2093)+    * This flag adds the hashed expression to the cache when enabled+* [Deprecate `Inject` / `Interpret`](https://github.com/dhall-lang/dhall-haskell/pull/2099)+    * You should instead use `ToDhall` / `FromDhall`, respectively+* Fixes and improvements to the haddocks:+    * [#2098](https://github.com/dhall-lang/dhall-haskell/pull/2098)+    * [#2100](https://github.com/dhall-lang/dhall-haskell/pull/2100)+* Fixes and improvements to error messages:+    * [#2082](https://github.com/dhall-lang/dhall-haskell/pull/2082)+    * [#2095](https://github.com/dhall-lang/dhall-haskell/pull/2095)+* Fixes and improvements to the parser:+    * [#2083](https://github.com/dhall-lang/dhall-haskell/pull/2089)+* Fixes and improvements to the pretty printer:+    * [#2083](https://github.com/dhall-lang/dhall-haskell/pull/2083)+    * [#2101](https://github.com/dhall-lang/dhall-haskell/pull/2101)++1.36.0++* [Supports version 19.0.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v19.0.0)+    * BREAKING CHANGE TO THE API: [Add `Text/replace` built-in](https://github.com/dhall-lang/dhall-haskell/pull/2063)+    * [Implement `with` without syntactic sugar](https://github.com/dhall-lang/dhall-haskell/pull/2055)+* [`dhall lint` will now add a `.dhall` extension to all Prelude imports](https://github.com/dhall-lang/dhall-haskell/pull/2061)+    * The old extension-free Prelude imports are deprecated+* [Fix command-line completions for files](https://github.com/dhall-lang/dhall-haskell/pull/2016)+* [Improve Template Haskell support for record constructors](https://github.com/dhall-lang/dhall-haskell/pull/2070)+* Fixes and improvements to code formatting+    * [#2037](https://github.com/dhall-lang/dhall-haskell/pull/2037)+    * [#2048](https://github.com/dhall-lang/dhall-haskell/pull/2048)+    * [#2069](https://github.com/dhall-lang/dhall-haskell/pull/2069)++1.35.0++* [Supports version 18.0.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v18.0.0)+    * [Implement more efficient `with` desugaring](https://github.com/dhall-lang/dhall-haskell/pull/1993)+        * Chained `with` expressions will now be much more efficient+* [BREAKING CHANGE TO THE API: Preserve whitespace for `Lam` constructor](https://github.com/dhall-lang/dhall-haskell/pull/1980)+    * This change extends the `Lam` constructor to preserve whitespace around+      the variable binding+    * The motivation for this change is to enable `dhall-docs` to support+      jumping to definitions+    * You can replace your existing `Lam` constructors with+      `Dhall.Core.makeFunctionBinding`+* [BREAKING CHANGE TO THE API: Preserve whitespace for `Field` constructors](https://github.com/dhall-lang/dhall-haskell/pull/1991)+    * This change extends the `Field` constructor to preserve whitespace around+      the selected field+    * The motivation for this change is to enable `dhall-docs` to support+      jumping to definitions+    * You can use `Dhall.Core.makeFieldSelection` and+      `Dhall.Core.fieldSelectionLabel` to convert between the detailed and the+      simple representation of the selected field.+* [Add `FromDhall` instances for `{Int,Word}{,8,16,32,64}`](https://github.com/dhall-lang/dhall-haskell/pull/2012)+* [Add `--output` option for `dhall text` subcommand](https://github.com/dhall-lang/dhall-haskell/pull/1974)+* [Add `Dhall.Crypto.toString`](https://github.com/dhall-lang/dhall-haskell/pull/1976)+* [Make the HTTP `Manager` configurable](https://github.com/dhall-lang/dhall-haskell/pull/2027)+    * Several import-related functions now provide an alternative variants that+      allows the user to supply a custom `Manager`+    * You can use this to tweak HTTP request timeouts or use a different TLS+      manager (e.g. one from `http-client-openssl`)+* Fixes and improvements to code formatting+    * [#2000](https://github.com/dhall-lang/dhall-haskell/pull/2000)+    * [#2021](https://github.com/dhall-lang/dhall-haskell/pull/2021)++      The formatter now preserves comments for record fields (both record types+      and record literals)+* Fixes and improvements to documentation+    * [#2011](https://github.com/dhall-lang/dhall-haskell/pull/2011)+    * [#2013](https://github.com/dhall-lang/dhall-haskell/pull/2013)+    * [#2014](https://github.com/dhall-lang/dhall-haskell/pull/2014)+* Fixes and improvements to test suite+    * [#2020](https://github.com/dhall-lang/dhall-haskell/pull/2020)++1.34.0++* [Supports version 17.1.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v17.1.0)+    * [Add support for trailing commas](https://github.com/dhall-lang/dhall-haskell/pull/1885)+* BREAKING CHANGE to the API: [Support prefix comments on record key-value pairs](https://github.com/dhall-lang/dhall-haskell/pull/1908)+    * The Dhall AST (i.e. `Expr`) now preserves some comments for record types+      and record literals+    * The impact of this change is that you will need to add+      `Dhall.Syntax.makeRecordField` or `Dhall.Syntax.recordFieldValue` in a few+      places wherever your Haskell assembles or disassembles record expressions+    * The motivation of this change is two-fold:+        * To eventually enable `dhall-docs` support for rendering record+          comments as documentation+        * To eventually enable support for preserving record-related comments+          when formatting Dhall code+* BUG FIX: [Fix `with` expressions to permit functions on their left-hand side](https://github.com/dhall-lang/dhall-haskell/pull/1897)+    * This was a case of the Haskell implementation not being compliant with the+      standard grammar+* [Drop support for GHC 8.2](https://github.com/dhall-lang/dhall-haskell/pull/1949)+* [Add a new `dhall rewrite-with-schemas` command](https://github.com/dhall-lang/dhall-haskell/pull/1902)+    * You can now simplify a Dhall expression using a schema record (e.g. a+      `./schemas.dhall` record that a package might provide)+    * This simplification replaces large anonymous records with an+      equivalent use of a record completion when possible+* [Add `--transitive` flag to `dhall {format,lint,freeze}](https://github.com/dhall-lang/dhall-haskell/pull/1880)+    * This flag lets you format/lint/freeze a file and all of its transitive+      dependencies that are reachable via relative file imports+* [Move `man/dhall.1` to `data-files`](https://github.com/dhall-lang/dhall-haskell/pull/1921)+    * This ensures that Cabal will install `dhall`'s `man` pages in the+      correct directory+* Performance improvements+    * [#1879](https://github.com/dhall-lang/dhall-haskell/pull/1879)+* Standards compliance+    * [#1953](https://github.com/dhall-lang/dhall-haskell/pull/1953)+    * [#1954](https://github.com/dhall-lang/dhall-haskell/pull/1954)+    * [#1956](https://github.com/dhall-lang/dhall-haskell/pull/1956)+    * [#1957](https://github.com/dhall-lang/dhall-haskell/pull/1957)+    * [#1958](https://github.com/dhall-lang/dhall-haskell/pull/1958)+* Fixes and improvements to haddocks+    * [#1881](https://github.com/dhall-lang/dhall-haskell/pull/1881)+    * [#1955](https://github.com/dhall-lang/dhall-haskell/pull/1955)++1.33.1++* [Multi-line REPL / support `repline-0.4.0.0`](https://github.com/dhall-lang/dhall-haskell/pull/1867)+    * `dhall repl` supports a new `:paste` command that lets you input a command+       by pasting one or more lines++1.33.0++* [Supports version 17.0.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v17.0.0)+    * BREAKING CHANGE: [URLs no longer support quoted path components](https://github.com/dhall-lang/dhall-haskell/pull/1812)+    * BREAKING CHANGE: [`Optional/{fold,build}` are no longer built-ins](https://github.com/dhall-lang/dhall-haskell/pull/1802)+    * [Record fields now permit empty labels](https://github.com/dhall-lang/dhall-haskell/pull/1812)+* BREAKING CHANGE: [Fail instead of hanging when deriving `FromDhall` for recursive types](https://github.com/dhall-lang/dhall-haskell/pull/1825)+    * This is a breaking change as now the `expected` type returns an+      `Expector (Expr Src Void)` (essentially an `Either`) instead of+      `Expr Src Void`+    * If you really don't want to handle the new error-related wrapper, you can+      get the old behavior using a partial pattern match (which will be partial,+      still an improvement over the previous behavior, which was hanging)+* BREAKING CHANGE: [Records can no longer contain attributes named after language keywords](https://github.com/dhall-lang/dhall-haskell/pull/1801)+    * This is a bugfix, because the language standard disallows using+      keywords as record labels. However, some users were relying on+      this bug.+    * If you need to use a keyword as a record label, enclose it in backticks:+      ``{ `assert` = 1 }``.+* [Fix invalid cache entries](https://github.com/dhall-lang/dhall-haskell/pull/1793)+    * The interpreter will now correct cached expressions that are incorrect+      and warn you when this happens+    * Specifically, if there is a hash mismatch from the cached expression the+      interpreter will resolve the import again and fix the cache if the+      resolved import matches the expected hash+* [Make `encodeExpression` polymorphic](https://github.com/dhall-lang/dhall-haskell/pull/1789)+    * `encodeExpression` now has a more general type, which means that you+      can use it to serialise expressions without imports (i.e.+      ones of type `Expr Void Void`)+* [Add `--quiet` option for `dhall decode`](https://github.com/dhall-lang/dhall-haskell/pull/1803)+* [Add `--noted` flag for `dhall haskell-syntax-tree`](https://github.com/dhall-lang/dhall-haskell/pull/1843)+* Performance improvements:+    * There were several performance improvements related to binary decoding,+      which should improve cache lookup speed+    * [#1807](https://github.com/dhall-lang/dhall-haskell/pull/1807)+    * [#1809](https://github.com/dhall-lang/dhall-haskell/pull/1809)+    * [#1857](https://github.com/dhall-lang/dhall-haskell/pull/1857)+* Improvements to error messages+    * [#1824](https://github.com/dhall-lang/dhall-haskell/pull/1824)+    * [#1849](https://github.com/dhall-lang/dhall-haskell/pull/1849)+    * [#1851](https://github.com/dhall-lang/dhall-haskell/pull/1851)+* Fixes to haddocks+    * [#1815](https://github.com/dhall-lang/dhall-haskell/pull/1815)++1.32.0++* [Supports version 16.0.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v16.0.0)+    * BREAKING CHANGE: Change the precedence of `with` and `===`+        * The precedence change to `with` means that some old expressions that+          were valid now require explicit parentheses+    * BREAKING CHANGE: Use RFC7049bis encoding for `Double`s+        * This is a breaking change because the hashes of expressions with small+          `Double` literals will change now+    * Add support for unions mixing terms and types+        * For example, `< A : Bool | B : Type >` is legal now+        * You can now write `someRecord with a.b.c = x` to update a nested+          fields+* DEPRECATION: [Deprecate `Dhall.Parser.exprA`](https://github.com/dhall-lang/dhall-haskell/pull/1740)+    * `Dhall.Parser` module will eventually drop support for parsing custom+      import types+    * This is necessary in order to fix several parsing bugs and improve+      parsing error messages+* BUG FIX: [GHC Generics instance for `:+:` now uses `union`](https://github.com/dhall-lang/dhall-haskell/pull/1725)+    * This fixes a few subtle bugs in how Dhall unions are marshalled into+      Haskell types, and also improves the error messages+* Formatting improvements+    * [Change formatting of `if` expressions](https://github.com/dhall-lang/dhall-haskell/pull/1767)+    * [Change formatting for functions and their types](https://github.com/dhall-lang/dhall-haskell/pull/1759)+    * [Prefer puns when formatting record completions](https://github.com/dhall-lang/dhall-haskell/pull/1736)+* [Convert union alternatives to directory tree](https://github.com/dhall-lang/dhall-haskell/pull/1757)+    * `dhall to-directory-tree` now supports unions which are automatically+      unwrapped+* [Fix `dhall freeze --cache` to better handle protected imports](https://github.com/dhall-lang/dhall-haskell/pull/1772)+    * `dhall freeze --cache` will now also update imports that already have+      integrity checks+* [Don't normalized partially saturated `{List,Natural}/fold`](https://github.com/dhall-lang/dhall-haskell/pull/1742)+    * The behavior now matches the standard.  Previously, the Haskell+      implementation was not standards-compliant because it would normalize+      these partially saturated built-ins++1.31.1++* BUG FIX: [Allow whitespace after record pun entry](https://github.com/dhall-lang/dhall-haskell/pull/1733)+    * 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`](https://github.com/dhall-lang/dhall-haskell/pull/1727)+    * 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`](https://github.com/dhall-lang/dhall-haskell/pull/1721)+    * [`haskell-lsp-0.21`](https://github.com/dhall-lang/dhall-haskell/pull/1730)+    * [`repline-0.3` / `haskeline-0.8`](https://github.com/dhall-lang/dhall-haskell/pull/1717)+    * [`template-haskell-2.16`](https://github.com/dhall-lang/dhall-haskell/pull/1719)+* [Prefer to format using record puns when possible](https://github.com/dhall-lang/dhall-haskell/pull/1729)+    * `dhall format` will now reformat code to use record puns when applicable+* Fixes and improvements to error messages:+    * [#1721](https://github.com/dhall-lang/dhall-haskell/pull/1724)++1.31.0++* [Supports version 15.0.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v15.0.0)+    * [Implement `with` keyword](https://github.com/dhall-lang/dhall-haskell/pull/1685)+        * You can now write `someRecord with a.b.c = x` to update a nested+          fields+    * [Add support for record puns](https://github.com/dhall-lang/dhall-haskell/pull/1710)+        * 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](https://github.com/dhall-lang/dhall-haskell/pull/1682)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1696)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1700)+    * 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://github.com/dhall-lang/dhall-haskell/pull/1673)+    * `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](https://github.com/dhall-lang/dhall-haskell/pull/1688)+    * `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](https://github.com/dhall-lang/dhall-haskell/pull/1674)+    * 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 `Map`s](https://github.com/dhall-lang/dhall-haskell/pull/1705)+    * `Map`s are now converted to directories (just like records)+* [Add manpage](https://github.com/dhall-lang/dhall-haskell/pull/1677)+    * ... mainly for the benefit of people packaging Dhall for various+      distributions+* [Group commands in CLI](https://github.com/dhall-lang/dhall-haskell/pull/1692)+    * The command-line `--help` output now groups commands into useful+      sections+* [Fix numeric parsing for GHCJS](https://github.com/dhall-lang/dhall-haskell/pull/1681)+    * The GHCJS backend for Dhall was failing to parse numbers, which this+      change fixes+* Fixes and improvements to error messages:+    * [#1656](https://github.com/dhall-lang/dhall-haskell/pull/1656)+    * [#1698](https://github.com/dhall-lang/dhall-haskell/pull/1698)+    * [#1702](https://github.com/dhall-lang/dhall-haskell/pull/1702)+* Fixes and improvements to the haddocks:+    * [#1708](https://github.com/dhall-lang/dhall-haskell/pull/1708)+    * [#1712](https://github.com/dhall-lang/dhall-haskell/pull/1712)++1.30.0++* [Supports version 14.0.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v14.0.0)+* BREAKING CHANGE TO THE API: [Add `--check` flag to `dhall {lint,freeze}`](https://github.com/dhall-lang/dhall-haskell/pull/1636)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1658)+    * Now a literal like `042` is no longer valid+    * See the [changelog for standard version 14.0.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v14.0.0) for more details+* BUG FIX: [Fix parsing of `Double` literal trailing whitespace](https://github.com/dhall-lang/dhall-haskell/pull/1647)+    * Certain expressions using `Double` literals would fail to parse, which this+      change fixes+* BUG FIX: [Use `DeriveLift` instead of GHC Generics to derive `Lift` ](https://github.com/dhall-lang/dhall-haskell/pull/1640)+    * This fixes a build failure on GHC 8.10+* [Drop support for GHC 7.10.3](https://github.com/dhall-lang/dhall-haskell/pull/1649)+    * GHC 8.0.2 is now the earliest supported version+* [Add support for dotted field syntax](https://github.com/dhall-lang/dhall-haskell/pull/1651)+    * `{ x.y.z = 1 }` now legal syntax for nested fields+    * See the [changelog for standard version 14.0.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v14.0.0) for more details+* [Add support for duplicate record fields](https://github.com/dhall-lang/dhall-haskell/pull/1643)+    * 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](https://github.com/dhall-lang/dhall-lang/releases/tag/v14.0.0) for more details+* [Add `dhall lint` support for deprecating `Optional/{fold,build}`](https://github.com/dhall-lang/dhall-haskell/pull/1628)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1664)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1650)+    * You can now add custom substitutions, which are like `let` bindings that+      propagate to transitive imports+* [Small formatting fixes](https://github.com/dhall-lang/dhall-haskell/pull/1652)++1.29.0++* [Supports version 13.0.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v13.0.0)+* BREAKING CHANGE: [Generate Haskell datatype declarations from Dhall types](https://github.com/dhall-lang/dhall-haskell/commit/b0280826790930d18a5498fb802120478fa11767#diff-a9729dccf50be61ce3d8c68c16f0fd50)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1597)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1598)+    * 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](https://github.com/dhall-lang/dhall-haskell/issues/1350)+* NEW FEATURE: [`dhall to-directory-tree` command](https://github.com/dhall-lang/dhall-haskell/pull/1606)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1607)+    * See the [changelog for standard version 13.0.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v13.0.0) for more details+* NEW FEATURE: [`merge` works on `Optional` values](https://github.com/dhall-lang/dhall-haskell/pull/1608)+    * See the [changelog for standard version 13.0.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v13.0.0) for more details+* [Improve formatter](https://github.com/dhall-lang/dhall-haskell/pull/1609)+    * `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`](https://github.com/dhall-lang/dhall-haskell/pull/1603)+    * Specifically when using the `--{immediate,transitive}-dependencies` flags++1.28.0++* [Supports version 12.0.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v12.0.0)+* BREAKING CHANGE: [Add `Integer/{clamp,negate}` built-ins](https://github.com/dhall-lang/dhall-haskell/pull/1486)+    * 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](https://github.com/dhall-lang/dhall-lang/releases/tag/v12.0.0) for more details+* BREAKING CHANGE: [Remove support for fusion](https://github.com/dhall-lang/dhall-haskell/pull/1478)+    * This is also a technically breaking change to the language.  See the [changelog for standard version 12.0.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v12.0.0) for more details+* BREAKING CHANGE: [Parse whitespace more precisely](https://github.com/dhall-lang/dhall-haskell/pull/1483)+    * 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](https://github.com/dhall-lang/dhall-lang/blob/master/standard/dhall.abnf) 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](https://github.com/dhall-lang/dhall-haskell/pull/1512) for more details+* BREAKING CHANGE: Rename `Type` to `Decoder` and `InputType` to `Encoder` [#1483](https://github.com/dhall-lang/dhall-haskell/pull/1485) / [#1489](https://github.com/dhall-lang/dhall-haskell/pull/1489)+* BUG FIX: [Fix `dhall format --check`](https://github.com/dhall-lang/dhall-haskell/pull/1462)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1471)+    * Before this fix, `dhall freeze` would not attempt to refreeze an already+      frozen import+* [Permit spaces around completion operator](https://github.com/dhall-lang/dhall-haskell/pull/1532)+    * See the [changelog for standard version 12.0.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v12.0.0) for more details+* [Make `missing` referentially transparent](https://github.com/dhall-lang/dhall-haskell/pull/1509)+    * `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](https://github.com/dhall-lang/dhall-lang/releases/tag/v12.0.0) for more details+* [Write cache files atomically](https://github.com/dhall-lang/dhall-haskell/pull/1544)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1507)+    * This is provides the same functionality as the `Interpret` instance for+      `(->)`, except without the use of typeclasses+* [New `dhall haskell-syntax-tree` command](https://github.com/dhall-lang/dhall-haskell/pull/1553)+    * 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`](https://github.com/dhall-lang/dhall-haskell/pull/1567)+* [Move normalization code from `Dhall.Core` to `Dhall.Normalize`](https://github.com/dhall-lang/dhall-haskell/pull/1452)+    * 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"](https://github.com/dhall-lang/dhall-haskell/pull/1539)+* Performance improvements+    * [#1500](https://github.com/dhall-lang/dhall-haskell/pull/1500)+    * [#1522](https://github.com/dhall-lang/dhall-haskell/pull/1522)+    * [#1568](https://github.com/dhall-lang/dhall-haskell/pull/1568)+    * [#1580](https://github.com/dhall-lang/dhall-haskell/pull/1578)+* Fixes and improvements to code formatting+    * [#1460](https://github.com/dhall-lang/dhall-haskell/pull/1460)+    * [#1466](https://github.com/dhall-lang/dhall-haskell/pull/1466)+    * [#1508](https://github.com/dhall-lang/dhall-haskell/pull/1508)+    * [#1527](https://github.com/dhall-lang/dhall-haskell/pull/1527)+    * [#1422](https://github.com/dhall-lang/dhall-haskell/pull/1422)+    * [#1552](https://github.com/dhall-lang/dhall-haskell/pull/1552)+    * [#1543](https://github.com/dhall-lang/dhall-haskell/pull/1543)+    * [#1554](https://github.com/dhall-lang/dhall-haskell/pull/1554)+    * [#1569](https://github.com/dhall-lang/dhall-haskell/pull/1569)+* Fixes and improvements to code linting+    * [#1518](https://github.com/dhall-lang/dhall-haskell/pull/1518)+    * [#1531](https://github.com/dhall-lang/dhall-haskell/pull/1531)+* Fixes and improvements to error messages+    * [#1443](https://github.com/dhall-lang/dhall-haskell/pull/1443)+    * [#1448](https://github.com/dhall-lang/dhall-haskell/pull/1448)+    * [#1482](https://github.com/dhall-lang/dhall-haskell/pull/1482)+    * [#1519](https://github.com/dhall-lang/dhall-haskell/pull/1519)+    * [#1556](https://github.com/dhall-lang/dhall-haskell/pull/1556)+    * [#1528](https://github.com/dhall-lang/dhall-haskell/pull/1528)+* Fixes and improvements to the parser+    * [#1473](https://github.com/dhall-lang/dhall-haskell/pull/1473)+    * [#1549](https://github.com/dhall-lang/dhall-haskell/pull/1549)+    * [#1563](https://github.com/dhall-lang/dhall-haskell/pull/1563)+    * [#1584](https://github.com/dhall-lang/dhall-haskell/pull/1584)+* Fixes and improvements to diffs+    * [#1585](https://github.com/dhall-lang/dhall-haskell/pull/1585)+* Fixes and improvements to the REPL+    * [#1573](https://github.com/dhall-lang/dhall-haskell/pull/1573)+* Fixes and improvements to documentation+    * [#1530](https://github.com/dhall-lang/dhall-haskell/pull/1530)++1.27.0++* [Supports version 11.0.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v11.0.0)+* 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 `Expr`s with special `Double`s+    * This fixes the `Eq` instance for `Expr`s 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`](https://github.com/dhall-lang/dhall-haskell/pull/1445)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1355)+    * See the [changelog for standard version 11.0.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v11.0.0) for more details+* [Add record completion operator](https://github.com/dhall-lang/dhall-haskell/pull/1375)+    * See the [changelog for standard version 11.0.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v11.0.0) for more details+* [Add `dhall tags` subcommand](https://github.com/dhall-lang/dhall-haskell/pull/1398)+    * This generates an ETags file from an input file or directory+* [Add `dhall lint` support for fixing malformed assertions](https://github.com/dhall-lang/dhall-haskell/pull/1353)+    * `dhall lint` now fixes `let example = foo === bar` to be+       `let example = assert : foo === bar`+* Normalize inferred types [#1337](https://github.com/dhall-lang/dhall-haskell/pull/1337)+* New `FromDhall`/`ToDhall` (previously `Interpret`/`Inject`) instances for:+    * [`Void`](https://github.com/dhall-lang/dhall-haskell/pull/1382)+    * `Map` [#1391](https://github.com/dhall-lang/dhall-haskell/pull/1391) / [#1412](https://github.com/dhall-lang/dhall-haskell/pull/1412)+    * [`HashMap`](https://github.com/dhall-lang/dhall-haskell/pull/1426)+    * [`Set` and `HashSet`](https://github.com/dhall-lang/dhall-haskell/pull/1405)+    * [`()`](https://github.com/dhall-lang/dhall-haskell/pull/1388)+* [Add `--output` option to `dhall`](https://github.com/dhall-lang/dhall-haskell/pull/1399)+* [Move syntax things from `Dhall.Core` to a new `Dhall.Syntax` module](https://github.com/dhall-lang/dhall-haskell/pull/1440)+    * This is not a breaking change.  `Dhall.Core` still re-exports the same+      API as before+* Performance improvements+    * [#1362](https://github.com/dhall-lang/dhall-haskell/pull/1362)+    * [#1366](https://github.com/dhall-lang/dhall-haskell/pull/1366)+    * [#1368](https://github.com/dhall-lang/dhall-haskell/pull/1368)+    * [#1397](https://github.com/dhall-lang/dhall-haskell/pull/1397)+    * [#1401](https://github.com/dhall-lang/dhall-haskell/pull/1401)+* Fixes and improvements to code formatting+    * [#1360](https://github.com/dhall-lang/dhall-haskell/pull/1360)+    * [#1372](https://github.com/dhall-lang/dhall-haskell/pull/1372)+    * [#1380](https://github.com/dhall-lang/dhall-haskell/pull/1380)+    * [#1415](https://github.com/dhall-lang/dhall-haskell/pull/1415)++1.26.1++* TECHNICALLY BREAKING CHANGES: [Simplify `⫽` within projection](https://github.com/dhall-lang/dhall-haskell/pull/1283) / [Simplify nested record projections](https://github.com/dhall-lang/dhall-haskell/pull/1307)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1335)+    * This change fixes the performance regression introduced in the previous+      release (version 1.26.0)+* BUG FIX: [Prevent REPL from inserting inferred `Sort`s into context](https://github.com/dhall-lang/dhall-haskell/pull/1318)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1315) / [#1321](https://github.com/dhall-lang/dhall-haskell/pull/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](https://github.com/dhall-lang/dhall-haskell/pull/1312) / [#1329](https://github.com/dhall-lang/dhall-haskell/pull/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](https://github.com/dhall-lang/dhall-haskell/pull/1314)+    * 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`](https://github.com/dhall-lang/dhall-haskell/pull/1325)+    * This lets you use `dhall type` in "check only" mode (e.g. for CI for+      for development feedback)+* Improved GHCJS support - ([#1311](https://github.com/dhall-lang/dhall-haskell/pull/1311) / [#1330](https://github.com/dhall-lang/dhall-haskell/pull/1330))+* [Fix all executables to accept `--version`](https://github.com/dhall-lang/dhall-haskell/pull/1334)+    * Note that the `dhall version` subcommand is still supported, too+* [New `Dhall.Version` module](https://github.com/dhall-lang/dhall-haskell/pull/1332)+* [Don't normalize inferred types](https://github.com/dhall-lang/dhall-haskell/pull/1317)+    * This fixes `dhall type` to more accurately follow the standard+* [Initial changes for GHC 8.8 support](https://github.com/dhall-lang/dhall-haskell/pull/1324)+* [Fix Haddock formatting for `dhallFromJSON`](https://github.com/dhall-lang/dhall-haskell/pull/1316)+* [Improved Windows caching support](https://github.com/dhall-lang/dhall-haskell/pull/1272)+    * `dhall` will now prefer the `%LOCALAPPDATA%` directory for caching if it is+      available+* [Warn about missing cache directories](https://github.com/dhall-lang/dhall-haskell/pull/1320)++1.26.0++* [Supports version 10.0.0 of the standard](https://github.com/dhall-lang/dhall-lang/releases/tag/v10.0.0)+* BREAKING CHANGE TO THE LANGUAGE: [Remove old union literal syntax](https://github.com/dhall-lang/dhall-haskell/pull/1176)+    * Union literals of the form `< x = e | ... >` are no longer valid+    * For more details, see: [Migration: Deprecation of old union literal syntax](https://github.com/dhall-lang/dhall-lang/wiki/Migration%3A-Deprecation-of-old-union-literal-syntax)+    * Also see the [changelog for standard version 10.0.0](https://github.com/dhall-lang/dhall-lang/releases/tag/v10.0.0) for more details+* BREAKING CHANGE TO THE API: [Change `X` to be a type synonym for `Data.Void`](https://github.com/dhall-lang/dhall-haskell/pull/1172)+    * 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-`let`s as syntactic sugar](https://github.com/dhall-lang/dhall-haskell/pull/1242)+    * This is a breaking change because the `Let` constructor now only stores+      one `Binding` instead of a `NonEmpty` list of `Binding`s+* PERFORMANCE REGRESSION & TECHNICALLY BREAKING CHANGE TO THE LANGUAGE: [Dependent types](https://github.com/dhall-lang/dhall-haskell/pull/1164)+    * 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](https://github.com/dhall-lang/dhall-haskell/issues/1306))+    * Splitting large multi-`let` expressions into smaller files may mitigate+      the problem as a work-around for now+    * Follow [#1129](https://github.com/dhall-lang/dhall-haskell/issues/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](https://github.com/dhall-lang/dhall-lang/releases/tag/v10.0.0) for more details+* TECHNICALLY BREAKING CHANGE TO THE LANGUAGE: [Add `Natural/subtract` built-in](https://github.com/dhall-lang/dhall-haskell/pull/1133)+    * 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](https://github.com/dhall-lang/dhall-lang/releases/tag/v10.0.0) for more details+* TECHNICALLY BREAKING CHANGE TO THE LANGUAGE: [More simplifications for field selection](https://github.com/dhall-lang/dhall-haskell/pull/1174)+    * 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](https://github.com/dhall-lang/dhall-lang/releases/tag/v10.0.0) for more details+* TECHNICALLY BREAKING CHANGE TO THE LANGUAGE: [Simplify `⫽` when its arguments are equivalent](https://github.com/dhall-lang/dhall-haskell/pull/1196)+    * 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](https://github.com/dhall-lang/dhall-lang/releases/tag/v10.0.0) for more details+* NEW FEATURE: [Restore support for records containing both types and terms](https://github.com/dhall-lang/dhall-haskell/pull/1173)+    * 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](https://github.com/dhall-lang/dhall-lang/releases/tag/v10.0.0) for more details+* [`dhall format` now preserves `let` comments](https://github.com/dhall-lang/dhall-haskell/pull/1273)+    * `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](https://github.com/dhall-lang/dhall-haskell/pull/1195)+    * You can now marshal recursive types from Dhall into Haskell using the+      newly-added utilities+    * See also: [#1298](https://github.com/dhall-lang/dhall-haskell/pull/1298)+* [New `:help` command for `dhall repl`](https://github.com/dhall-lang/dhall-haskell/pull/1237)+* New `--no-cache` flag [#1290](https://github.com/dhall-lang/dhall-haskell/pull/1290) / [#1434](https://github.com/dhall-lang/dhall-haskell/pull/1434) / [#1436](https://github.com/dhall-lang/dhall-haskell/pull/1436)+    * 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](https://github.com/dhall-lang/dhall-haskell/pull/1210)+    * [Simplify `Natural/subtract` when its arguments are equivalent](https://github.com/dhall-lang/dhall-haskell/pull/1220)+    * [Fix `NaN` to be judgmentally equivalent to itself](https://github.com/dhall-lang/dhall-haskell/pull/1231)+    * [Fix `Inject` instance for lists](https://github.com/dhall-lang/dhall-haskell/pull/1261)+    * [Fix typechecking of `toMap`](https://github.com/dhall-lang/dhall-haskell/pull/1279)+* Performance optimizations+    * [Optimize a few `Set` instances](https://github.com/dhall-lang/dhall-haskell/pull/1184)+    * [Remove some redundant sorting during normalization](https://github.com/dhall-lang/dhall-haskell/pull/1228)+* Improvements to error messages+    * [Improve error reporting for failed remote imports](https://github.com/dhall-lang/dhall-haskell/pull/1188)+    * [Improve HTTP errors](https://github.com/dhall-lang/dhall-haskell/pull/1253)+* Improvements to formatting+    * [Indent function arguments when formatting](https://github.com/dhall-lang/dhall-haskell/pull/1167)+    * [Prefer unquoted URLs](https://github.com/dhall-lang/dhall-haskell/pull/1235)+    * [Strip leading whitespace](https://github.com/dhall-lang/dhall-haskell/pull/1270)+* Improvements to diffs+    * [Fix diffs for lists](https://github.com/dhall-lang/dhall-haskell/pull/1213)+    * [Improve diff for non-empty lists](https://github.com/dhall-lang/dhall-haskell/pull/1244)+    * [Small fixes to `dhall diff`](https://github.com/dhall-lang/dhall-haskell/pull/1263)+* Improvements to documentation+    * [Fix documentation for `UnionInputType`](https://github.com/dhall-lang/dhall-haskell/pull/1230)+    * [Document support for caching protected imports](https://github.com/dhall-lang/dhall-haskell/pull/1247)+* Improvements to command-line interface+    * [Improve description of `dhall lint`](https://github.com/dhall-lang/dhall-haskell/pull/1264)+    * [Change `dhall type` to resolve imports](https://github.com/dhall-lang/dhall-haskell/pull/1281)++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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/987+    * See: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/1027+* BUG FIX: Fix linting of unused let bindings+    * Certain let bindings were not correctly detected as unused, which this+      change fixes+    * See: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/1024+* BUG FIX: `Dhall.Map`: Reflect original key ordering in `Ord` instance+    * `Dhall.Map` now considers key order when comparing `Map`s, which it should+      have done before, but didn't+    * See: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/1056+* BUG FIX: Make `isNormalized` consistent with `normalize`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1115+* BUG FIX: Make `normalizeWithM` consistent with `normalize`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1126+* BUG FIX: Fix import alternatives to recover from type errors+    * See: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/1154+* Feature: New `dhall text` subcommand+    * This new subcommand supersedes the old `dhall-to-text` executable+* Feature: Add `instance Lift (Expr s a)`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1119+* Fixes and improvements to error messages:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1030+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1137+* Fixes and improvements to tests:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1155+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1159+* Performance improvements+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1036+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1051+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1048+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1057+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1065+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1066+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1085++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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/985+* BUG FIX: `dhall diff` no longer double-prints key-value separators+    * See: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/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: https://github.com/dhall-lang/dhall-haskell/pull/980+* Feature: Add `:clear` command to `dhall repl`+    * This deletes previous bindings from the history so that they can be+      garbage collected+    * See: https://github.com/dhall-lang/dhall-haskell/pull/966+* Feature: New `chunkExprs` `Traversal` added to `Dhall.Core`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/954+* Feature: New `Dhall.Optics` module+    * This re-exports some convenient @lens@ utilities used internally for+      packages trying to avoid a @lens@ dependency+    * See: https://github.com/dhall-lang/dhall-haskell/pull/986+* More GHC 8.8 support+    * See: https://github.com/dhall-lang/dhall-haskell/pull/961++1.23.0++* BREAKING CHANGE: Fix marshaling union literals+    * 1.22.0 introduced two separate bugs in marshaling union literals between+      Dhall and Haskell, which this release fixes:+        * Dhall enums did not correctly map onto Haskell enums+        * New-style union literals (i.e. `< A : T >.A x`) were not correctly+          supported+    * See: https://github.com/dhall-lang/dhall-haskell/pull/918+    * See: https://github.com/dhall-lang/dhall-haskell/pull/927+    * See: https://github.com/dhall-lang/dhall-haskell/pull/936+* BUG FIX: Fix α-normalization+    * Version 1.22.0 introduced a new faster evaluation algorithm, but the new+      algorithm introduced two α-normalization regression, which this release+      fixes+    * The primary effect of this bug was that semantic integrity checks would+      fail for expressions that contain an `if`/`then`/else` expression in their+      normal form+    * See: https://github.com/dhall-lang/dhall-haskell/pull/931+    * See: https://github.com/dhall-lang/dhall-haskell/pull/938+* BUG FIX: Fix merging of sort-level record types+    * The language standard requires that `{ a : Kind } ⩓ { b : Kind }` is+      valid, which this change fixes+    * See: https://github.com/dhall-lang/dhall-haskell/pull/891+* BUG FIX: `dhall freeze` respects the `--ascii` flag+    * See: https://github.com/dhall-lang/dhall-haskell/pull/934+* BUG FIX: Don't autocomplete fields for record types+    * This prevents the REPL from expanding `{ x : T }.<TAB>` to `{ x : T }.x`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/937+* Support `MonadFail`-related changes in GHC 8.8+    * See: https://github.com/dhall-lang/dhall-haskell/pull/912+* Add `cross` flag to simplify cross-compilation+    * This allows the `dhall` package to be built without using+      `TemplateHaskell`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/928+* Increase lines of context for error messages+    * Error messages now provide at least 20 lines of context instead of 3+      before truncating large expressions+    * See: https://github.com/dhall-lang/dhall-haskell/pull/916+* Add line numbers to error messages+    * The bottom of every Dhall type error includes the original source code,+      which now has line numbers on the left margin+    * See: https://github.com/dhall-lang/dhall-haskell/pull/919+* Expand lower bounds on `megaparsec`/`transformers-compat` dependencies+    * This is to support `dhall` on Debian Sid+    * See: https://github.com/dhall-lang/dhall-haskell/pull/939++1.22.0++* Supports version 7.0.0 of the standard+    * See: https://github.com/dhall-lang/dhall-lang/releases/tag/v7.0.0+* BREAKING CHANGE: Add support for empty alternatives+    * The `Union` type now has an optional (`Maybe`) type for each alternative+    * See the changelog for standard version 7.0.0 for more details+    * See: https://github.com/dhall-lang/dhall-haskell/pull/863+* BREAKING CHANGE: Remove support for URL fragments+    * The `URL` type no longer has a field for a URL fragment since the language+      no longer supports fragments+    * See the changelog for standard version 7.0.0 for more details+    * See: https://github.com/dhall-lang/dhall-haskell/pull/851+* BREAKING CHANGE: Remove deprecated `Path` type synonym+    * See: https://github.com/dhall-lang/dhall-haskell/pull/858+* BUG FIX: Correctly parse identifiers beginning with `http`+    * i.e. `httpPort` was supposed to be a valid identifier name and now is+    * See: https://github.com/dhall-lang/dhall-haskell/pull/870+* BUG FIX: Fix `dhall encode` bug+    * `dhall encode` bug was generating binary expressions that were valid+      (i.e. they would decode correctly) but were non-standard (i.e. hashing+      them would not match the hash you would normally get from a semantic+      integrity check)+    * Semantic integrity checks were not affected by this bug since they used+      a slightly different code path that generated the correct binary input to+      the hash.  Only the `dhall decode` subcommand was affected+    * See: https://github.com/dhall-lang/dhall-haskell/pull/859+* BUG FIX: Fix for `Dhall.UnionType`+    * This fixes some expressions that would previously fail to marshal into+      Haskell, specifically those were the marshalling logic was built using+      the `UnionType` utilities+    * See: https://github.com/dhall-lang/dhall-haskell/pull/857+* Feature: New `--alpha` flag to α-normalize command-line output+    * See: https://github.com/dhall-lang/dhall-haskell/pull/855+* Performance improvements+    * The normalizer is now *much* faster+    * See: https://github.com/dhall-lang/dhall-haskell/pull/876++1.21.0++* Supports version 6.0.0 of the language standard+    * See: https://github.com/dhall-lang/dhall-lang/releases/tag/v6.0.0+* BREAKING CHANGE: Remove the `constructors` keyword+    * ... as standardized in version 6.0.0 of the language standard+    * The deprecation cycle is over, so the keyword is no longer supported+    * For more details, see: https://github.com/dhall-lang/dhall-lang/wiki/Migration%3A-Deprecation-of-constructors-keyword+    * See: https://github.com/dhall-lang/dhall-haskell/pull/829+* BREAKING CHANGE: CBOR-encode only special `Double`s as half-floats+    * ... as standardized in version 6.0.0 of the language standard+    * CBOR `Double`s except `Infinity`/`-Infinity`/`NaN`/`0.0` are now encoded in at+      least 32 bits+    * See: https://github.com/dhall-lang/dhall-haskell/pull/822+* BREAKING CHANGE: Sort record and union fields when CBOR-encoding+    * Fields and alternatives are now sorted when serialized+    * This does not affect semantic integrity checks, which already sorted these+      fields/alternatives before hashing expressions+    * This does affect the serialization of expressions that have not been+      normalized (e.g. uninterpreted expressions transmitted over the wire)+    * See: https://github.com/dhall-lang/dhall-haskell/pull/835+* BUG FIX: Fix non-exhaustive pattern match in `dhall lint`+    * This fixes: `Irrefutable pattern failed for pattern Let (l' :| ls') d'`+    * This bug would cause `dhall lint` to fail on some nested `let`/`in`+      expressions+    * See: https://github.com/dhall-lang/dhall-haskell/pull/780+    * See: https://github.com/dhall-lang/dhall-haskell/pull/784+* BUG FIX: Don't fail if `$HOME` environment variable is unset+    * The interpreter was incorrectly throwing an exception if `HOME` was unset+    * The standard requires that implementations should handle the `HOME`+      environment variable being missing+    * See: https://github.com/dhall-lang/dhall-haskell/pull/789+* Feature: Remove version tag from semantic integrity check+    * ... as standardized in version 6.0.0 of the language standard+    * This is not a breaking change because this change also includes+      backwards-compatible support for semantic integrity checks produced by+      older versions of the interpreter+* Feature: Support Unicode path components+    * ... as standardized in version 6.0.0 of the language standard+    * You can now use Unicode in path components if they are quoted+    * i.e. `./families/"禺.dhall"` is now legal+* Feature: Add `Text/show` built-in+    * ... as standardized in version 6.0.0 of the language standard+    * You can now convert a `Text` literal to its equivalent Dhall source code+      (which is itself a `Text` literal)+    * This comes in handy when using Dhall code to generate JSON or Dhall code+    * See: https://github.com/dhall-lang/dhall-haskell/pull/811+* Feature: Add `--immediate-dependencies`/`--transitive-dependencies` flags for+  `dhall resolve`+    * You can now retrieve all of your immediate or transitive dependencies as a+      textual list+    * This simplifies integration with other command-line tools (such as file+      watchers)+    * See: https://github.com/dhall-lang/dhall-haskell/pull/795+    * See: https://github.com/dhall-lang/dhall-haskell/pull/803+* Feature: `dhall freeze` now only freezes remote imports by default+    * `dhall freeze` used to freeze all imports (including local imports and+      environment variables)+    * Now `dhall freeze` only freezes remote imports by default, which is what+      most users want+    * You can install freeze all imports using the `--all` flag+    * See: https://github.com/dhall-lang/dhall-haskell/pull/808+* Feature: `:save` and `:load` REPL state+    * `:save` with no arguments now saves the REPL state to a `.dhall-repl-N`+       file+    * The file format is a list of `dhall repl` commands+    * You can use `:load` to load the saved state back into the REPL+    * See: https://github.com/dhall-lang/dhall-haskell/pull/807+* Feature: Add `:hash` command to `dhall repl`+    * This lets you conveniently hash expressions within the `dhall repl`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/806+* Feature: Add `--check` flag to `dhall format`+    * Use this to check if the input is already formatted+    * Useful for continuous integration when you want to ensure that all code+      under version control remains formatted+    * See: https://github.com/dhall-lang/dhall-haskell/pull/810+* Feature: Add  `UnionInputType` builder for `InputType`s+    * This is the union analog of `RecordInputType`, letting you build a+      record explicitly instead of deriving the instance using GHC generics+    * See: https://github.com/dhall-lang/dhall-haskell/pull/775+* Feature: Add `:set`/`:unset` commands to `dhall repl`+    * You can use these commands to set or unset command-line options+    * Currently only setting/unsetting `--explain` is supported+* Standards-compliance fixes:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/779+    * See: https://github.com/dhall-lang/dhall-haskell/pull/804+    * See: https://github.com/dhall-lang/dhall-haskell/pull/833+* Documentation fixes:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/792+    * See: https://github.com/dhall-lang/dhall-haskell/pull/825+* Test fixes:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/782+    * See: https://github.com/dhall-lang/dhall-haskell/pull/836+* Improved error messages:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/812+    * See: https://github.com/dhall-lang/dhall-haskell/pull/815+    * See: https://github.com/dhall-lang/dhall-haskell/pull/824+* Formatting fixes:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/831+* REPL fixes:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/837++1.20.1++* BUG FIX: Fix binary encoding to use correct standard version+    * This fixes computed hashes to correctly match standard version 5.0.0+    * This is not marked as a breaking change since it is a bug fix.  The+      1.20.0 release will be blacklisted on Hackage and users should upgrade+      from 1.19.* directly to 1.20.1+    * See: https://github.com/dhall-lang/dhall-haskell/pull/771++1.20.0++* Supports version 5.0.0 of the language standard+    * See: https://github.com/dhall-lang/dhall-lang/releases/tag/v5.0.0+* BREAKING CHANGE TO THE LANGUAGE: Implement standardized support for multi-line+  literals+    * This updates the multi-line support to match the standard+    * This is a breaking change because empty lines within the multi-line+      literal now require leading whitespace whereas previously they did not+    * This is also a breaking change because now a newline is required after+      the opening `''` quotes whereas previously it was not required+    * If you use `dhall format` then your multi-line literals already have the+      necessary leading whitespace+* BREAKING CHANGE TO THE LANGUAGE: `constructors x = x`+    * Now the `constructors` keyword behaves like an identity function, since+      constructors can already be accessed as fields off the original union+      type.+    * This is a breaking change since any record of terms that contains a+      `constructors` field will now be a forbidden mixed record of types and+      terms.+    * This is also a breaking change if you annotated the type of what used to+      be a `constructors` record.+    * `dhall lint` will now remove the obsolete `constructors` keyword for you+    * See: https://github.com/dhall-lang/dhall-haskell/pull/693+    * See: https://github.com/dhall-lang/dhall-haskell/pull/701+* BREAKING CHANGE TO THE API: Restore `Parent` constructor for `Local` type+    * This more closely matches the standard and also enables `dhall format` to+      produce a leading `../` for imports instead of `./../`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/718+* BUG FIX: Fix type-checking bug for unions+    * The first fix was that the inferred type was wrong for unions where+      alternatives were types or kinds+    * The second fix was that unions that mixed terms/types/kinds were not+      properly rejected+    * See: https://github.com/dhall-lang/dhall-haskell/pull/763+* BUG FIX: Change how `dhall repl` handles prior definitions+    * This changes the REPL to handle previous bindings as if they were+      defined using a large `let` expression instead of adding them to the+      context+    * This fixes some type-checking false negatives+    * See: https://github.com/dhall-lang/dhall-haskell/pull/729+* Feature: Autocomplete for `dhall repl`+    * You can now auto-complete record fields, union constructors, and+      identifiers that are in scope+    * See: https://github.com/dhall-lang/dhall-haskell/pull/727+* Feature: GHCJS support+    * `dhall` can now be built using GHCJS, although some features are still+      not supported for GHCJS, such as:+        * Semantic integrity checks+        * Custom HTTP headers+    * Also, HTTP imports only work for URLs that support CORS+    * See: https://github.com/dhall-lang/dhall-haskell/pull/739+* Feature: Add support for records of records of types+    * You can now nest records of types+    * See: https://github.com/dhall-lang/dhall-haskell/pull/700+* Feature: Add `:quit` command for `dhall repl`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/719+* Feature: Add `--json` flag for `dhall {encode,decode}`+    * You can now produce/consume CBOR expressions via JSON instead of binary+    * See: https://github.com/dhall-lang/dhall-haskell/pull/717+* Feature: Add decoding logic for `as Text`+    * You can now preserve the `as Text` qualifier on imports when serializing+      them+    * See: https://github.com/dhall-lang/dhall-haskell/pull/712+* Prenormalize substituted expressions+    * This is a performance improvement that reduces the time and memory+      consumption when normalizing expressions+    * See: https://github.com/dhall-lang/dhall-haskell/pull/765++1.19.1+++* BUG FIX: Fix serious `dhall lint` bug+    * `dhall lint` would sometimes remove `let` expressions that were still+      in use+    * See: https://github.com/dhall-lang/dhall-haskell/pull/703+* BUG FIX: Fix import caching efficiency bug+    * Some imports were being wastefully fetched multiple times+    * See: https://github.com/dhall-lang/dhall-haskell/pull/702+* Feature: Generate dot graph to visualize import graph+    * Use the `dhall resolve --dot` command+    * See: https://github.com/dhall-lang/dhall-haskell/pull/698+    * See: https://github.com/dhall-lang/dhall-haskell/pull/713+* Improve HTTP error messages+    * See: https://github.com/dhall-lang/dhall-haskell/pull/710++1.19.0++* Supports version 4.0.0 of the language standard+    * See: https://github.com/dhall-lang/dhall-lang/releases/tag/v4.0.0+* BREAKING CHANGE TO THE LANGUAGE AND API: Prevent Hurkens' paradox+    * This fixes a type-checking soundness bug which permitted infinite loops+    * This is a breaking change because infinite loops are no longer possible+    * This is also a breaking change because a record of types is now treated as+      a kind instead of a type+    * See: https://github.com/dhall-lang/dhall-haskell/pull/680+* BREAKING CHANGE TO THE LANGUAGE AND API: `Double`s are now double-precision+  floating point numbers+    * This restricts the range of `Double`s to IEEE 754 double-precision+      floating point+    * This also implies that you can no longer convert `Scientific` values to+      `Dhall` expressions (i.e. no `Inject` instance for `Scientific`)+    * See: https://github.com/dhall-lang/dhall-haskell/pull/667+* BREAKING CHANGE TO THE API: Preserve field order for record projection+    * The API uses a new `Dhall.Set.Set` type instead of `Data.Set.Set`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/670+* BREAKING CHANGE TO THE API: Add support for multi-`let` expressions+    * This changes the `Let` constructor to now support storing multiple+      bindings per `let` expression+    * See: https://github.com/dhall-lang/dhall-haskell/pull/675+* Access constructors as if they were fields of the union type+    * In other words: `< Left : Bool | Right : Natural >.Left`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/657+* Support GHC 8.6+    * See: https://github.com/dhall-lang/dhall-haskell/pull/669+* Add support for quoted path components+    * i.e. `/"foo"/bar/"baz qux"` or `https://example.com/foo/"bar?baz"?qux`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/690+* Fix parsing of `//\\` operator+    * See: https://github.com/dhall-lang/dhall-haskell/commit/9d0fd42d95ab69fa64da4afd8b60d69aca8e65a6+* Preserve Unicode characters when formatting code+    * See: https://github.com/dhall-lang/dhall-haskell/pull/679+* Allow identifier names to begin with `Some`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/658+* Add `subExpressions` `Traversal`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/660+* Add `normalizeWithM` for monadic normalization+    * See: https://github.com/dhall-lang/dhall-haskell/pull/371+* Custom normalizers now take precedence over default normalization logic+    * This allows one to override the implementation of built-in operators+    * See: https://github.com/dhall-lang/dhall-haskell/pull/684++1.18.0++* Supports version 3.0.0 of the language standard:+    * See: https://github.com/dhall-lang/dhall-lang/releases/tag/v3.0.0+* BREAKING CHANGE TO THE LANGUAGE AND API: New `Some`/`None` constructors for+  `Optional` values+    * Example: `[ Some 1, None Natural ]`+    * This is a breaking change to the language because `Some` and `None` are+      now reserved keywords+    * This is a breaking change to the API because `Some` and `None` are new+      constructors for the `Expr` type+* BREAKING CHANGE TO THE LANGUAGE AND API: Support for kind polymorphism+    * This adds a new `Sort` constant above `Kind` in the hierarchy+    * i.e. `Type : Kind : Sort`+    * This is a breaking change to the language because `Sort` is now a+      reserved keyword+    * This is a breaking change to the API because `Sort` is a new+      constructor for the `Expr` type+* BREAKING CHANGE TO THE API: New `Dhall.Map` module+    * This replaces `InsOrdHashMap` in the API+    * The primary motivation is to improve performance and to remove the+      dependency on `insert-ordered-containers`+* BREAKING CHANGE TO THE API: Use standard version instead of protocol version+    * The binary protocol is now versioned alongside the standard+    * The `ProtocolVersion` type is renamed to `StandardVersion` and the+    * `--protocol-version` option is renamed to `--standard-version`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/634+* BUG FIX: Fix import chaining for custom header imports+    * See: https://github.com/dhall-lang/dhall-haskell/pull/618+* BUG FIX: Fix import chaining for imports protected by semantic integrity+  checks+    * See: https://github.com/dhall-lang/dhall-haskell/pull/584+* BUG FIX: Record literals and types produced by `∧`/`⫽`/`⩓` are now sorted+    * This ensures that β-normalization is idempotent+    * See: https://github.com/dhall-lang/dhall-haskell/pull/572+* BUG FIX: `dhall freeze` now correctly handles the starting file being+  located outside the current working directory+    * See: https://github.com/dhall-lang/dhall-haskell/commit/a22aa79d1957be9ecf166ea066e2a9a5b309e1ae+* BUG FIX: Fix parsing of IPv4-mapped IPv6 addresses+    * See: https://github.com/dhall-lang/dhall-haskell/pull/632+* FEATURE: New `--ascii` flag for ASCII output+    * See: https://github.com/dhall-lang/dhall-haskell/pull/570+* FEATURE: New `dhall encode` and `dhall decode` subcommands+    * These allow you to transform Dhall source code to and from its binary+      representation+    * See: https://github.com/dhall-lang/dhall-haskell/pull/588+* LARGE parsing performance improvements+    * Parsing is about 10x-100x faster on most code+    * See: https://github.com/dhall-lang/dhall-haskell/pull/591+    * See: https://github.com/dhall-lang/dhall-haskell/pull/592+    * See: https://github.com/dhall-lang/dhall-haskell/pull/597+    * See: https://github.com/dhall-lang/dhall-haskell/pull/601+    * See: https://github.com/dhall-lang/dhall-haskell/pull/602+    * See: https://github.com/dhall-lang/dhall-haskell/pull/604+    * See: https://github.com/dhall-lang/dhall-haskell/pull/606+* Type-checking performance improvements:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/566+* Normalization performance improvements:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/610+* `dhall freeze` now caches the imports as it freezes them+    * See: https://github.com/dhall-lang/dhall-haskell/pull/587+* `dhall freeze` now refreezes imports with invalid semantic integrity checks+    * See: https://github.com/dhall-lang/dhall-haskell/pull/637+* `dhall freeze` now adds a trailing newline+    * See: https://github.com/dhall-lang/dhall-haskell/pull/629+* Build against `megaparsec-7.0.*`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/565+* Support GHC 8.6+    * See: https://github.com/dhall-lang/dhall-haskell/pull/599+    * See: https://github.com/dhall-lang/dhall-haskell/pull/623+* Support GHC all the way back to 7.10.3+    * See: https://github.com/dhall-lang/dhall-haskell/pull/595+    * See: https://github.com/dhall-lang/dhall-haskell/pull/621+* Improvements to error messages:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/563+    * See: https://github.com/dhall-lang/dhall-haskell/pull/576+    * See: https://github.com/dhall-lang/dhall-haskell/pull/583+    * See: https://github.com/dhall-lang/dhall-haskell/pull/589+++1.17.0++* This release corresponds to version 2.0.0 of the language standard+* BREAKING CHANGE TO THE LANGUAGE AND API: Binary serialization support+    * This is a breaking change to the hash for all semantic integrity checks+    * The hash used by the semantic integrity check is now based on the+      binary representation instead of a text representation of the+      expression+    * You can pin the new hashes by supplying the `--protocol-version 1.0`+      option on the command line until you need support for newer language+      features+    * This also includes a breaking change to `ImportType` in the API+* BREAKING CHANGE TO THE LANGUAGE: Disallow combining records of terms and+  types+    * This is mainly for consistency and to improve type errors that would+      have otherwise happened further downstream+    * This should not affect the vast majority of code+    * See: https://github.com/dhall-lang/dhall-haskell/pull/538+* BUG FIX: Semantic integrity checks now work for imported expression using+  the `constructors` keyword+    * See: https://github.com/dhall-lang/dhall-haskell/pull/554+* BUG FIX: Fix α-normalization of expressions with bound variables named `_`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/524+* BUG FIX: Fix `isNormalized` to match `normalize`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/522+* BUG FIX: `dhall lint` now correctly handles nested `let` expressions+    * See: https://github.com/dhall-lang/dhall-haskell/pull/555+* FEATURE: Imports protected by a semantic integrity check are now cached+    * See: https://github.com/dhall-lang/dhall-haskell/pull/533+* The default `dhall` command no longer outputs the type to `stderr`+    * You can add back the type as a type annotation using the+      `--annotate` switch+    * See: https://github.com/dhall-lang/dhall-haskell/pull/544+* New utilities for building `InputTypes`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/530+* Improve parsing performance for long variable names+    * See: https://github.com/dhall-lang/dhall-haskell/pull/526+* More succinct type diffs for function types+    * See: https://github.com/dhall-lang/dhall-haskell/pull/540+* Identifier names can now begin with keywords+    * i.e. `ifChanged` and `lettuce` are now legal identifiers+    * See: https://github.com/dhall-lang/dhall-haskell/pull/551++1.16.1++* Fix test failure due to missing test data file++1.16.0++* BREAKING CHANGE: Consolidate `input` family of functions+    * These now take a record of options+    * This also `_stack` field of the `Status` type from `[Import]` to+      `NonEmpty Import`+* Permit `$` in quoted variable names+    * See: https://github.com/dhall-lang/dhall-haskell/pull/510++1.15.1++* Fix infinite loop when formatting expressions containing `?`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/491++1.15.0++* BREAKING CHANGE TO THE API: Support alternative imports using new `?` operator+    * This adds a new constructor which affects exhaustive pattern matches+    * See: https://github.com/dhall-lang/dhall-haskell/pull/473+* BREAKING CHANGE TO THE API: Add `Integer/toDouble` built-in function+    * This adds a new constructor which affects exhaustive pattern matches+    * See: https://github.com/dhall-lang/dhall-haskell/pull/434+* BREAKING CHANGE TO THE API: Use strict `Text` instead of lazy `Text`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/455+* BREAKING CHANGE TO THE API: Remove `Buildable` in favor of `Pretty`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/459+* BREAKING CHANGE TO THE API: Removed the `Parent` constructor from `FilePrefix`+    * Instead, use `Here` with a `".."` prefix.+    * See: https://github.com/dhall-lang/dhall-haskell/pull/407+* BUG FIX: Disallow duplicate fields in records+    * See: https://github.com/dhall-lang/dhall-haskell/pull/430+* BUG FIX: Fix stripping of leading whitespace in multi-line strings+    * See: https://github.com/dhall-lang/dhall-haskell/pull/469+* BUG FIX: Fix formatting field access of an import+    * See: https://github.com/dhall-lang/dhall-haskell/pull/471+* Add `dhall freeze` command+    * See: https://github.com/dhall-lang/dhall-haskell/pull/486+* Add `dhall diff` command+    * See: https://github.com/dhall-lang/dhall-haskell/pull/442+* Add `dhall lint` command+    * See: https://github.com/dhall-lang/dhall-haskell/pull/484+* Change `dhall-repl`/`dhall-hash`/`dhall-format` to `dhall` subcommands+    * i.e. `dhall repl`/`dhall hash`/`dhall format`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/435+    * See: https://github.com/dhall-lang/dhall-haskell/pull/452+* Add `with-http` cabal flag to disable support for remote imports+    * See: https://github.com/dhall-lang/dhall-haskell/pull/482+* Added `inputFrom` and `inputFromWith`+    * These allow naming the file that the expression is coming from for better+      error messages+    * See: https://github.com/dhall-lang/dhall-haskell/pull/464+* Performance improvements+    * See: https://github.com/dhall-lang/dhall-haskell/pull/420+* Tutorial recommends GitHub for Prelude instead of IPFS+    * See: https://github.com/dhall-lang/dhall-haskell/pull/479+* Pretty-print expressions in type errors+    * See: https://github.com/dhall-lang/dhall-haskell/pull/429+* Formatting improvements+    * See: https://github.com/dhall-lang/dhall-haskell/pull/398+    * See: https://github.com/dhall-lang/dhall-haskell/pull/458+* Diff improvements+    * See: https://github.com/dhall-lang/dhall-haskell/pull/455+    * See: https://github.com/dhall-lang/dhall-haskell/pull/470+    * See: https://github.com/dhall-lang/dhall-haskell/pull/478++1.14.0++* BREAKING CHANGE TO THE LANGUAGE: Switch grammar of `Natural` and `Integer`+    * `Natural` number literals are now unsigned and `Integer` literals always+      require a sign+    * This is a **VERY** disruptive change to most Dhall code in the wild but+      was unanimously agreed upon here:+      https://github.com/dhall-lang/dhall-lang/issues/138+    * See also: https://github.com/dhall-lang/dhall-haskell/pull/381+* BREAKING CHANGE TO THE LANGUAGE: Drop support for importing directories+    * Importing `dir/` used to resolve to `dir/@`, which is no longer supported+    * See: https://github.com/dhall-lang/dhall-haskell/pull/384+* BREAKING CHANGE TO THE LANGUAGE: Change to the grammar for imports+    * File path components can no longer contain `#` or `?` characters+    * URL imports must now contain at least one path component+    * URL path components must match the grammar for file path components+    * See: https://github.com/dhall-lang/dhall-haskell/pull/390+* BREAKING CHANGE TO THE API: Rename `Path{,Mode,Hashed,Type}` to+  `Import{,Mode,Hashed,Type}`+    * In practice this change is not breaking for the most common use cases+      since this also provides a `Path` type synonym for backwards compatibility+    * See: https://github.com/dhall-lang/dhall-haskell/pull/376+* BUG FIX: Fix α-equivalence bug when type-checking `merge`+    * `merge` expressions would sometimes reject valid code due to a+       type-checking bug+    * See: https://github.com/dhall-lang/dhall-haskell/pull/394+* Improve import caching+    * See: https://github.com/dhall-lang/dhall-haskell/pull/388+    * See: https://github.com/dhall-lang/dhall-haskell/pull/392+* Increase upper bound on `tasty`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/382+* Fix lower bound on `insert-ordered-containers`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/377++1.13.1++* Increase upper bound on `ansi-terminal` and `megaparsec`++1.13.0++* BUG FIX: Fix semantic integrity hashing support+    * Both parsing and pretty-printing semantic hashes were broken since version+      1.11.0+    * See: https://github.com/dhall-lang/dhall-haskell/pull/345+* BUG FIX: Allow leading whitespace in interpolated expresssions+    * See: https://github.com/dhall-lang/dhall-haskell/pull/369+* BUG FIX: Fix `deriving (Interpret)` for sum types+    * The types of alternatives were not correctly included in the corresponding+      Dhall type+    * See: https://github.com/dhall-lang/dhall-haskell/pull/348+* BREAKING CHANGE TO LANGUAGE: Records cannot store both types and terms+    * Records can also not store type-level functions (like `List`)+        * Records might be allowed to store type-level functions again in the+          future+    * This fixes a potential soundness bug+    * The primarily practical consequence of this change is that if you are+      hosting a "package" then you will need to split terms and types from your+      package into different records for your users to import+    * This also implies removing the `./Monoid` type-level function from the+      `./Prelude/package.dhall` record+    * See: https://github.com/dhall-lang/dhall-haskell/pull/335+* BREAKING CHANGE TO THE API: Replace `trifecta` with `megaparsec`+    * This change the API to use the `Parser` type from `megaparsec`+    * This also slightly changes the type of `exprFromText`+    * If you program using the type classes provided by the `parsers` library+      then this is not a breaking change as that interface is preserved+    * See: https://github.com/dhall-lang/dhall-haskell/pull/268+* BREAKING CHANGE TO THE API: New `⩓` operator for merging record types+    * Example: `{ foo : Text } ⩓ { bar : Bool } = { foo : Text, bar : Bool }`+    * This is breaking because it adds a new constructor to the `Expr` type+    * See: https://github.com/dhall-lang/dhall-haskell/pull/342+* BREAKING CHANGE TO THE API: New support for projecting a subset of fields+    * Example: `{ x = 1, y = 2, z = 3 }.{ x, y } = { x = 1, y = 2 }`+    * This is breaking because it adds a new constructor to the `Expr` type+    * See: https://github.com/dhall-lang/dhall-haskell/pull/350+* API+UX feature: New support for pretty-printing diffs of Dhall expressions+    * Error messages also use this feature to simplify large type mismatches+    * There is also a new `Dhall.Diff` module+    * See: https://github.com/dhall-lang/dhall-haskell/pull/336+* Add `version`, `resolve`, `type`, and `normalize` sub-commands to interpreter+    * See: https://github.com/dhall-lang/dhall-haskell/pull/352+* Support GHC 7.10.3+    * See: https://github.com/dhall-lang/dhall-haskell/pull/340+* `:type` command in `dhall-repl` now only displays the type+    * Before it would also display the original expression+    * See: https://github.com/dhall-lang/dhall-haskell/pull/344+* Trim dependency tree+    * See: https://github.com/dhall-lang/dhall-haskell/pull/351+    * See: https://github.com/dhall-lang/dhall-haskell/pull/268+    * See: https://github.com/dhall-lang/dhall-haskell/pull/355++1.12.0++* Additional changes to support GHC 8.4+    * See: https://github.com/dhall-lang/dhall-haskell/pull/331+* BREAKING CHANGE TO API: Replace dependency on `text-format` with `formatting`+    * This replace the `Data.Text.Buildable.Buildable` instances with+      `Formatting.Buildable.Buildable` instances, which is why this is a+       breaking change+    * `text-format` is no longer maintained and blocking GHC 8.4 support+    * See: https://github.com/dhall-lang/dhall-haskell/pull/330++1.11.1++* Support GHC 8.4+    * See: https://github.com/dhall-lang/dhall-haskell/pull/321+* Fix α-normalization bug+    * Note that this is not a type-checking bug.  This only affects users who+      were directly using the `alphaNormalize` function from the Haskell API+      because `let` expressions were not correctly α-normalized+    * See: https://github.com/dhall-lang/dhall-haskell/pull/319+* Slight tweak to syntax highlighting+    * See: https://github.com/dhall-lang/dhall-haskell/pull/324+* Increase upper bound on `ansi-terminal` and `exceptions`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/322+    * See: https://github.com/dhall-lang/dhall-haskell/pull/325++1.11.0++* BREAKING CHANGE TO THE API: Fix `{Natural,Optional,List}/build` semantics to+  match standard+    * This is a breaking change because the `OptionalLit` and `ListLit`+      constructors changed their representations to efficiently support the+      standard semantics+    * `ListLit` now stores a `Data.Sequence.Seq` instead of a+      `Data.Vector.Vector`+    * `OptionalLit` now stores a `Maybe` instead of a `Data.Vector.Vector`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/300+* BREAKING CHANGE TO THE COMMAND LINE: `dhall` executable always formats output+    * Previously you had to opt into formatting using `--pretty`+    * Now formatting is obligatory and the `--pretty` flag is gone+    * See: https://github.com/dhall-lang/dhall-haskell/pull/303+* Feature: New `:save` command for `dhall-repl`+    * Now you can save an expression to a file: `./yourFile = someExpression`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/309+* Improvement: Add new simplifications to match standard+    * See: https://github.com/dhall-lang/dhall-haskell/pull/312+    * See: https://github.com/dhall-lang/dhall-haskell/pull/316+* Improvement: Fix equivalence check to match standard+    * Practically this means that more corner cases of the language correctly+      type-check than before+* Improvement: New `--plain` flag to disable syntax highlighting+    * See: https://github.com/dhall-lang/dhall-haskell/pull/310+* Improvement: Prelude now provides an umbrella `package.dhall` import+    * This is primarily for convenience+    * See: https://github.com/dhall-lang/dhall-haskell/pull/298+* Improvement: Context is now normalized+    * See: https://github.com/dhall-lang/dhall-haskell/pull/302+* Replace `cryptohash` dependency with `cryptonite`+    * See: https://github.com/dhall-lang/dhall-haskell/commit/5d2012927a062ec8bdf2bbaba77150344f38db77+* Increase upper bound on exceptions+    * See: https://github.com/dhall-lang/dhall-haskell/pull/306+* Fix type error in tutorial+    * See: https://github.com/dhall-lang/dhall-haskell/commit/5a9126b2f684d3236fc1e8e20e206cfaf47d97db++1.10.0++* Feature: Records/unions can now have fields/alternatives that are types+    * i.e. `{ foo = Text, bar = List }` is legal now+    * See: https://github.com/dhall-lang/dhall-haskell/pull/273+* Feature: New `dhall-repl` for interactively evaluating Dhall expressions+    * See: https://github.com/dhall-lang/dhall-haskell/pull/266+* Feature: Syntax highlighting+    * See: https://github.com/dhall-lang/dhall-haskell/pull/260+* Feature: BREAKING CHANGE TO THE API: `dhall-format` preserves field order+    * This changes the syntax tree to use an `InsOrdHashMap` instead of a `Map`+* BREAKING CHANGE TO THE API: Use Haskell's `Scientific` type+    * This is fixes the interpreter to correct handle really large/small numbers+    * This also allows marshaling into Haskell's `Scientific` type+    * See: https://github.com/dhall-lang/dhall-haskell/pull/256+* BREAKING CHANGE TO THE API: Remove `system-filepath`/`system-fileio` dependencies+    * Now the library uses `Prelude.FilePath`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/248+* Feature: Labels can now begin with reserved names+    * i.e. `List/map` is now a legal label+    * See: https://github.com/dhall-lang/dhall-haskell/pull/255+* Fix: Rendered labels are now correctly escaped if they are numbers+    * See: https://github.com/dhall-lang/dhall-haskell/pull/252+* Add the instance `Interpret String`.+    * See: https://github.com/dhall-lang/dhall-haskell/pull/247+* Fix: Custom contexts passed to `typeWith` are now checked+    * This prevents a custom context from triggering an infinite loop+    * See: https://github.com/dhall-lang/dhall-haskell/pull/259++1.9.1++* `dhall-format` now emits single-quoted strings for multi-line strings+    * See: https://github.com/dhall-lang/dhall-haskell/pull/237+* Improved error messages for list elements with the wrong type+    * See: https://github.com/dhall-lang/dhall-haskell/pull/236+* Change `lens` dependency to `lens-family-core`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/238++1.9.0++* Feature: BREAKING CHANGE TO LANGUAGE AND API: Add `constructors` keyword+    * This new keyword generates constructors from a union type+        * See the updated Haskell tutorial for more details+    * This means that `constructors` is now a reserved keyword+    * This adds a new `Constructors` constructor to the `Expr` type+    * See: https://github.com/dhall-lang/dhall-haskell/pull/199+* Feature: BREAKING CHANGE TO THE API: `dhall-format` preserves interpolation+    * This changes the `TextLit` constructor to represent an interpolated `Text`+      literal+    * See: https://github.com/dhall-lang/dhall-haskell/pull/220+* Feature: You can now define type synonyms using `let`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/202+* Feature: Extend valid set of quoted labels+    * See: https://github.com/dhall-lang/dhall-lang/pull/65+    * See: https://github.com/dhall-lang/dhall-lang/pull/77+* Performance: Improve startup time when importing files, but not URLs+    * See: https://github.com/dhall-lang/dhall-haskell/pull/194+* Security: `localhost`/`127.0.0.1` imports no longer count as local imports+    * Specifically: they cannot import environment variables or files+    * See: https://github.com/dhall-lang/dhall-haskell/pull/197+* Security: Fix potential type-checking bug+    * See: https://github.com/dhall-lang/dhall-haskell/pull/198+* Fix: BREAKING CHANGE TO API: Improve localization of error messages+    * This required fixing the type of `normalize`/`shift`/`subst` to preserve+      the first type parameter of `Expr` (i.e. they no longer delete `Note`+      constructors)+    * A new `denote` function was added for the explicit purpose of deleting+      `Note` constructors+    * See: https://github.com/dhall-lang/dhall-haskell/pull/218+* Expose `MissingEnvironmentVariable` exception type+    * See: https://github.com/dhall-lang/dhall-haskell/pull/196+* Add `genericAuto`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/195+* Add `inputWith`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/222+* Add`loadWithContext`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/215+* Add `pair`/`unit`/`string`/`list`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/227++1.8.2++* Add `typeWithA` for type-checking custom `Embed`ded values+* Fix `dhall{,-*}` executables to ignore ambient locale and use UTF8+* Increase upper bound on `tasty` dependency++1.8.1++* `dhall` executable can now format output using `--pretty`+* Improved Unicode suppport on Windows++1.8.0++* BREAKING CHANGE TO LANGUAGE: Add support for import integrity checks+    * In practice, the likelihood of this breaking code in the wild is+      astronomically low+    * This would only break code of the form `sha256:aaa...aaa` (i.e. a+      variabled named `sha256` with a type annotation for a type with a name+      64 characters long drawn from the first 6 characters of the alphabet)+* BUG FIX: Fix parsing of single quotes in single-quoted strings+* BUG FIX: Fix superfluous parentheses introduced by `dhall-format`+* New `dhall-hash` executable+    * This goes hand-in-hand with the added support for integrity checks since+      the executable lets you compute the current hash of an import++1.7.0++* BREAKING CHANGE TO LANGUAGE: Update parser to match standardized grammar+    * Trailing commas and bars no longer supported for union and record literals+    * Paths no longer permit commas+    * URL grammar is now RFC-compliant+    * Environment variables can now be quoted to support full range of+      POSIX-compliant names+    * Text literals support full set of JSON escape sequences (such as `\u2192`)+* BREAKING CHANGE TO LANGUAGE: Single quoted strings strip leading newlines+* BUG FIX: Fixed type-checking infinite loops due to non-type-checked variables+  in context+* BUG FIX: Fixed type-checking bug due to missing context when type-checking+  certain expressions+* BUG FIX: Fixed type-checking bug due to off-by-one errors in name shadowing+  logic+* New `dhall-format` executable to automatically format code+* Performance optimizations to `Natural/fold` and `List/fold`+* Improved parsing performance (over 3x faster)+* Union literals can now specify the set value anywhere in the literal+    * i.e. `< A : Integer | B = False | C : Text >`+* New `Inject` instance for `()`+* Several tutorial fixes and improvements++1.6.0++* BREAKING CHANGE TO THE API: Drop support for GHC 7.*+* BREAKING CHANGE TO THE API: Add support for customizing Dhall import+    * This is a breaking change because this changes the type of `loadWith`+* BREAKING CHANGE TO THE API: Add field to `UnboundVariable` error containing+* BUG FIX: Fix parsing single quotes in string literals+  the name of the unbound variable+* Add `List/concatMap` to the Prelude+* You can now derive `Inject` and `Interpret` for types with unlabeled fields+* Add new instances for `Interpret`:+    * `[]`+    * `(,)`+* Add new instance for `Inject`+    * `[]`, `Data.Set.Set`, `Data.Sequence.Seq`+    * `(,)`+    * `Int`, `Word8`, `Word16`, `Word32`, `Word64`+* Add `Eq` instance for `Src`++1.5.1++* Increase upper bound on `vector` and `optparse-generic`++1.5.0++* BREAKING CHANGE: Add list concatenation operator: `(#)`+    * This is a breaking change because it adds a new constructor to the `Expr`+      type which breaks exhaustive pattern matches+* BREAKING CHANGE: Add `Interpret` support for lazy `Text`+    * This is a breaking change because it renames `text` to `strictText`+* Add `Interpret` instance for decoding (a limited subset of) Dhall functions+* Dhall no longer requires Template Haskell to compile+    * This helps with cross-compilation+* Add `rawInput` utility for decoding a Haskell value from the `Expr` type+* Add `loadWith`/`normalizeWith` utilities for normalizing/importing modules+  with a custom context+* Export `Type` constructor++1.4.2++* Fix missing `Prelude` files in package archive uploaded to Hackage++1.4.1++* Fix missing `tests/Tutorial.hs` module in package archive uploaded to Hackage++1.4.0++* BREAKING CHANGE TO THE LANGUAGE AND API: You can now supply custom headers for+  URL imports with the new `using` keyword+    * This is a breaking change to the language because this adds a new reserved+      `using` keyword+    * This is a breaking change to the API because this adds a new field to the+      `URL` constructor to store optional custom headers+* BUG FIX: `:` is no longer a disallowed path character+    * This was breaking URL imports with a port+* BUG FIX: If you import a home-anchored path (i.e. `~/foo`) and that imports a+  relative path (like `./bar`), then the canonical path of the relative import+  should be home-anchored (i.e. `~/bar`).  However, there was a bug that made+  lose the home anchor (i.e. `./foo/bar`), which this release fixes+  likely fail due to no longer being home-anchored (i.e. `./foob+* Add support for string interpolation+* `merge` no longer requires a type annotation if you are merging at least one+  alternative+* Expanded Prelude+    * `./Prelude/Optional/all`+    * `./Prelude/Optional/any`+    * `./Prelude/Optional/filter`+    * `./Prelude/Optional/length`+    * `./Prelude/Optional/null`+    * `./Prelude/Text/concatMap`+    * `./Prelude/Text/concatMapSep`+    * `./Prelude/Text/concatSep`+* Rearrange detailed error messages to put summary information at the bottom of+  the message++1.3.0++* BREAKING CHANGE TO THE API: Add support for new primitives, specifically:+    * `(//)` - Right-biased and shallow record merge+    * `Optional/build` (now a built-in in order to support build/fold fusion)+    * `Natural/show`+    * `Integer/show`+    * `Double/show`+    * `Natural/toInteger`+    * These all add new constructors to the `Expr` type, which would break+      exhaustive pattern matches+* BREAKING CHANGE TO THE LANGUAGE: Imported paths and URLs no longer support+  the characters: "()[]{}<>:"+    * This reduces the number of cases where you have to add a space after+      imports+    * Note that this does not exclude the `:` in the URL scheme (i.e. `http://`)+* Increase connection timeout for imports+* Variable names now allow the `-` character for all but the first character+* You can now escape identifiers with backticks+    * This lets you name identifiers so that they don't conflict with reserved+      key words+    * This is most useful when converting Dhall to other file formats (like+      JSON) where you might need to emit a field that conflicts with one of+      Dhall's reserved keywords+* New `--version` flag for the `dhall` executable+ 1.2.0  * BREAKING CHANGE: Add support for customizing derived `Interpret` instances
LICENSE view
@@ -1,24 +1,27 @@-Copyright (c) 2017 Gabriel Gonzalez+Copyright (c) 2020 Gabriella Gonzalez All rights reserved. -Redistribution and use in source and binary forms, with or without modification,-are permitted provided that the following conditions are met:-    * Redistributions of source code must retain the above copyright notice,-      this list of conditions and the following disclaimer.-    * Redistributions in binary form must reproduce the above copyright notice,-      this list of conditions and the following disclaimer in the documentation-      and/or other materials provided with the distribution.-    * Neither the name of Gabriel Gonzalez nor the names of other contributors-      may be used to endorse or promote products derived from this software-      without specific prior written permission.+Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met: -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.+1. Redistributions of source code must retain the above copyright notice, this+list of conditions and the following disclaimer.++2. Redistributions in binary form must reproduce the above copyright notice,+this list of conditions and the following disclaimer in the documentation+and/or other materials provided with the distribution.++3. Neither the name of the author nor the names of its contributors may be+used to endorse or promote products derived from this software without+specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ benchmark/deep-nested-large-record/BigEnum.dhall view
@@ -0,0 +1,302 @@+< A0 : {}+| A1 : {}+| A2 : {}+| A3 : {}+| A4 : {}+| A5 : {}+| A6 : {}+| A7 : {}+| A8 : {}+| A9 : {}+| A10 : {}+| A11 : {}+| A12 : {}+| A13 : {}+| A14 : {}+| A15 : {}+| A16 : {}+| A17 : {}+| A18 : {}+| A19 : {}+| A20 : {}+| A21 : {}+| A22 : {}+| A23 : {}+| A24 : {}+| A25 : {}+| A26 : {}+| A27 : {}+| A28 : {}+| A29 : {}+| A30 : {}+| A31 : {}+| A32 : {}+| A33 : {}+| A34 : {}+| A35 : {}+| A36 : {}+| A37 : {}+| A38 : {}+| A39 : {}+| A40 : {}+| A41 : {}+| A42 : {}+| A43 : {}+| A44 : {}+| A45 : {}+| A46 : {}+| A47 : {}+| A48 : {}+| A49 : {}+| A50 : {}+| A51 : {}+| A52 : {}+| A53 : {}+| A54 : {}+| A55 : {}+| A56 : {}+| A57 : {}+| A58 : {}+| A59 : {}+| A60 : {}+| A61 : {}+| A62 : {}+| A63 : {}+| A64 : {}+| A65 : {}+| A66 : {}+| A67 : {}+| A68 : {}+| A69 : {}+| A70 : {}+| A71 : {}+| A72 : {}+| A73 : {}+| A74 : {}+| A75 : {}+| A76 : {}+| A77 : {}+| A78 : {}+| A79 : {}+| A80 : {}+| A81 : {}+| A82 : {}+| A83 : {}+| A84 : {}+| A85 : {}+| A86 : {}+| A87 : {}+| A88 : {}+| A89 : {}+| A90 : {}+| A91 : {}+| A92 : {}+| A93 : {}+| A94 : {}+| A95 : {}+| A96 : {}+| A97 : {}+| A98 : {}+| A99 : {}+| A100 : {}+| A101 : {}+| A102 : {}+| A103 : {}+| A104 : {}+| A105 : {}+| A106 : {}+| A107 : {}+| A108 : {}+| A109 : {}+| A110 : {}+| A111 : {}+| A112 : {}+| A113 : {}+| A114 : {}+| A115 : {}+| A116 : {}+| A117 : {}+| A118 : {}+| A119 : {}+| A120 : {}+| A121 : {}+| A122 : {}+| A123 : {}+| A124 : {}+| A125 : {}+| A126 : {}+| A127 : {}+| A128 : {}+| A129 : {}+| A130 : {}+| A131 : {}+| A132 : {}+| A133 : {}+| A134 : {}+| A135 : {}+| A136 : {}+| A137 : {}+| A138 : {}+| A139 : {}+| A140 : {}+| A141 : {}+| A142 : {}+| A143 : {}+| A144 : {}+| A145 : {}+| A146 : {}+| A147 : {}+| A148 : {}+| A149 : {}+| A150 : {}+| A151 : {}+| A152 : {}+| A153 : {}+| A154 : {}+| A155 : {}+| A156 : {}+| A157 : {}+| A158 : {}+| A159 : {}+| A160 : {}+| A161 : {}+| A162 : {}+| A163 : {}+| A164 : {}+| A165 : {}+| A166 : {}+| A167 : {}+| A168 : {}+| A169 : {}+| A170 : {}+| A171 : {}+| A172 : {}+| A173 : {}+| A174 : {}+| A175 : {}+| A176 : {}+| A177 : {}+| A178 : {}+| A179 : {}+| A180 : {}+| A181 : {}+| A182 : {}+| A183 : {}+| A184 : {}+| A185 : {}+| A186 : {}+| A187 : {}+| A188 : {}+| A189 : {}+| A190 : {}+| A191 : {}+| A192 : {}+| A193 : {}+| A194 : {}+| A195 : {}+| A196 : {}+| A197 : {}+| A198 : {}+| A199 : {}+| A200 : {}+| A201 : {}+| A202 : {}+| A203 : {}+| A204 : {}+| A205 : {}+| A206 : {}+| A207 : {}+| A208 : {}+| A209 : {}+| A210 : {}+| A211 : {}+| A212 : {}+| A213 : {}+| A214 : {}+| A215 : {}+| A216 : {}+| A217 : {}+| A218 : {}+| A219 : {}+| A220 : {}+| A221 : {}+| A222 : {}+| A223 : {}+| A224 : {}+| A225 : {}+| A226 : {}+| A227 : {}+| A228 : {}+| A229 : {}+| A230 : {}+| A231 : {}+| A232 : {}+| A233 : {}+| A234 : {}+| A235 : {}+| A236 : {}+| A237 : {}+| A238 : {}+| A239 : {}+| A240 : {}+| A241 : {}+| A242 : {}+| A243 : {}+| A244 : {}+| A245 : {}+| A246 : {}+| A247 : {}+| A248 : {}+| A249 : {}+| A250 : {}+| A251 : {}+| A252 : {}+| A253 : {}+| A254 : {}+| A255 : {}+| A256 : {}+| A257 : {}+| A258 : {}+| A259 : {}+| A260 : {}+| A261 : {}+| A262 : {}+| A263 : {}+| A264 : {}+| A265 : {}+| A266 : {}+| A267 : {}+| A268 : {}+| A269 : {}+| A270 : {}+| A271 : {}+| A272 : {}+| A273 : {}+| A274 : {}+| A275 : {}+| A276 : {}+| A277 : {}+| A278 : {}+| A279 : {}+| A280 : {}+| A281 : {}+| A282 : {}+| A283 : {}+| A284 : {}+| A285 : {}+| A286 : {}+| A287 : {}+| A288 : {}+| A289 : {}+| A290 : {}+| A291 : {}+| A292 : {}+| A293 : {}+| A294 : {}+| A295 : {}+| A296 : {}+| A297 : {}+| A298 : {}+| A299 : {}+| A300 : {}+>
+ benchmark/deep-nested-large-record/LittleEnum.dhall view
@@ -0,0 +1,4 @@+< Foo : {}+| Bar : {}+| Baz : {}+>
+ benchmark/deep-nested-large-record/Main.hs view
@@ -0,0 +1,72 @@+{-# LANGUAGE OverloadedStrings #-}+module Main (main) where++import Data.Void        (Void)+import Test.Tasty.Bench++import qualified Data.Sequence   as Seq+import qualified Dhall.Core      as Core+import qualified Dhall.Import    as Import+import qualified Dhall.TypeCheck as TypeCheck++dhallPreludeImport :: Core.Import+dhallPreludeImport = Core.Import+  { Core.importMode = Core.Code+  , Core.importHashed = Core.ImportHashed+    { Core.hash = Nothing+    , Core.importType = Core.Local Core.Here $ Core.File+      { Core.directory = Core.Directory ["deep-nested-large-record", "benchmark"]+      , Core.file = "prelude.dhall"+      }+    }+  }++issue412 :: Core.Expr s Void -> Benchmarkable+issue412 prelude = whnf TypeCheck.typeOf expr+  where+    expr+      = Core.Let (Core.Binding Nothing "prelude" Nothing Nothing Nothing prelude)+      $ Core.ListLit Nothing+      $ Seq.replicate 5+      $ Core.Var (Core.V "prelude" 0) `Core.Field` types `Core.Field` little `Core.Field` foo+    types = Core.makeFieldSelection "types"+    little = Core.makeFieldSelection "little"+    foo = Core.makeFieldSelection "Foo"++unionPerformance :: Core.Expr s Void -> Benchmarkable+unionPerformance prelude = whnf TypeCheck.typeOf expr+  where+    expr =+        Core.Let+            (Core.Binding+                Nothing+                "x"+                Nothing+                Nothing+                Nothing+                (Core.Let+                    (Core.Binding+                        Nothing+                        "big"+                        Nothing+                        Nothing+                        Nothing+                        (prelude `Core.Field` types `Core.Field` big)+                    )+                    (Core.Prefer mempty Core.PreferFromSource "big" "big")+                )+            )+            "x"+    types = Core.makeFieldSelection "types"+    big = Core.makeFieldSelection "Big"++main :: IO ()+main =+  defaultMain+    [ env prelude $ \p ->+      bgroup "Prelude"+        [ bench "issue 412" (issue412 p)+        , bench "union performance" (unionPerformance p)+        ]+    ]+  where prelude = Import.load (Core.Embed dhallPreludeImport)
+ benchmark/deep-nested-large-record/prelude.dhall view
@@ -0,0 +1,5 @@+{ types =+  { Big = ./BigEnum.dhall+  , Little = ./LittleEnum.dhall+  }+}
+ benchmark/parser/Main.hs view
@@ -0,0 +1,91 @@+{-# LANGUAGE BangPatterns      #-}+{-# LANGUAGE OverloadedStrings #-}++module Main where++import Control.Exception (throw)+import Control.Monad     (forM)+import Data.Map          (Map)+import Data.Text         (Text)+import Data.Void         (Void)+import Test.Tasty.Bench++import qualified Data.ByteString.Lazy+import qualified Data.Map             as Map+import qualified Data.Text            as Text+import qualified Data.Text.IO+import qualified Dhall.Binary+import qualified Dhall.Core           as Dhall+import qualified Dhall.Parser         as Dhall+import qualified System.Directory     as Directory++type PreludeFiles = Map FilePath Text++loadPreludeFiles :: IO PreludeFiles+loadPreludeFiles = loadDirectory "./dhall-lang/Prelude"+    where+        loadDirectory :: FilePath -> IO PreludeFiles+        loadDirectory dir =+            Directory.withCurrentDirectory dir $ do+                files <- Directory.getCurrentDirectory >>= Directory.listDirectory+                results <- forM files $ \file -> do+                    file' <- Directory.makeAbsolute file+                    doesExist <- Directory.doesFileExist file'+                    if doesExist+                       then loadFile file'+                       else loadDirectory file'+                pure $ Map.unions results++        loadFile :: FilePath -> IO PreludeFiles+        loadFile path = Map.singleton path <$> Data.Text.IO.readFile path++benchParser :: PreludeFiles -> Benchmark+benchParser =+      bgroup "exprFromText"+    . Map.foldrWithKey (\name expr -> (benchExprFromText name expr :)) []++benchExprFromText :: String -> Text -> Benchmark+benchExprFromText name !expr =+    bench name $ whnf (Dhall.exprFromText "(input)") expr++benchExprFromBytes :: String -> Data.ByteString.Lazy.ByteString -> Benchmark+benchExprFromBytes name bs = bench name (nf f bs)+  where+    f bytes =+        case Dhall.Binary.decodeExpression bytes of+            Left  exception  -> error (show exception)+            Right expression -> expression :: Dhall.Expr Void Dhall.Import++benchNfExprFromText :: String -> Text -> Benchmark+benchNfExprFromText name !expr =+    bench name $ nf (either throw id . Dhall.exprFromText "(input)") expr++main :: IO ()+main = do+    prelude <- loadPreludeFiles+    defaultMain+        [ env issues $ \ ~(it, ib) ->+            bgroup "Issue #108"+                [ benchExprFromText  "Text"   it+                , benchExprFromBytes "Binary" ib+                ]+        , env kubernetesExample $+            benchExprFromBytes "Kubernetes/Binary"+        , benchExprFromText "Long variable names" (Text.replicate 1000000 "x")+        , benchExprFromText "Large number of function arguments" (Text.replicate 10000 "x ")+        , benchExprFromText "Long double-quoted strings" ("\"" <> Text.replicate 1000000 "x" <> "\"")+        , benchExprFromText "Long single-quoted strings" ("''" <> Text.replicate 1000000 "x" <> "''")+        , benchExprFromText "Whitespace" (Text.replicate 1000000 " " <> "x")+        , benchExprFromText "Line comment" ("x -- " <> Text.replicate 1000000 " ")+        , benchExprFromText "Block comment" ("x {- " <> Text.replicate 1000000 " " <> "-}")+        , benchExprFromText "Deeply nested parentheses" "((((((((((((((((x))))))))))))))))"+        , benchParser prelude+        , env cpkgExample $+            benchNfExprFromText "CPkg/Text"+        ]+    where+        cpkgExample = Data.Text.IO.readFile "benchmark/parser/examples/cpkg.dhall"+        issue108Text = Data.Text.IO.readFile "benchmark/parser/examples/issue108.dhall"+        issue108Bytes = Data.ByteString.Lazy.readFile "benchmark/parser/examples/issue108.dhallb"+        issues = (,) <$> issue108Text <*> issue108Bytes+        kubernetesExample = Data.ByteString.Lazy.readFile "benchmark/parser/examples/kubernetes.dhallb"
+ benchmark/parser/examples/cpkg.dhall view

file too large to diff

+ benchmark/parser/examples/issue108.dhall view
@@ -0,0 +1,63 @@+λ ( xs : List { cores : Natural , host : Text , key : Text , mandatoryFeatures :+List Text , platforms : List < AArch64_Linux : {} | ARMv5tel_Linux : {} |+ARMv7l_Linux : {} | I686_Cygwin : {} | I686_Linux : {} | MIPS64el_Linux : {} |+PowerPC_Linux : {} | X86_64_Cygwin : {} | X86_64_Darwin : {} | X86_64_FreeBSD :+{} | X86_64_Linux : {} | X86_64_Solaris : {} > , speedFactor : Natural ,+supportedFeatures : List Text , user : Optional Text } )→ List/fold { cores :+Natural , host : Text , key : Text , mandatoryFeatures : List Text , platforms :+List < AArch64_Linux : {} | ARMv5tel_Linux : {} | ARMv7l_Linux : {} |+I686_Cygwin : {} | I686_Linux : {} | MIPS64el_Linux : {} | PowerPC_Linux : {} |+X86_64_Cygwin : {} | X86_64_Darwin : {} | X86_64_FreeBSD : {} | X86_64_Linux :+{} | X86_64_Solaris : {} > , speedFactor : Natural , supportedFeatures : List+Text , user : Optional Text } xs Text ( λ ( x : { cores : Natural , host : Text+, key : Text , mandatoryFeatures : List Text , platforms : List < AArch64_Linux+: {} | ARMv5tel_Linux : {} | ARMv7l_Linux : {} | I686_Cygwin : {} | I686_Linux :+{} | MIPS64el_Linux : {} | PowerPC_Linux : {} | X86_64_Cygwin : {} |+X86_64_Darwin : {} | X86_64_FreeBSD : {} | X86_64_Linux : {} | X86_64_Solaris :+{} > , speedFactor : Natural , supportedFeatures : List Text , user : Optional+Text } ) → λ(y : Text) →+merge { None = x.host, Some = λ(user : Text) → "${user}@${x.host}" } x.user+++ " " ++ ( merge { Empty = λ(_ : {}) → "",+NonEmpty = λ(result : Text) → result } ( List/fold < AArch64_Linux : {} |+ARMv5tel_Linux : {} | ARMv7l_Linux : {} | I686_Cygwin : {} | I686_Linux : {} |+MIPS64el_Linux : {} | PowerPC_Linux : {} | X86_64_Cygwin : {} | X86_64_Darwin :+{} | X86_64_FreeBSD : {} | X86_64_Linux : {} | X86_64_Solaris : {} > x.platforms+< Empty : {} | NonEmpty : Text > ( λ ( element : < AArch64_Linux : {} |+ARMv5tel_Linux : {} | ARMv7l_Linux : {} | I686_Cygwin : {} | I686_Linux : {} |+MIPS64el_Linux : {} | PowerPC_Linux : {} | X86_64_Cygwin : {} | X86_64_Darwin :+{} | X86_64_FreeBSD : {} | X86_64_Linux : {} | X86_64_Solaris : {} > ) →+λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → <+NonEmpty : Text | Empty : {} >.NonEmpty ( merge { AArch64_Linux = λ(_ : {}) →+"aarch64-linux" , ARMv5tel_Linux = λ(_ : {}) → "armv5tel-linux" , ARMv7l_Linux =+λ(_ : {}) → "armv7l-linux" , I686_Cygwin = λ(_ : {}) → "i686-cygwin" ,+I686_Linux = λ(_ : {}) → "i686-linux" , MIPS64el_Linux = λ(_ : {}) →+"mips64el-linux" , PowerPC_Linux = λ(_ : {}) → "powerpc-linux" , X86_64_Cygwin =+λ(_ : {}) → "x86_64-cygwin" , X86_64_Darwin = λ(_ : {}) → "x86_64-darwin" ,+X86_64_FreeBSD = λ(_ : {}) → "x86_64-freebsd" , X86_64_Linux = λ(_ : {}) →+"x86_64-linux" , X86_64_Solaris = λ(_ : {}) → "x86_64-solaris" } element ) ,+NonEmpty = λ(result : Text) → < NonEmpty : Text | Empty : {} >.NonEmpty ( (+merge { AArch64_Linux = λ(_ : {}) → "aarch64-linux" , ARMv5tel_Linux = λ(_ : {})+→ "armv5tel-linux" , ARMv7l_Linux = λ(_ : {}) → "armv7l-linux" , I686_Cygwin =+λ(_ : {}) → "i686-cygwin" , I686_Linux = λ(_ : {}) → "i686-linux" ,+MIPS64el_Linux = λ(_ : {}) → "mips64el-linux" , PowerPC_Linux = λ(_ : {}) →+"powerpc-linux" , X86_64_Cygwin = λ(_ : {}) → "x86_64-cygwin" , X86_64_Darwin =+λ(_ : {}) → "x86_64-darwin" , X86_64_FreeBSD = λ(_ : {}) → "x86_64-freebsd" ,+X86_64_Linux = λ(_ : {}) → "x86_64-linux" , X86_64_Solaris = λ(_ : {}) →+"x86_64-solaris" } element ) ++ "," ++ result ) } status : < Empty : {} |+NonEmpty : Text > ) (< Empty : {} | NonEmpty : Text >.Empty {=}) ) : Text ) +++" " ++ x.key ++ " " ++ Integer/show (Natural/toInteger x.cores) ++ " " +++Integer/show (Natural/toInteger x.speedFactor) ++ " " ++ ( merge { Empty = λ(_ :+{}) → "", NonEmpty = λ(result : Text) → result } ( List/fold Text+x.supportedFeatures < Empty : {} | NonEmpty : Text > ( λ(element : Text) →+λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → <+NonEmpty : Text | Empty : {} >.NonEmpty element , NonEmpty = λ(result : Text) →+< NonEmpty : Text | Empty : {} >.NonEmpty (element ++ "," ++ result) } status :+< Empty : {} | NonEmpty : Text > ) (< Empty : {} | NonEmpty : Text >.Empty {=})+) : Text ) ++ " " ++ ( merge { Empty = λ(_ : {}) → "", NonEmpty = λ(result :+Text) → result } ( List/fold Text x.mandatoryFeatures < Empty : {} | NonEmpty :+Text > ( λ(element : Text) → λ(status : < Empty : {} | NonEmpty : Text >) →+merge { Empty = λ(_ : {}) → < NonEmpty : Text | Empty : {} >.NonEmpty element ,+NonEmpty = λ(result : Text) → < NonEmpty : Text | Empty : {} >.NonEmpty+(element ++ "," ++ result) } status : < Empty : {} | NonEmpty : Text > ) (<+Empty : {} | NonEmpty : Text+>.Empty {=}) ) : Text ) ++ "\n" ++ y ) ""
+ benchmark/parser/examples/issue108.dhallb view

binary file changed (absent → 3818 bytes)

+ benchmark/parser/examples/kubernetes.dhallb view

file too large to diff

+ benchmark/parser/examples/normalize/ChurchEval.dhall view
@@ -0,0 +1,22 @@++let Nat = ∀(N : Type) → (N → N) → N → N+let n2  = λ(N : Type) → λ(s : N → N) → λ(z : N) → s (s z)+let n5  = λ(N : Type) → λ(s : N → N) → λ(z : N) → s (s (s (s (s z))))++let mul =+  λ(a : Nat) → λ(b : Nat) → λ(N : Type) → λ(s : N → N) → λ(z : N) → a N (b N s) z++let add =+  λ(a : Nat) → λ(b : Nat) → λ(N : Type) → λ(s : N → N) → λ(z : N) → a N s (b N s z)++let n10   = mul n2 n5+let n100  = mul n10 n10+let n1k   = mul n10 n100+let n10k  = mul n100 n100+let n100k = mul n10 n10k+let n1M   = mul n10k n100+let n5M   = mul n1M n5+let n10M  = mul n1M n10+let n20M  = mul n10M n2++in n1M Natural (λ (x:Natural) → x + 1) 0
+ benchmark/parser/examples/normalize/FunCompose.dhall view
@@ -0,0 +1,18 @@++let compose+    : ∀(a : Type) → ∀(b : Type) → ∀(c : Type) → (a → b) → (b → c) → a → c+    =   λ(A : Type)+      → λ(B : Type)+      → λ(C : Type)+      → λ(f : A → B)+      → λ(g : B → C)+      → λ(x : A)+      → g (f x)++let composeN : ∀ (a : Type) → Natural → (a → a) → a → a+    = λ (a : Type)+	→ λ (n : Natural)+	→ λ (f : a → a)+	→ Natural/fold n (a → a) (compose a a a f) (λ (x : a) → x)++in composeN Natural 100000 (λ (x : Natural) → x + 1) 0
+ benchmark/parser/examples/normalize/ListBench.dhall view
@@ -0,0 +1,75 @@++let iterate+    =   λ(n : Natural)+      → λ(a : Type)+      → λ(f : a → a)+      → λ(x : a)+      → List/build+        a+        (   λ(list : Type)+          → λ(cons : a → list → list)+          → List/fold+            { index : Natural, value : {} }+            ( List/indexed+              {}+              ( List/build+                {}+                (   λ(list : Type)+                  → λ(cons : {} → list → list)+                  → Natural/fold n list (cons {=})+                )+              )+            )+            list+            (   λ(y : { index : Natural, value : {} })+              → cons (Natural/fold y.index a f x)+            )+        )++let countTo =+  λ (x : Natural)+  → iterate x Natural (λ (x : Natural) → x + 1) 0++let sum =+  λ (xs : List Natural)+  → List/fold Natural xs Natural (λ (x : Natural) → λ (acc : Natural) → x + acc) 0+++let map+        : ∀(a : Type) → ∀(b : Type) → (a → b) → List a → List b+        =   λ(a : Type)+          → λ(b : Type)+          → λ(f : a → b)+          → λ(xs : List a)+          → List/build+            b+            (   λ(list : Type)+              → λ(cons : b → list → list)+              → List/fold a xs list (λ(x : a) → cons (f x))+            )++let any+        : ∀(a : Type) → (a → Bool) → List a → Bool+        =   λ(a : Type)+          → λ(f : a → Bool)+          → λ(xs : List a)+          → List/fold a xs Bool (λ(x : a) → λ(r : Bool) → f x || r) False++let filter+        : ∀(a : Type) → (a → Bool) → List a → List a+        =   λ(a : Type)+          → λ(f : a → Bool)+          → λ(xs : List a)+          → List/build+            a+            (   λ(list : Type)+              → λ(cons : a → list → list)+              → List/fold+                a+                xs+                list+                (λ(x : a) → λ(xs : list) → if f x then cons x xs else xs)+            )++in sum (filter Natural Natural/even+     (map Natural Natural (λ(x:Natural) → x + 10) (countTo 1000)))
+ benchmark/parser/examples/normalize/ListBenchAlt.dhall view
@@ -0,0 +1,45 @@++let iterate =+    λ(n : Natural)+  → λ(a : Type)+  → λ(f : a → a)+  → λ(x : a)+  → (Natural/fold n+      (a → List a → {fst:a, snd:List a})+	  (λ (hyp : a → List a → {fst:a, snd:List a}) →+	   λ (x : a) → λ (xs : List a)+	   → let tup = hyp x xs+	     in {fst = f (tup.fst), snd = tup.snd # [tup.fst]})+	  (λ (x : a) → λ (xs : List a) → {fst=x, snd=xs})+	  x ([] : List a)).snd++let countTo =+  λ (x : Natural)+  → iterate x Natural (λ (x : Natural) → x + 1) 0++let sum =+  λ (xs : List Natural)+  → List/fold Natural xs Natural (λ (x : Natural) → λ (acc : Natural) → x + acc) 0++let map+  =   λ(a : Type)+    → λ(b : Type)+    → λ(f : a → b)+    → λ(xs : List a)+	→ List/fold a xs (List b) (λ (x : a) → λ (xs : List b) → [f x] # xs) ([] : List b)++let any+  =   λ(a : Type)+        → λ(f : a → Bool)+        → λ(xs : List a)+        → List/fold a xs Bool (λ(x : a) → λ(r : Bool) → f x || r) False++let filter+  =   λ(a : Type)+    → λ(f : a → Bool)+    → λ(xs : List a)+	→ List/fold a xs (List a)+	    (λ (x : a) → λ (xs : List a) → if f x then [x] # xs else xs) ([] : List a)++in sum (filter Natural Natural/even+     (map Natural Natural (λ(x:Natural) → x + 10) (countTo 1000)))
+ dhall-lang/Prelude/Bool/and view
@@ -0,0 +1,3 @@+  missing+    sha256:0b2114fa33cd76652e4360f012bc082718944fe4c5b28c975483178f8d9b0a6d+? ./and.dhall
+ dhall-lang/Prelude/Bool/and.dhall view
@@ -0,0 +1,14 @@+{-|+The `and` function returns `False` if there are any `False` elements in the+`List` and returns `True` otherwise+-}+let and+    : List Bool → Bool+    = λ(xs : List Bool) →+        List/fold Bool xs Bool (λ(l : Bool) → λ(r : Bool) → l && r) True++let example0 = assert : and [ True, False, True ] ≡ False++let example1 = assert : and ([] : List Bool) ≡ True++in  and
+ dhall-lang/Prelude/Bool/build view
@@ -0,0 +1,3 @@+  missing+    sha256:add7cb9acacac705410088d876a7e4488e046a7aded304f06c51accffd7f1b7b+? ./build.dhall
+ dhall-lang/Prelude/Bool/build.dhall view
@@ -0,0 +1,16 @@+--| `build` is the inverse of `fold`+let build+    : (∀(bool : Type) → ∀(true : bool) → ∀(false : bool) → bool) → Bool+    = λ(f : ∀(bool : Type) → ∀(true : bool) → ∀(false : bool) → bool) →+        f Bool True False++let example0 =+        assert+      : build (λ(bool : Type) → λ(true : bool) → λ(false : bool) → true) ≡ True++let example1 =+        assert+      :   build (λ(bool : Type) → λ(true : bool) → λ(false : bool) → false)+        ≡ False++in  build
+ dhall-lang/Prelude/Bool/equal.dhall view
@@ -0,0 +1,6 @@+--| Returns `True` if both arguments are equal and returns `False` otherwise+let equal+    : Bool -> Bool -> Bool+    = \(x : Bool) -> \(y : Bool) -> x == y++in  equal
+ dhall-lang/Prelude/Bool/even view
@@ -0,0 +1,3 @@+  missing+    sha256:72a05ee550636a3acb768360fa51ba0db0326763e0cf1ceb737f0f3607fc0fe5+? ./even.dhall
+ dhall-lang/Prelude/Bool/even.dhall view
@@ -0,0 +1,20 @@+{-|+Returns `True` if there are an even number of `False` elements in the list and+returns `False` otherwise.++This function is the `Monoid` for the `==` operation.+-}+let even+    : List Bool → Bool+    = λ(xs : List Bool) →+        List/fold Bool xs Bool (λ(x : Bool) → λ(y : Bool) → x == y) True++let example0 = assert : even [ False, True, False ] ≡ True++let example1 = assert : even [ False, True ] ≡ False++let example2 = assert : even [ False ] ≡ False++let example3 = assert : even ([] : List Bool) ≡ True++in  even
+ dhall-lang/Prelude/Bool/fold view
@@ -0,0 +1,3 @@+  missing+    sha256:39f60baf3950268c2e849e91dc6279ee41cd6b81892d54020d4fcd2ce30a96ae+? ./fold.dhall
+ dhall-lang/Prelude/Bool/fold.dhall view
@@ -0,0 +1,14 @@+--| `fold` is essentially the same as `if`/`then`/`else` except as a function+let fold+    : ∀(b : Bool) → ∀(bool : Type) → ∀(true : bool) → ∀(false : bool) → bool+    = λ(b : Bool) →+      λ(bool : Type) →+      λ(true : bool) →+      λ(false : bool) →+        if b then true else false++let example0 = assert : fold True Natural 0 1 ≡ 0++let example1 = assert : fold False Natural 0 1 ≡ 1++in  fold
+ dhall-lang/Prelude/Bool/not view
@@ -0,0 +1,3 @@+  missing+    sha256:723df402df24377d8a853afed08d9d69a0a6d86e2e5b2bac8960b0d4756c7dc4+? ./not.dhall
+ dhall-lang/Prelude/Bool/not.dhall view
@@ -0,0 +1,10 @@+--| Flip the value of a `Bool`+let not+    : Bool → Bool+    = λ(b : Bool) → b == False++let example0 = assert : not True ≡ False++let example1 = assert : not False ≡ True++in  not
+ dhall-lang/Prelude/Bool/odd view
@@ -0,0 +1,3 @@+  missing+    sha256:6360fca3a745de32bd186cc7b71487a6398cd47d5119064eae491872c41d1999+? ./odd.dhall
+ dhall-lang/Prelude/Bool/odd.dhall view
@@ -0,0 +1,20 @@+{-|+Returns `True` if there are an odd number of `True` elements in the list and+returns `False` otherwise.++This function is the `Monoid` for the `!=` operation.+-}+let odd+    : List Bool → Bool+    = λ(xs : List Bool) →+        List/fold Bool xs Bool (λ(x : Bool) → λ(y : Bool) → x != y) False++let example0 = assert : odd [ True, False, True ] ≡ False++let example1 = assert : odd [ True, False ] ≡ True++let example2 = assert : odd [ True ] ≡ True++let example3 = assert : odd ([] : List Bool) ≡ False++in  odd
+ dhall-lang/Prelude/Bool/or view
@@ -0,0 +1,3 @@+  missing+    sha256:5c50738e84e1c4fed8343ebd57608500e1b61ac1f502aa52d6d6edb5c20b99e4+? ./or.dhall
+ dhall-lang/Prelude/Bool/or.dhall view
@@ -0,0 +1,14 @@+{-|+The `or` function returns `True` if there are any `True` elements in the `List`+and returns `False` otherwise+-}+let or+    : List Bool → Bool+    = λ(xs : List Bool) →+        List/fold Bool xs Bool (λ(l : Bool) → λ(r : Bool) → l || r) False++let example0 = assert : or [ True, False, True ] ≡ True++let example1 = assert : or ([] : List Bool) ≡ False++in  or
+ dhall-lang/Prelude/Bool/package.dhall view
@@ -0,0 +1,37 @@+{ and =+      missing+        sha256:0b2114fa33cd76652e4360f012bc082718944fe4c5b28c975483178f8d9b0a6d+    ? ./and.dhall+, build =+      missing+        sha256:add7cb9acacac705410088d876a7e4488e046a7aded304f06c51accffd7f1b7b+    ? ./build.dhall+, equal =+      missing+        sha256:f0dc047ca14644c2a979bb126f2a3c6659ec770c66bd7beb70ae4a9d05815709+    ? ./equal.dhall+, even =+      missing+        sha256:72a05ee550636a3acb768360fa51ba0db0326763e0cf1ceb737f0f3607fc0fe5+    ? ./even.dhall+, fold =+      missing+        sha256:39f60baf3950268c2e849e91dc6279ee41cd6b81892d54020d4fcd2ce30a96ae+    ? ./fold.dhall+, not =+      missing+        sha256:723df402df24377d8a853afed08d9d69a0a6d86e2e5b2bac8960b0d4756c7dc4+    ? ./not.dhall+, odd =+      missing+        sha256:6360fca3a745de32bd186cc7b71487a6398cd47d5119064eae491872c41d1999+    ? ./odd.dhall+, or =+      missing+        sha256:5c50738e84e1c4fed8343ebd57608500e1b61ac1f502aa52d6d6edb5c20b99e4+    ? ./or.dhall+, show =+      missing+        sha256:f85f6d2d921c37a2122cb2e2f8a0170e305b699debd0e6df5ef3370d806b5f61+    ? ./show.dhall+}
+ dhall-lang/Prelude/Bool/show view
@@ -0,0 +1,3 @@+  missing+    sha256:f85f6d2d921c37a2122cb2e2f8a0170e305b699debd0e6df5ef3370d806b5f61+? ./show.dhall
+ dhall-lang/Prelude/Bool/show.dhall view
@@ -0,0 +1,13 @@+{-|+Render a `Bool` as `Text` using the same representation as Dhall source code+(i.e. beginning with a capital letter)+-}+let show+    : Bool → Text+    = λ(b : Bool) → if b then "True" else "False"++let example0 = assert : show True ≡ "True"++let example1 = assert : show False ≡ "False"++in  show
+ dhall-lang/Prelude/Date/package.dhall view
@@ -0,0 +1,5 @@+{ show =+      missing+        sha256:8a0eb9732cbc3c8f161b7cb05b183493befacc4728d2d9b7ee1384f19106a5ff+    ? ./show.dhall+}
+ dhall-lang/Prelude/Date/show.dhall view
@@ -0,0 +1,15 @@+{-+Render a `Date` as `Text` using the same representation as Dhall source code+(i.e. `YYYY-MM-DD`)+-}+let show+    : Date → Text+    = Date/show++let example0 = assert : show 2000-09-02 ≡ "2000-09-02"++let example1 = assert : show 9999-12-31 ≡ "9999-12-31"++let example2 = assert : show 0000-01-01 ≡ "0000-01-01"++in  show
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/Type.dhall view
@@ -0,0 +1,5 @@+{-|+A (total) set of access rights; See chmod(5) for an explanation of the flags.+For a partial set of of access rights see `Access`.+-}+{ execute : Bool, read : Bool, write : Bool }
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/intersect.dhall view
@@ -0,0 +1,69 @@+{-|+@intersect a b@ intesects the flags of the two `Mask`s @a@ and @b@. This+resembles the bitwise "and", i.e. the value of a flag is 'True' if and only if+it is set to 'True' in both @a@ and @b@. As a consequence @intersect a rwx == a@+and @intersect a none == none@ for all @a@.+-}+let Mask =+        missing+          sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+      ? ./Type.dhall++let intersect+    : Mask -> Mask -> Mask+    = \(m1 : Mask) ->+      \(m2 : Mask) ->+        { read = m1.read && m2.read+        , write = m1.write && m2.write+        , execute = m1.execute && m2.execute+        }++let example0 =+      let r =+              missing+                sha256:26d7fc8df6194a8051946eac88d0d7fecce690bff6819e69b3c74edf65ac027a+            ? ./r.dhall++      let w =+              missing+                sha256:9d10dfc672f61bbb2828c7be2121aae2502938c25adb47bb8cce3c40ba99821b+            ? ./w.dhall++      let x =+              missing+                sha256:a966fd88c05a5912a6daa8409e0c9e396f0a4810b51def1e1f62a95e18235f10+            ? ./x.dhall++      let rwx =+              missing+                sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+            ? ./rwx.dhall++      let none =+              missing+                sha256:db6c3bb734bb3288441f2664379706052943eaba35c021326a600d41ca766925+            ? ./none.dhall++      in  assert : intersect r (intersect w (intersect x rwx)) === none++let example1 =+      \(a : Mask) ->+        let rwx =+                missing+                  sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+              ? ./rwx.dhall++        in    assert+            :     intersect a rwx+              ===  { execute = a.execute, read = a.read, write = a.write }++let example2 =+      \(a : Mask) ->+        let none =+                missing+                  sha256:db6c3bb734bb3288441f2664379706052943eaba35c021326a600d41ca766925+              ? ./none.dhall++        in  assert : intersect a none === none++in  intersect
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/invert.dhall view
@@ -0,0 +1,48 @@+{-|+Inverts the flags set in a `Mask`.+-}+let Mask =+        missing+          sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+      ? ./Type.dhall++let Bool/not =+        missing+          sha256:723df402df24377d8a853afed08d9d69a0a6d86e2e5b2bac8960b0d4756c7dc4+      ? ../../../Bool/not.dhall++let invert+    : Mask -> Mask+    = \(m : Mask) ->+        { read = Bool/not m.read+        , write = Bool/not m.write+        , execute = Bool/not m.execute+        }++let example0 =+      let none =+              missing+                sha256:db6c3bb734bb3288441f2664379706052943eaba35c021326a600d41ca766925+            ? ./none.dhall++      let rwx =+              missing+                sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+            ? ./rwx.dhall++      in  assert : invert rwx === none++let example1 =+      let none =+              missing+                sha256:db6c3bb734bb3288441f2664379706052943eaba35c021326a600d41ca766925+            ? ./none.dhall++      let rwx =+              missing+                sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+            ? ./rwx.dhall++      in  assert : invert none === rwx++in  invert
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/none.dhall view
@@ -0,0 +1,4 @@+  { read = False, write = False, execute = False }+:   missing+      sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+  ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/package.dhall view
@@ -0,0 +1,53 @@+{ Type =+      missing+        sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+    ? ./Type.dhall+, intersect =+      missing+        sha256:7c7dab3e305f43cba556e0778b5a797cf8e9b1d1a6c6f6fe0ea311c329919663+    ? ./intersect.dhall+, invert =+      missing+        sha256:8807fb02f694fe2117f8a7f794e5afbb967ec36eac3405184bf9232c33cdd830+    ? ./invert.dhall+, none =+      missing+        sha256:db6c3bb734bb3288441f2664379706052943eaba35c021326a600d41ca766925+    ? ./none.dhall+, r =+      missing+        sha256:26d7fc8df6194a8051946eac88d0d7fecce690bff6819e69b3c74edf65ac027a+    ? ./r.dhall+, rw =+      missing+        sha256:c3cce19f462b841e64adafbdf2963699a0031f5fc08b041c8ad364483c544d8b+    ? ./rw.dhall+, rwx =+      missing+        sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+    ? ./rwx.dhall+, rx =+      missing+        sha256:d9beaa853c0de6984c3e5b0e313b573942900f8024fd9aaad743d73df458dc5e+    ? ./rx.dhall+, toAccess =+      missing+        sha256:78fe016f0273b2551c8590da71bf204cc26d6879c6b84622d4d8ad5624328438+    ? ./toAccess.dhall+, toAccessWith =+      missing+        sha256:814ab74ad292c121620a1f468837d4a5473323423bf68c1bceca69e7b3c59077+    ? ./toAccessWith.dhall+, union =+      missing+        sha256:b40c4cbb266991e3f764af075e9db544b59c16b3d9aa680c0cf6cb7552da191f+    ? ./union.dhall+, w =+      missing+        sha256:9d10dfc672f61bbb2828c7be2121aae2502938c25adb47bb8cce3c40ba99821b+    ? ./w.dhall+, x =+      missing+        sha256:a966fd88c05a5912a6daa8409e0c9e396f0a4810b51def1e1f62a95e18235f10+    ? ./x.dhall+}
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/r.dhall view
@@ -0,0 +1,4 @@+  { read = True, write = False, execute = False }+:   missing+      sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+  ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/rw.dhall view
@@ -0,0 +1,4 @@+  { read = True, write = True, execute = False }+:   missing+      sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+  ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/rwx.dhall view
@@ -0,0 +1,4 @@+  { read = True, write = True, execute = True }+:   missing+      sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+  ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/rx.dhall view
@@ -0,0 +1,4 @@+  { read = True, write = False, execute = True }+:   missing+      sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+  ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/toAccess.dhall view
@@ -0,0 +1,20 @@+{-|+Convert a `Mask` value to an `Access` value. For a partial conversion see+`toAccessWith`.+-}+let Access =+        missing+          sha256:50689ae80f8c8dcd6e7af33fbc20ea871afb92ec87104253cdbae01f838f6c38+      ? ../Type.dhall++let Mask =+        missing+          sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+      ? ./Type.dhall++let toAccess+    : Mask -> Access+    = \(m : Mask) ->+        { execute = Some m.execute, read = Some m.read, write = Some m.write }++in  toAccess
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/toAccessWith.dhall view
@@ -0,0 +1,42 @@+{-|+@toAccessWith x m@ converts some fields of a `Mask` @m@ to an `Access` setting:+If the respective field is set in the first `Mask` @x@, then the flag will be+set to the flags value given in @m@. Otherwise, the value set in @m@ is ignored+and the value of the flag in the result is `None`.++For a motivation of this function see the documenation on `toModeWith`.+-}+let Access =+        missing+          sha256:50689ae80f8c8dcd6e7af33fbc20ea871afb92ec87104253cdbae01f838f6c38+      ? ../Type.dhall++let Mask =+        missing+          sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+      ? ./Type.dhall++let toAccessWith+    : Mask -> Mask -> Access+    = \(set : Mask) ->+      \(m : Mask) ->+        { execute = if set.execute then Some m.execute else None Bool+        , read = if set.read then Some m.read else None Bool+        , write = if set.write then Some m.write else None Bool+        }++let example0 =+      \(a : Mask) ->+        let Access/none =+                missing+                  sha256:955a2eed689139c811d4b9ef3dd8d0c484392b18c3bb8752c59fd69dbdaf4881+              ? ../none.dhall++        let none =+                missing+                  sha256:db6c3bb734bb3288441f2664379706052943eaba35c021326a600d41ca766925+              ? ./none.dhall++        in  assert : toAccessWith none a === Access/none++in  toAccessWith
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/union.dhall view
@@ -0,0 +1,64 @@+{-|+@union a b@ combines the flags of the two `Mask`s @a@ and @b@. This resembles+the bitwise "or", i.e. the value of a flag is 'True' if it is set to 'True' in+either @a@ and @b@. As a consequence @union a rwx == rwx@ and+@union a none == a@ for all @a@.+-}+let Mask =+        missing+          sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+      ? ./Type.dhall++let union+    : Mask -> Mask -> Mask+    = \(m1 : Mask) ->+      \(m2 : Mask) ->+        { read = m1.read || m2.read+        , write = m1.write || m2.write+        , execute = m1.execute || m2.execute+        }++let example0 =+      let r =+              missing+                sha256:26d7fc8df6194a8051946eac88d0d7fecce690bff6819e69b3c74edf65ac027a+            ? ./r.dhall++      let w =+              missing+                sha256:9d10dfc672f61bbb2828c7be2121aae2502938c25adb47bb8cce3c40ba99821b+            ? ./w.dhall++      let x =+              missing+                sha256:a966fd88c05a5912a6daa8409e0c9e396f0a4810b51def1e1f62a95e18235f10+            ? ./x.dhall++      let rwx =+              missing+                sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+            ? ./rwx.dhall++      in  assert : union r (union w x) === rwx++let example1 =+      \(a : Mask) ->+        let rwx =+                missing+                  sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+              ? ./rwx.dhall++        in  assert : union a rwx === rwx++let example1 =+      \(a : Mask) ->+        let none =+                missing+                  sha256:db6c3bb734bb3288441f2664379706052943eaba35c021326a600d41ca766925+              ? ./none.dhall++        in    assert+            :     union a none+              ===  { execute = a.execute, read = a.read, write = a.write }++in  union
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/w.dhall view
@@ -0,0 +1,4 @@+  { read = False, write = True, execute = False }+:   missing+      sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+  ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Access/Mask/x.dhall view
@@ -0,0 +1,4 @@+  { read = False, write = False, execute = True }+:   missing+      sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+  ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Access/Type.dhall view
@@ -0,0 +1,5 @@+{-|+A (partial) set of access rights; See chmod(5) for an explanation of the flags.+For a total set of access rights see `Mask`.+-}+{ execute : Optional Bool, read : Optional Bool, write : Optional Bool }
+ dhall-lang/Prelude/DirectoryTree/Access/equal.dhall view
@@ -0,0 +1,29 @@+{-|+`equal` checks if two `Access` settings are equal.+-}+let Access =+        missing+          sha256:50689ae80f8c8dcd6e7af33fbc20ea871afb92ec87104253cdbae01f838f6c38+      ? ./Type.dhall++let Bool/equal =+        missing+          sha256:f0dc047ca14644c2a979bb126f2a3c6659ec770c66bd7beb70ae4a9d05815709+      ? ../../Bool/equal.dhall++let Optional/equal =+        missing+          sha256:5411888399fe9c6720f7f3b59caf5eff3e8e8c30402d09f34e46a4457649a35a+      ? ../../Optional/equal.dhall++let f+    : Optional Bool -> Optional Bool -> Bool+    = Optional/equal Bool Bool/equal++let equal+    : Access -> Access -> Bool+    = \(a1 : Access) ->+      \(a2 : Access) ->+        f a1.execute a2.execute && f a1.read a2.read && f a1.write a2.write++in  equal
+ dhall-lang/Prelude/DirectoryTree/Access/none.dhall view
@@ -0,0 +1,4 @@+  { read = None Bool, write = None Bool, execute = None Bool }+:   missing+      sha256:50689ae80f8c8dcd6e7af33fbc20ea871afb92ec87104253cdbae01f838f6c38+  ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Access/package.dhall view
@@ -0,0 +1,17 @@+{ Mask =+      missing+        sha256:ed736de51ea15a2ef671eaa7219dfbf3138bb52acfd0ae17894acf2ec4b06369+    ? ./Mask/package.dhall+, Type =+      missing+        sha256:50689ae80f8c8dcd6e7af33fbc20ea871afb92ec87104253cdbae01f838f6c38+    ? ./Type.dhall+, equal =+      missing+        sha256:5fa90f55505780a7be942275d6bbb2b1f1fb7857364332ed732a0241c2165e53+    ? ./equal.dhall+, schema =+      missing+        sha256:7d33a584a42a5d92411d5ca623e27ccb397762905be86ecfd01b106719fae690+    ? ./schema.dhall+}
+ dhall-lang/Prelude/DirectoryTree/Access/schema.dhall view
@@ -0,0 +1,12 @@+{-|+A schema for blank access rights.+-}+{ Type =+      missing+        sha256:50689ae80f8c8dcd6e7af33fbc20ea871afb92ec87104253cdbae01f838f6c38+    ? ./Type.dhall+, default =+      missing+        sha256:955a2eed689139c811d4b9ef3dd8d0c484392b18c3bb8752c59fd69dbdaf4881+    ? ./none.dhall+}
+ dhall-lang/Prelude/DirectoryTree/Entry/BinaryFileEntry.dhall view
@@ -0,0 +1,6 @@+let Entry =+        missing+          sha256:75148ae19175750e38705e11cda8dcc775b2ac08f22518ff2ef3f33a6273ef15+      ? ./Type.dhall++in  Entry Bytes
+ dhall-lang/Prelude/DirectoryTree/Entry/DirectoryEntry.dhall view
@@ -0,0 +1,6 @@+let Entry =+        missing+          sha256:75148ae19175750e38705e11cda8dcc775b2ac08f22518ff2ef3f33a6273ef15+      ? ./Type.dhall++in  \(tree : Type) -> Entry (List tree)
+ dhall-lang/Prelude/DirectoryTree/Entry/Metadata.dhall view
@@ -0,0 +1,24 @@+{-|+An `Entry` without content. That in turn implies that the type of the entry+(i.e. whether it is a file or a directory) is not (yet) fixed as well.+-}+let User =+        missing+          sha256:8b25916612d2c9b17130d16b55c6bdb085dd118e692f72bf351a83b1d0ac8833+      ? ../User/Type.dhall++let Group =+        missing+          sha256:83e6e8846153d94abf6f879808c94f5cdba3f486cc9e392eb6124b1dc67368cf+      ? ../Group/Type.dhall++let Mode =+        missing+          sha256:f05819ec2145e7dabf4aa167338bee6d326aabd81355dcf0b078e358bd34ec60+      ? ../Mode/Type.dhall++in  { name : Text+    , user : Optional User+    , group : Optional Group+    , mode : Optional Mode+    }
+ dhall-lang/Prelude/DirectoryTree/Entry/TextFileEntry.dhall view
@@ -0,0 +1,6 @@+let Entry =+        missing+          sha256:75148ae19175750e38705e11cda8dcc775b2ac08f22518ff2ef3f33a6273ef15+      ? ./Type.dhall++in  Entry Text
+ dhall-lang/Prelude/DirectoryTree/Entry/Type.dhall view
@@ -0,0 +1,6 @@+let Metadata =+        missing+          sha256:8c240a00094238a73904af63ac0924b3e6aba1655312f20a2a27f88554e2febe+      ? ./Metadata.dhall++in  \(content : Type) -> Metadata //\\ { content : content }
+ dhall-lang/Prelude/DirectoryTree/Entry/binary-file.dhall view
@@ -0,0 +1,6 @@+let Entry =+        missing+          sha256:742610b2a13e55ae6e344b54aa8a7ee1bfec8e8b313a1132eae9286309b520e6+      ? ./entry.dhall++in  Entry Bytes
+ dhall-lang/Prelude/DirectoryTree/Entry/directory.dhall view
@@ -0,0 +1,6 @@+let Entry =+        missing+          sha256:742610b2a13e55ae6e344b54aa8a7ee1bfec8e8b313a1132eae9286309b520e6+      ? ./entry.dhall++in  \(tree : Type) -> Entry (List tree)
+ dhall-lang/Prelude/DirectoryTree/Entry/entry.dhall view
@@ -0,0 +1,24 @@+let Entry =+        missing+          sha256:75148ae19175750e38705e11cda8dcc775b2ac08f22518ff2ef3f33a6273ef15+      ? ./Type.dhall++let User =+        missing+          sha256:8b25916612d2c9b17130d16b55c6bdb085dd118e692f72bf351a83b1d0ac8833+      ? ../User/Type.dhall++let Group =+        missing+          sha256:83e6e8846153d94abf6f879808c94f5cdba3f486cc9e392eb6124b1dc67368cf+      ? ../Group/Type.dhall++let Mode =+        missing+          sha256:f05819ec2145e7dabf4aa167338bee6d326aabd81355dcf0b078e358bd34ec60+      ? ../Mode/Type.dhall++in  \(content : Type) ->+      { Type = Entry content+      , default = { user = None User, group = None Group, mode = None Mode }+      }
+ dhall-lang/Prelude/DirectoryTree/Entry/package.dhall view
@@ -0,0 +1,37 @@+{ BinaryFileEntry =+      missing+        sha256:f027db2893f6f38bbe6d868a91f22de530e85407237f00b147427c87d32bf55c+    ? ./BinaryFileEntry.dhall+, DirectoryEntry =+      missing+        sha256:163a4536fdd05ce122d793ceda01d03fcffb29463817ae8b7b5601bf4a06ce6e+    ? ./DirectoryEntry.dhall+, Metadata =+      missing+        sha256:8c240a00094238a73904af63ac0924b3e6aba1655312f20a2a27f88554e2febe+    ? ./Metadata.dhall+, TextFileEntry =+      missing+        sha256:23a8cb29d96aeb623501519d9a62c5c49659e8d1c30b4ae4f2399809e3fd3a01+    ? ./TextFileEntry.dhall+, Type =+      missing+        sha256:75148ae19175750e38705e11cda8dcc775b2ac08f22518ff2ef3f33a6273ef15+    ? ./Type.dhall+, binary-file =+      missing+        sha256:bd49df43268c259e3d0bef995917c3ab517ae7b98bf1faac8f4a7e8a602e3465+    ? ./binary-file.dhall+, directory =+      missing+        sha256:0bee17310a21efa5b06f139b6731fdcee4f9e0245ef711c2b0127b8938dfed2e+    ? ./directory.dhall+, entry =+      missing+        sha256:742610b2a13e55ae6e344b54aa8a7ee1bfec8e8b313a1132eae9286309b520e6+    ? ./entry.dhall+, text-file =+      missing+        sha256:c5d76fd43216668d03df9945183fe7b3c55486aedcc77324c3372bd63e283b78+    ? ./text-file.dhall+}
+ dhall-lang/Prelude/DirectoryTree/Entry/text-file.dhall view
@@ -0,0 +1,6 @@+let Entry =+        missing+          sha256:742610b2a13e55ae6e344b54aa8a7ee1bfec8e8b313a1132eae9286309b520e6+      ? ./entry.dhall++in  Entry Text
+ dhall-lang/Prelude/DirectoryTree/Group/Type.dhall view
@@ -0,0 +1,1 @@+< GroupId : Natural | GroupName : Text >
+ dhall-lang/Prelude/DirectoryTree/Group/id.dhall view
@@ -0,0 +1,6 @@+let Group =+        missing+          sha256:83e6e8846153d94abf6f879808c94f5cdba3f486cc9e392eb6124b1dc67368cf+      ? ./Type.dhall++in  Group.GroupId
+ dhall-lang/Prelude/DirectoryTree/Group/name.dhall view
@@ -0,0 +1,6 @@+let Group =+        missing+          sha256:83e6e8846153d94abf6f879808c94f5cdba3f486cc9e392eb6124b1dc67368cf+      ? ./Type.dhall++in  Group.GroupName
+ dhall-lang/Prelude/DirectoryTree/Group/package.dhall view
@@ -0,0 +1,13 @@+{ Type =+      missing+        sha256:83e6e8846153d94abf6f879808c94f5cdba3f486cc9e392eb6124b1dc67368cf+    ? ./Type.dhall+, id =+      missing+        sha256:2bf9e546f56a583243d419a652caba16ca4053df9ccb3c5b242506d86806944b+    ? ./id.dhall+, name =+      missing+        sha256:51ac5c407f2939ab0c80bf2896d292ee6049bd8ba10acda0af327a3777f2205d+    ? ./name.dhall+}
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/Type.dhall view
@@ -0,0 +1,10 @@+{-|+A complete mode with all access rights specified explicitely. For an incomplete+mode where some access rights might not be set see `Mode`.+-}+let Access/Mask =+        missing+          sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+      ? ../../Access/Mask/Type.dhall++in  { user : Access/Mask, group : Access/Mask, other : Access/Mask }
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/all.dhall view
@@ -0,0 +1,9 @@+{-|+Permissions with all flags set: rwxrwxrwx+-}+let rwx =+        missing+          sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+      ? ../../Access/Mask/rwx.dhall++in  { user = rwx, group = rwx, other = rwx }
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/directory.dhall view
@@ -0,0 +1,17 @@+{-|+Permissions commonly used for directories: rwxr-xr-x+-}+let rwx =+        missing+          sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+      ? ../../Access/Mask/rwx.dhall++let rx =+        missing+          sha256:d9beaa853c0de6984c3e5b0e313b573942900f8024fd9aaad743d73df458dc5e+      ? ../../Access/Mask/rx.dhall++in    { user = rwx, group = rx, other = rx }+    :   missing+          sha256:4f97762058f24053e03997565a78800a5a2586159deaa265a4ee84a3d94ad471+      ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/executable.dhall view
@@ -0,0 +1,17 @@+{-|+Permissions commonly used for executable files: rwxr-xr-x+-}+let rwx =+        missing+          sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+      ? ../../Access/Mask/rwx.dhall++let rx =+        missing+          sha256:d9beaa853c0de6984c3e5b0e313b573942900f8024fd9aaad743d73df458dc5e+      ? ../../Access/Mask/rx.dhall++in    { user = rwx, group = rx, other = rx }+    :   missing+          sha256:4f97762058f24053e03997565a78800a5a2586159deaa265a4ee84a3d94ad471+      ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/file.dhall view
@@ -0,0 +1,17 @@+{-|+Permissions commonly used for regular files: rw-r--r--+-}+let r =+        missing+          sha256:26d7fc8df6194a8051946eac88d0d7fecce690bff6819e69b3c74edf65ac027a+      ? ../../Access/Mask/r.dhall++let rw =+        missing+          sha256:c3cce19f462b841e64adafbdf2963699a0031f5fc08b041c8ad364483c544d8b+      ? ../../Access/Mask/rw.dhall++in    { user = rw, group = r, other = r }+    :   missing+          sha256:4f97762058f24053e03997565a78800a5a2586159deaa265a4ee84a3d94ad471+      ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/group.dhall view
@@ -0,0 +1,14 @@+{-|+Permissions with group flags set: ---rwx---+-}+let rwx =+        missing+          sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+      ? ../../Access/Mask/rwx.dhall++let none =+        missing+          sha256:db6c3bb734bb3288441f2664379706052943eaba35c021326a600d41ca766925+      ? ../../Access/Mask/none.dhall++in  { user = none, group = rwx, other = none }
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/intersect.dhall view
@@ -0,0 +1,24 @@+{-|+Calculates the intersection of the access rights of two `Mask`s using+`Access/intersect`.+-}+let Mask =+        missing+          sha256:4f97762058f24053e03997565a78800a5a2586159deaa265a4ee84a3d94ad471+      ? ./Type.dhall++let Access/intersect =+        missing+          sha256:7c7dab3e305f43cba556e0778b5a797cf8e9b1d1a6c6f6fe0ea311c329919663+      ? ../../Access/Mask/intersect.dhall++let intersect+    : Mask -> Mask -> Mask+    = \(m1 : Mask) ->+      \(m2 : Mask) ->+        { user = Access/intersect m1.user m2.user+        , group = Access/intersect m1.group m2.group+        , other = Access/intersect m1.other m2.other+        }++in  intersect
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/invert.dhall view
@@ -0,0 +1,22 @@+{-|+Inverts each access right set in a `Mask` using `Access/invert`.+-}+let Mask =+        missing+          sha256:4f97762058f24053e03997565a78800a5a2586159deaa265a4ee84a3d94ad471+      ? ./Type.dhall++let Access/invert =+        missing+          sha256:8807fb02f694fe2117f8a7f794e5afbb967ec36eac3405184bf9232c33cdd830+      ? ../../Access/Mask/invert.dhall++let invert+    : Mask -> Mask+    = \(m : Mask) ->+        { user = Access/invert m.user+        , group = Access/invert m.group+        , other = Access/invert m.other+        }++in  invert
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/none.dhall view
@@ -0,0 +1,12 @@+{-|+Permissions with no flags set: ---------+-}+let none =+        missing+          sha256:db6c3bb734bb3288441f2664379706052943eaba35c021326a600d41ca766925+      ? ../../Access/Mask/none.dhall++in    { user = none, group = none, other = none }+    :   missing+          sha256:4f97762058f24053e03997565a78800a5a2586159deaa265a4ee84a3d94ad471+      ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/other.dhall view
@@ -0,0 +1,14 @@+{-|+Permissions with other flags set: ------rwx+-}+let rwx =+        missing+          sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+      ? ../../Access/Mask/rwx.dhall++let none =+        missing+          sha256:db6c3bb734bb3288441f2664379706052943eaba35c021326a600d41ca766925+      ? ../../Access/Mask/none.dhall++in  { user = none, group = none, other = rwx }
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/package.dhall view
@@ -0,0 +1,41 @@+{ Type =+      missing+        sha256:4f97762058f24053e03997565a78800a5a2586159deaa265a4ee84a3d94ad471+    ? ./Type.dhall+, directory =+      missing+        sha256:a43f235f0caa25c7cabd89ac5d77e466e0c0ebf3339046993c18e481930243fd+    ? ./directory.dhall+, executable =+      missing+        sha256:a43f235f0caa25c7cabd89ac5d77e466e0c0ebf3339046993c18e481930243fd+    ? ./executable.dhall+, file =+      missing+        sha256:32d34228d48a707996272d1c9681171ddcd6651f72eeb3de9727d1c26ba99df3+    ? ./file.dhall+, intersect =+      missing+        sha256:146be962523ef619d3a250699f977b69c3e5f6c24b975453f351c0e807266fc8+    ? ./intersect.dhall+, invert =+      missing+        sha256:07a13d8c233d0a9fd6b3a11475987c10619072fec882c96bc5499bfb3c01e9b2+    ? ./invert.dhall+, none =+      missing+        sha256:7cac21e2b72cadf3ee0bf10680df4902ca73b6ee070219df5eac1a24cd66ccdf+    ? ./none.dhall+, toMode =+      missing+        sha256:af2b0dab799374afa0a2f28551446760ff29f4697c200da0a8b0a8def7feee2a+    ? ./toMode.dhall+, toModeWith =+      missing+        sha256:b92327bec9141cc1a55bc3f11ae2584af0883b94fe2513376fc40f1da5ade9b2+    ? ./toModeWith.dhall+, union =+      missing+        sha256:3bb32fc6ea21f661571e46d90e450e0340b2f2b65482ba7bd1a30514e1b39fc2+    ? ./union.dhall+}
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/toMode.dhall view
@@ -0,0 +1,28 @@+{-|+Convert a `Mask` value to a `Mode` value. For a partial conversion see+`toModeWith`.+-}+let Mode =+        missing+          sha256:f05819ec2145e7dabf4aa167338bee6d326aabd81355dcf0b078e358bd34ec60+      ? ../Type.dhall++let Mask =+        missing+          sha256:4f97762058f24053e03997565a78800a5a2586159deaa265a4ee84a3d94ad471+      ? ./Type.dhall++let Access/toAccess =+        missing+          sha256:78fe016f0273b2551c8590da71bf204cc26d6879c6b84622d4d8ad5624328438+      ? ../../Access/Mask/toAccess.dhall++let toMode+    : Mask -> Mode+    = \(m : Mask) ->+        { user = Some (Access/toAccess m.user)+        , group = Some (Access/toAccess m.group)+        , other = Some (Access/toAccess m.other)+        }++in  toMode
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/toModeWith.dhall view
@@ -0,0 +1,149 @@+{-|+@toModeWith x m@ converts some fields of a `Mask` @m@ to a `Mode`: If the+respective field is set in the first `Mask` @x@, then the flag will be set to+the flags value given in @m@. Otherwise, the value set in @m@ is ignored and the+value of the flag in the result is `None`.++The function is motivated by the following use case:+Alice has her umask set to 022 and new files will have permissions set to+rw-r--r--. Bob has the umask set to 077, hence newly created files will have+rw------- permissions. Now Eve distributes Dhall code writing a file with the+following mode to the filesystem:+```dhall+let mask = ./other.dhall++let permissions = ./all.dhall++in+toModeWith mask permissions+```+The written file will have rw-r--rwx permissions for Alice and rw----rwx+permissions for Bob as the `toModeWith mask` produces a `Mode` that will only+apply the permissions for the 'other' part.+-}+let Access =+        missing+          sha256:50689ae80f8c8dcd6e7af33fbc20ea871afb92ec87104253cdbae01f838f6c38+      ? ../../Access/Type.dhall++let Access/Mask =+        missing+          sha256:c0fa7626b69e117086439a7b4ee15d1a80e16e38fe2ccc13f55e6dd26030b4df+      ? ../../Access/Mask/Type.dhall++let Mode =+        missing+          sha256:f05819ec2145e7dabf4aa167338bee6d326aabd81355dcf0b078e358bd34ec60+      ? ../Type.dhall++let Mask =+        missing+          sha256:4f97762058f24053e03997565a78800a5a2586159deaa265a4ee84a3d94ad471+      ? ./Type.dhall++let Access/equal =+        missing+          sha256:5fa90f55505780a7be942275d6bbb2b1f1fb7857364332ed732a0241c2165e53+      ? ../../Access/equal.dhall++let Access/toAccessWith =+        missing+          sha256:814ab74ad292c121620a1f468837d4a5473323423bf68c1bceca69e7b3c59077+      ? ../../Access/Mask/toAccessWith.dhall++let f+    : Access/Mask -> Access/Mask -> Optional Access+    = \(set : Access/Mask) ->+      \(m : Access/Mask) ->+        let x = Access/toAccessWith set m++        in  if    Access/equal+                    { execute = None Bool, read = None Bool, write = None Bool }+                    x+            then  None Access+            else  Some x++let toModeWith+    : Mask -> Mask -> Mode+    = \(set : Mask) ->+      \(m : Mask) ->+        { user = f set.user m.user+        , group = f set.group m.group+        , other = f set.other m.other+        }++let example0 =+      \(a : Mask) ->+        let none =+                missing+                  sha256:7cac21e2b72cadf3ee0bf10680df4902ca73b6ee070219df5eac1a24cd66ccdf+              ? ./none.dhall++        let Mode/none =+                missing+                  sha256:0ed46da7e6acbdff9e4c9e27a9f2770075a7cd6cb6bb565765c62093df1b5563+              ? ../none.dhall++        in  assert : toModeWith none a === Mode/none++let example1 =+      \(a : Mask) ->+        let toMode =+                missing+                  sha256:af2b0dab799374afa0a2f28551446760ff29f4697c200da0a8b0a8def7feee2a+              ? ./toMode.dhall++        let all =+                missing+                  sha256:758415eca8dfee675dfef93ace9af82abb36bb3319b8e6295537ed18f9b5d3dd+              ? ./all.dhall++        in  assert : toModeWith all a === toMode a++let example2 =+      let mask =+              missing+                sha256:94bf82678d8d1c4f370a96f3831d3ad4464fbee508ffb37e93a479a1d9ee25cf+            ? ./other.dhall++      let permissions =+              missing+                sha256:758415eca8dfee675dfef93ace9af82abb36bb3319b8e6295537ed18f9b5d3dd+            ? ./all.dhall++      let rwx = { read = Some True, write = Some True, execute = Some True }++      in    assert+          :     toModeWith mask permissions+            ===  { user = None Access, group = None Access, other = Some rwx }++let example3 =+      let union =+              missing+                sha256:3bb32fc6ea21f661571e46d90e450e0340b2f2b65482ba7bd1a30514e1b39fc2+            ? ./union.dhall++      let group =+              missing+                sha256:faa567630372f77bb5cd2fa4fe7cb4760d2f9f79e35df80917e6e0064decf7cf+            ? ./group.dhall++      let other =+              missing+                sha256:94bf82678d8d1c4f370a96f3831d3ad4464fbee508ffb37e93a479a1d9ee25cf+            ? ./other.dhall++      let permissions =+              missing+                sha256:758415eca8dfee675dfef93ace9af82abb36bb3319b8e6295537ed18f9b5d3dd+            ? ./all.dhall++      let mask = union group other++      let rwx = { read = Some True, write = Some True, execute = Some True }++      in    assert+          :     toModeWith mask permissions+            ===  { user = None Access, group = Some rwx, other = Some rwx }++in  toModeWith
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/union.dhall view
@@ -0,0 +1,24 @@+{-|+Calculates the union of the access rights set by both `Mask`s using+`Access/union`.+-}+let Mask =+        missing+          sha256:4f97762058f24053e03997565a78800a5a2586159deaa265a4ee84a3d94ad471+      ? ./Type.dhall++let Access/union =+        missing+          sha256:b40c4cbb266991e3f764af075e9db544b59c16b3d9aa680c0cf6cb7552da191f+      ? ../../Access/Mask/union.dhall++let union+    : Mask -> Mask -> Mask+    = \(m1 : Mask) ->+      \(m2 : Mask) ->+        { user = Access/union m1.user m2.user+        , group = Access/union m1.group m2.group+        , other = Access/union m1.other m2.other+        }++in  union
+ dhall-lang/Prelude/DirectoryTree/Mode/Mask/user.dhall view
@@ -0,0 +1,14 @@+{-|+Permissions with all user flags set: rwx------+-}+let rwx =+        missing+          sha256:cafda16b1ecc0d2f9a63f3aab229a02e18aebb054283c73e50517f1e3727cd27+      ? ../../Access/Mask/rwx.dhall++let none =+        missing+          sha256:db6c3bb734bb3288441f2664379706052943eaba35c021326a600d41ca766925+      ? ../../Access/Mask/none.dhall++in  { user = rwx, group = none, other = none }
+ dhall-lang/Prelude/DirectoryTree/Mode/Type.dhall view
@@ -0,0 +1,10 @@+{-|+An incomplete mode where some access rights might not be set explicitely. For a+complete mode with all access rights specified explicitely see `Mask`.+-}+let Access =+        missing+          sha256:50689ae80f8c8dcd6e7af33fbc20ea871afb92ec87104253cdbae01f838f6c38+      ? ../Access/Type.dhall++in  { user : Optional Access, group : Optional Access, other : Optional Access }
+ dhall-lang/Prelude/DirectoryTree/Mode/equal.dhall view
@@ -0,0 +1,34 @@+{-|+`equal` checks if two `Mode`s are equal.+-}+let Access =+        missing+          sha256:50689ae80f8c8dcd6e7af33fbc20ea871afb92ec87104253cdbae01f838f6c38+      ? ../Access/Type.dhall++let Mode =+        missing+          sha256:f05819ec2145e7dabf4aa167338bee6d326aabd81355dcf0b078e358bd34ec60+      ? ./Type.dhall++let Access/equal =+        missing+          sha256:5fa90f55505780a7be942275d6bbb2b1f1fb7857364332ed732a0241c2165e53+      ? ../Access/equal.dhall++let Optional/equal =+        missing+          sha256:5411888399fe9c6720f7f3b59caf5eff3e8e8c30402d09f34e46a4457649a35a+      ? ../../Optional/equal.dhall++let f+    : Optional Access -> Optional Access -> Bool+    = Optional/equal Access Access/equal++let equal+    : Mode -> Mode -> Bool+    = \(m1 : Mode) ->+      \(m2 : Mode) ->+        f m1.user m2.user && f m1.group m2.group && f m1.other m2.other++in  equal
+ dhall-lang/Prelude/DirectoryTree/Mode/none.dhall view
@@ -0,0 +1,9 @@+let Access =+        missing+          sha256:50689ae80f8c8dcd6e7af33fbc20ea871afb92ec87104253cdbae01f838f6c38+      ? ../Access/Type.dhall++in    { user = None Access, group = None Access, other = None Access }+    :   missing+          sha256:f05819ec2145e7dabf4aa167338bee6d326aabd81355dcf0b078e358bd34ec60+      ? ./Type.dhall
+ dhall-lang/Prelude/DirectoryTree/Mode/package.dhall view
@@ -0,0 +1,17 @@+{ Mask =+      missing+        sha256:ce2c7ac1b81c2184b906cdd07c79936ba0eaf0445f1e383f53fd18d688ee7044+    ? ./Mask/package.dhall+, Type =+      missing+        sha256:f05819ec2145e7dabf4aa167338bee6d326aabd81355dcf0b078e358bd34ec60+    ? ./Type.dhall+, equal =+      missing+        sha256:32fee2d3a56a2162d6c98fb63d47d31f98b352f22cc60c8b506011c9b5230e56+    ? ./equal.dhall+, schema =+      missing+        sha256:49f8eff9612d761c1bd424299b68317ad0f3ba325e4d22ec8acb550c2f1c0a40+    ? ./schema.dhall+}
+ dhall-lang/Prelude/DirectoryTree/Mode/schema.dhall view
@@ -0,0 +1,12 @@+{-|+A schema for a blank file mode.+-}+{ Type =+      missing+        sha256:f05819ec2145e7dabf4aa167338bee6d326aabd81355dcf0b078e358bd34ec60+    ? ./Type.dhall+, default =+      missing+        sha256:0ed46da7e6acbdff9e4c9e27a9f2770075a7cd6cb6bb565765c62093df1b5563+    ? ./none.dhall+}
+ dhall-lang/Prelude/DirectoryTree/Tree/Make.dhall view
@@ -0,0 +1,20 @@+let Directory =+        missing+          sha256:163a4536fdd05ce122d793ceda01d03fcffb29463817ae8b7b5601bf4a06ce6e+      ? ../Entry/DirectoryEntry.dhall++let BinaryFile =+        missing+          sha256:f027db2893f6f38bbe6d868a91f22de530e85407237f00b147427c87d32bf55c+      ? ../Entry/BinaryFileEntry.dhall++let TextFile =+        missing+          sha256:23a8cb29d96aeb623501519d9a62c5c49659e8d1c30b4ae4f2399809e3fd3a01+      ? ../Entry/TextFileEntry.dhall++in  \(tree : Type) ->+      { directory : Directory tree -> tree+      , binary-file : BinaryFile -> tree+      , file : TextFile -> tree+      }
+ dhall-lang/Prelude/DirectoryTree/Tree/Type.dhall view
@@ -0,0 +1,6 @@+let Make =+        missing+          sha256:33c52c16f76b41c3635b57a38ce0286f1ad8b3163a3f07a3b41b808ac5bfeb5b+      ? ./Make.dhall++in  forall (tree : Type) -> forall (make : Make tree) -> List tree
+ dhall-lang/Prelude/DirectoryTree/Tree/makeTree.dhall view
@@ -0,0 +1,32 @@+{-|+@makeTree tree make parents x@ places the tree @x@ below the directory @parent@.+@parent@ is given as a list of 'Metadata' values where each of those will be+used to create the respective level of the directory tree.+-}+let Make =+        missing+          sha256:33c52c16f76b41c3635b57a38ce0286f1ad8b3163a3f07a3b41b808ac5bfeb5b+      ? ./Make.dhall++let Metadata =+        missing+          sha256:8c240a00094238a73904af63ac0924b3e6aba1655312f20a2a27f88554e2febe+      ? ../Entry/Metadata.dhall++let makeTree+    : forall (tree : Type) -> Make tree -> List Metadata -> tree -> tree+    = \(tree : Type) ->+      \(make : Make tree) ->+      \(parents : List Metadata) ->+      \(leaf : tree) ->+        List/fold+          Metadata+          parents+          tree+          ( \(directory : Metadata) ->+            \(result : tree) ->+              make.directory (directory /\ { content = [ result ] })+          )+          leaf++in  makeTree
+ dhall-lang/Prelude/DirectoryTree/Tree/makeTreeFromList.dhall view
@@ -0,0 +1,42 @@+{-|+@makeTreeFromList tree make parents xs@ places the trees @xs@ below the+directory @parent@. @parent@ is given as a non-empty list of 'Metadata' values+where each of those will be used to create the respective level of the directory+tree.+-}+let Make =+        missing+          sha256:33c52c16f76b41c3635b57a38ce0286f1ad8b3163a3f07a3b41b808ac5bfeb5b+      ? ./Make.dhall++let Metadata =+        missing+          sha256:8c240a00094238a73904af63ac0924b3e6aba1655312f20a2a27f88554e2febe+      ? ../Entry/Metadata.dhall++let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ../../NonEmpty/Type.dhall++let makeTreesFromList =+        missing+          sha256:02fce5b194da66c2f98bd05af0a3bfdccf0b57d7971f17bcafee436652d9a88e+      ? ./makeTreesFromList.dhall++let makeTreeFromList+    : forall (tree : Type) ->+      Make tree ->+      NonEmpty Metadata ->+      List tree ->+        tree+    = \(tree : Type) ->+      \(make : Make tree) ->+      \(parents : NonEmpty Metadata) ->+      \(leaves : List tree) ->+        make.directory+          (     parents.head+            /\  { content = makeTreesFromList tree make parents.tail leaves }+          )++in  makeTreeFromList
+ dhall-lang/Prelude/DirectoryTree/Tree/makeTreesFromList.dhall view
@@ -0,0 +1,36 @@+{-|+@makeTreesFromList tree make parents xs@ places the trees @xs@ below the+directory @parent@. @parent@ is given as a list of 'Metadata' values where each+of those will be used to create the respective level of the directory tree.+-}+let Make =+        missing+          sha256:33c52c16f76b41c3635b57a38ce0286f1ad8b3163a3f07a3b41b808ac5bfeb5b+      ? ./Make.dhall++let Metadata =+        missing+          sha256:8c240a00094238a73904af63ac0924b3e6aba1655312f20a2a27f88554e2febe+      ? ../Entry/Metadata.dhall++let makeTreesFromList+    : forall (tree : Type) ->+      Make tree ->+      List Metadata ->+      List tree ->+        List tree+    = \(tree : Type) ->+      \(make : Make tree) ->+      \(parents : List Metadata) ->+      \(leaves : List tree) ->+        List/fold+          Metadata+          parents+          (List tree)+          ( \(directory : Metadata) ->+            \(content : List tree) ->+              [ make.directory (directory /\ { content }) ]+          )+          leaves++in  makeTreesFromList
+ dhall-lang/Prelude/DirectoryTree/Tree/package.dhall view
@@ -0,0 +1,21 @@+{ Make =+      missing+        sha256:33c52c16f76b41c3635b57a38ce0286f1ad8b3163a3f07a3b41b808ac5bfeb5b+    ? ./Make.dhall+, Type =+      missing+        sha256:60b4d351213c6d851d7b2163ada40290b3c492a27326a2066fdec1a3915fb33b+    ? ./Type.dhall+, makeTree =+      missing+        sha256:2c1339fa63b4947864e1a6eede3c296288b53cf91a09d0d6881ae56790342e44+    ? ./makeTree.dhall+, makeTreeFromList =+      missing+        sha256:b894c9398e123d7262320684ac6301c2efe44d9d4f5a303b99d14e9be6b3150f+    ? ./makeTreeFromList.dhall+, makeTreesFromList =+      missing+        sha256:02fce5b194da66c2f98bd05af0a3bfdccf0b57d7971f17bcafee436652d9a88e+    ? ./makeTreesFromList.dhall+}
+ dhall-lang/Prelude/DirectoryTree/User/Type.dhall view
@@ -0,0 +1,1 @@+< UserId : Natural | UserName : Text >
+ dhall-lang/Prelude/DirectoryTree/User/id.dhall view
@@ -0,0 +1,6 @@+let User =+        missing+          sha256:8b25916612d2c9b17130d16b55c6bdb085dd118e692f72bf351a83b1d0ac8833+      ? ./Type.dhall++in  User.UserId
+ dhall-lang/Prelude/DirectoryTree/User/name.dhall view
@@ -0,0 +1,6 @@+let User =+        missing+          sha256:8b25916612d2c9b17130d16b55c6bdb085dd118e692f72bf351a83b1d0ac8833+      ? ./Type.dhall++in  User.UserName
+ dhall-lang/Prelude/DirectoryTree/User/package.dhall view
@@ -0,0 +1,13 @@+{ Type =+      missing+        sha256:8b25916612d2c9b17130d16b55c6bdb085dd118e692f72bf351a83b1d0ac8833+    ? ./Type.dhall+, id =+      missing+        sha256:b572ca9f08a04e8e472f1b6141fd71ff27cc7f22d1e72be50eba5f54798b5a6d+    ? ./id.dhall+, name =+      missing+        sha256:9cfd68599bbd626d3f32c9caa3f09b358ecc08659ef2540b24a4b17b49027015+    ? ./name.dhall+}
+ dhall-lang/Prelude/DirectoryTree/package.dhall view
@@ -0,0 +1,25 @@+{ Access =+      missing+        sha256:12f2ac90297a81c6e5a548bbf568fc7c93c906a6528432aa74faab6ec859de30+    ? ./Access/package.dhall+, Entry =+      missing+        sha256:795db8b6c2bc28fdff6fbcc832c5b4cb6931c1f62ffa84674280c24d4f2eacd8+    ? ./Entry/package.dhall+, Group =+      missing+        sha256:76a0d7e4606bdb91ab001b245cbd411939333b3fc3934ecbb5d41982d1ea001f+    ? ./Group/package.dhall+, Mode =+      missing+        sha256:6687ff7703fe9abdc4af9b3404af3d1c7d21a523d10a0c0b57d102a0bd87843f+    ? ./Mode/package.dhall+, Tree =+      missing+        sha256:6a64c27fa8a0c95830a4cc836651257235da0d985b7f93d11813cdb7a72e646b+    ? ./Tree/package.dhall+, User =+      missing+        sha256:eee7762ea4769371278907a4e33b3808d88430dda32dfc0536dc9bb2bb49d46a+    ? ./User/package.dhall+}
+ dhall-lang/Prelude/Double/package.dhall view
@@ -0,0 +1,5 @@+{ show =+      missing+        sha256:ae645813cc4d8505a265df4d7564c95482f62bb3e07fc81681959599b6cee04f+    ? ./show.dhall+}
+ dhall-lang/Prelude/Double/show view
@@ -0,0 +1,3 @@+  missing+    sha256:ae645813cc4d8505a265df4d7564c95482f62bb3e07fc81681959599b6cee04f+? ./show.dhall
+ dhall-lang/Prelude/Double/show.dhall view
@@ -0,0 +1,13 @@+{-|+Render a `Double` as `Text` using the same representation as Dhall source+code (i.e. a decimal floating point number with a leading `-` sign if negative)+-}+let show+    : Double → Text+    = Double/show++let example0 = assert : show -3.1 ≡ "-3.1"++let example1 = assert : show 0.4 ≡ "0.4"++in  show
+ dhall-lang/Prelude/Function/compose view
@@ -0,0 +1,3 @@+  missing+    sha256:65ad8bbea530b3d8968785a7cf4a9a7976b67059aa15e3b61fcba600a40ae013+? ./compose.dhall
+ dhall-lang/Prelude/Function/compose.dhall view
@@ -0,0 +1,17 @@+--| Compose two functions into one.+let compose+    : ∀(a : Type) → ∀(b : Type) → ∀(c : Type) → (a → b) → (b → c) → a → c+    = λ(a : Type) →+      λ(b : Type) →+      λ(c : Type) →+      λ(f : a → b) →+      λ(g : b → c) →+      λ(x : a) →+        g (f x)++let example0 =+        assert+      :   compose Natural Natural Bool (λ(n : Natural) → n + n) Natural/even 3+        ≡ True++in  compose
+ dhall-lang/Prelude/Function/composeList.dhall view
@@ -0,0 +1,35 @@+{-|+Composes a list of functions starting from the left.+-}+let compose =+        missing+          sha256:65ad8bbea530b3d8968785a7cf4a9a7976b67059aa15e3b61fcba600a40ae013+      ? ./compose.dhall++let identity =+        missing+          sha256:f78b96792b459cb664f41c6119bd8897dd04353a3343521d436cd82ad71cb4d4+      ? ./identity.dhall++let composeList+    : ∀(a : Type) → List (a → a) → a → a+    = λ(a : Type) →+      λ(functions : List (a → a)) →+        List/fold (a → a) functions (a → a) (compose a a a) (identity a)++let example0 =+        assert+      :   composeList+            Natural+            [ λ(x : Natural) → x * 2, λ(x : Natural) → x + 1 ]+            1+        ≡ 3++let property0 =+      λ(a : Type) →+      λ(f : a → a) →+      λ(g : a → a) →+      λ(h : a → a) →+        assert : composeList a [ f, g, h ] ≡ (λ(x : a) → h (g (f x)))++in  composeList
+ dhall-lang/Prelude/Function/identity view
@@ -0,0 +1,3 @@+  missing+    sha256:f78b96792b459cb664f41c6119bd8897dd04353a3343521d436cd82ad71cb4d4+? ./identity.dhall
+ dhall-lang/Prelude/Function/identity.dhall view
@@ -0,0 +1,10 @@+--| The identity function simply returns its input+let identity+    : ∀(a : Type) → ∀(x : a) → a+    = λ(a : Type) → λ(x : a) → x++let example0 = assert : identity Natural 1 ≡ 1++let example1 = assert : identity Bool ≡ (λ(x : Bool) → x)++in  identity
+ dhall-lang/Prelude/Function/package.dhall view
@@ -0,0 +1,13 @@+{ compose =+      missing+        sha256:65ad8bbea530b3d8968785a7cf4a9a7976b67059aa15e3b61fcba600a40ae013+    ? ./compose.dhall+, composeList =+      missing+        sha256:2c6931544d8b5a5b14514098c07bd1813f67b16834588d056df3c0bc2e489937+    ? ./composeList.dhall+, identity =+      missing+        sha256:f78b96792b459cb664f41c6119bd8897dd04353a3343521d436cd82ad71cb4d4+    ? ./identity.dhall+}
+ dhall-lang/Prelude/Integer/abs view
@@ -0,0 +1,3 @@+  missing+    sha256:35212fcbe1e60cb95b033a4a9c6e45befca4a298aa9919915999d09e69ddced1+? ./abs.dhall
+ dhall-lang/Prelude/Integer/abs.dhall view
@@ -0,0 +1,15 @@+--| Returns the absolute value of an `Integer`, i.e. its non-negative value.+let abs+    : Integer → Natural+    = λ(n : Integer) →+        if    Natural/isZero (Integer/clamp n)+        then  Integer/clamp (Integer/negate n)+        else  Integer/clamp n++let example0 = assert : abs +7 ≡ 7++let example2 = assert : abs +0 ≡ 0++let example3 = assert : abs -3 ≡ 3++in  abs
+ dhall-lang/Prelude/Integer/add view
@@ -0,0 +1,3 @@+  missing+    sha256:7da1306a0bf87c5668beead2a1db1b18861e53d7ce1f38057b2964b649f59c3b+? ./add.dhall
+ dhall-lang/Prelude/Integer/add.dhall view
@@ -0,0 +1,25 @@+--| `add m n` computes `m + n`.+let Integer/subtract =+        missing+          sha256:a34d36272fa8ae4f1ec8b56222fe8dc8a2ec55ec6538b840de0cbe207b006fda+      ? ./subtract.dhall++let add+    : Integer → Integer → Integer+    = λ(m : Integer) → λ(n : Integer) → Integer/subtract (Integer/negate m) n++let example0 = assert : add +3 +5 ≡ +8++let example1 = assert : add -3 -5 ≡ -8++let example2 = assert : add -4 +4 ≡ +0++let example3 = assert : add -3 +5 ≡ +2++let example4 = assert : add +3 -5 ≡ -2++let example5 = assert : add +0 -3 ≡ -3++let example6 = assert : add +0 +3 ≡ +3++in  add
+ dhall-lang/Prelude/Integer/clamp view
@@ -0,0 +1,3 @@+  missing+    sha256:ea42096cf3e024fadfaf910e0b839005b0ea7514fff11e5a3950a77694d9c5d2+? ./clamp.dhall
+ dhall-lang/Prelude/Integer/clamp.dhall view
@@ -0,0 +1,14 @@+{-|+Convert an `Integer` to a `Natural` number, with negative numbers becoming zero.+-}+let clamp+    : Integer → Natural+    = Integer/clamp++let example0 = assert : clamp +7 ≡ 7++let example2 = assert : clamp +0 ≡ 0++let example3 = assert : clamp -3 ≡ 0++in  clamp
+ dhall-lang/Prelude/Integer/equal view
@@ -0,0 +1,3 @@+  missing+    sha256:2d99a205086aa77eea17ae1dab22c275f3eb007bccdc8d9895b93497ebfc39f8+? ./equal.dhall
+ dhall-lang/Prelude/Integer/equal.dhall view
@@ -0,0 +1,24 @@+--| `equal` checks if two Integers are equal.+let Natural/equal =+        missing+          sha256:7f108edfa35ddc7cebafb24dc073478e93a802e13b5bc3fd22f4768c9b066e60+      ? ../Natural/equal.dhall++let equal+    : Integer → Integer → Bool+    = λ(a : Integer) →+      λ(b : Integer) →+            Natural/equal (Integer/clamp a) (Integer/clamp b)+        &&  Natural/equal+              (Integer/clamp (Integer/negate a))+              (Integer/clamp (Integer/negate b))++let example0 = assert : equal +5 +5 ≡ True++let example1 = assert : equal +5 +6 ≡ False++let example2 = assert : equal +5 -5 ≡ False++let example3 = assert : equal -5 -5 ≡ True++in  equal
+ dhall-lang/Prelude/Integer/greaterThan view
@@ -0,0 +1,3 @@+  missing+    sha256:d23affd73029fc9aaf867c2c7b86510ca2802d3f0d1f3e1d1a93ffd87b7cb64b+? ./greaterThan.dhall
+ dhall-lang/Prelude/Integer/greaterThan.dhall view
@@ -0,0 +1,30 @@+--| `greaterThan` checks if one Integer is greater than another.+let Bool/not =+        missing+          sha256:723df402df24377d8a853afed08d9d69a0a6d86e2e5b2bac8960b0d4756c7dc4+      ? ../Bool/not.dhall++let lessThanEqual =+        missing+          sha256:e3cca9f3942f81fa78a2bea23c0c24519c67cfe438116c38e797e12dcd26f6bc+      ? ./lessThanEqual.dhall++let greaterThan+    : Integer → Integer → Bool+    = λ(x : Integer) → λ(y : Integer) → Bool/not (lessThanEqual x y)++let example0 = assert : greaterThan +5 +6 ≡ False++let example1 = assert : greaterThan +5 +5 ≡ False++let example2 = assert : greaterThan +5 +4 ≡ True++let example3 = assert : greaterThan -5 +8 ≡ False++let example4 = assert : greaterThan -5 -3 ≡ False++let example5 = assert : greaterThan -3 -5 ≡ True++let example6 = assert : greaterThan -3 -3 ≡ False++in  greaterThan
+ dhall-lang/Prelude/Integer/greaterThanEqual view
@@ -0,0 +1,3 @@+  missing+    sha256:a9fa2dc5cd6067a23b39d7fe8d14a63109583b320429fb0e446658a5aae0a958+? ./greaterThanEqual.dhall
+ dhall-lang/Prelude/Integer/greaterThanEqual.dhall view
@@ -0,0 +1,27 @@+{-|+`greaterThanEqual` checks if one Integer is greater than or equal to another.+-}+let lessThanEqual =+        missing+          sha256:e3cca9f3942f81fa78a2bea23c0c24519c67cfe438116c38e797e12dcd26f6bc+      ? ./lessThanEqual.dhall++let greaterThanEqual+    : Integer → Integer → Bool+    = λ(x : Integer) → λ(y : Integer) → lessThanEqual y x++let example0 = assert : greaterThanEqual +5 +6 ≡ False++let example1 = assert : greaterThanEqual +5 +5 ≡ True++let example2 = assert : greaterThanEqual +5 +4 ≡ True++let example3 = assert : greaterThanEqual -5 +8 ≡ False++let example4 = assert : greaterThanEqual -5 -3 ≡ False++let example5 = assert : greaterThanEqual -3 -5 ≡ True++let example6 = assert : greaterThanEqual -3 -3 ≡ True++in  greaterThanEqual
+ dhall-lang/Prelude/Integer/lessThan view
@@ -0,0 +1,3 @@+  missing+    sha256:eeaa0081d10c6c97464ef193c40f1aa5cbb12f0202972ab42f3d310c2fd6a3f0+? ./lessThan.dhall
+ dhall-lang/Prelude/Integer/lessThan.dhall view
@@ -0,0 +1,25 @@+--| `lessThan` checks if one Integer is less than another.+let greaterThan =+        missing+          sha256:d23affd73029fc9aaf867c2c7b86510ca2802d3f0d1f3e1d1a93ffd87b7cb64b+      ? ./greaterThan.dhall++let lessThan+    : Integer → Integer → Bool+    = λ(x : Integer) → λ(y : Integer) → greaterThan y x++let example0 = assert : lessThan +5 +6 ≡ True++let example1 = assert : lessThan +5 +5 ≡ False++let example2 = assert : lessThan +5 +4 ≡ False++let example3 = assert : lessThan -5 +8 ≡ True++let example4 = assert : lessThan -5 -3 ≡ True++let example5 = assert : lessThan -3 -5 ≡ False++let example6 = assert : lessThan -3 -3 ≡ False++in  lessThan
+ dhall-lang/Prelude/Integer/lessThanEqual view
@@ -0,0 +1,3 @@+  missing+    sha256:e3cca9f3942f81fa78a2bea23c0c24519c67cfe438116c38e797e12dcd26f6bc+? ./lessThanEqual.dhall
+ dhall-lang/Prelude/Integer/lessThanEqual.dhall view
@@ -0,0 +1,47 @@+--| `lessThanEqual` checks if one Integer is less than or equal to another.+let Natural/greaterThanEqual =+        missing+          sha256:30ebfab0febd7aa0ccccfdf3dc36ee6d50f0117f35dd4a9b034750b7e885a1a4+      ? ../Natural/greaterThanEqual.dhall++let Natural/lessThanEqual =+        missing+          sha256:1a5caa2b80a42b9f58fff58e47ac0d9a9946d0b2d36c54034b8ddfe3cb0f3c99+      ? ../Natural/lessThanEqual.dhall++let nonPositive =+        missing+          sha256:e00a852eed5b84ff60487097d8aadce53c9e5301f53ff4954044bd68949fac3b+      ? ./nonPositive.dhall++let nonNegative =+        missing+          sha256:b463373f070df6b1c8c7082051e0810fee38b360bab35256187c8c2b6af5c663+      ? ./nonNegative.dhall++let lessThanEqual+    : Integer → Integer → Bool+    = λ(x : Integer) →+      λ(y : Integer) →+        if    nonPositive x+        then      nonNegative y+              ||  Natural/greaterThanEqual+                    (Integer/clamp (Integer/negate x))+                    (Integer/clamp (Integer/negate y))+        else  Natural/lessThanEqual (Integer/clamp x) (Integer/clamp y)++let example0 = assert : lessThanEqual +5 +6 ≡ True++let example1 = assert : lessThanEqual +5 +5 ≡ True++let example2 = assert : lessThanEqual +5 +4 ≡ False++let example3 = assert : lessThanEqual -5 +8 ≡ True++let example4 = assert : lessThanEqual -5 -3 ≡ True++let example5 = assert : lessThanEqual -3 -5 ≡ False++let example6 = assert : lessThanEqual -3 -3 ≡ True++in  lessThanEqual
+ dhall-lang/Prelude/Integer/multiply view
@@ -0,0 +1,3 @@+  missing+    sha256:dcb1ed7c8475ece8d67db92cd249fc728541778ff82509e28c3760e341880e4d+? ./multiply.dhall
+ dhall-lang/Prelude/Integer/multiply.dhall view
@@ -0,0 +1,40 @@+--| `multiply m n` computes `m * n`.+let nonPositive =+        missing+          sha256:e00a852eed5b84ff60487097d8aadce53c9e5301f53ff4954044bd68949fac3b+      ? ./nonPositive.dhall++let multiplyNonNegative =+      λ(x : Integer) →+      λ(y : Integer) →+        Natural/toInteger (Integer/clamp x * Integer/clamp y)++let multiply+    : Integer → Integer → Integer+    = λ(m : Integer) →+      λ(n : Integer) →+        if    nonPositive m+        then  if    nonPositive n+              then  multiplyNonNegative (Integer/negate m) (Integer/negate n)+              else  Integer/negate (multiplyNonNegative (Integer/negate m) n)+        else  if nonPositive n+        then  Integer/negate (multiplyNonNegative m (Integer/negate n))+        else  multiplyNonNegative m n++let example0 = assert : multiply +3 +5 ≡ +15++let example1 = assert : multiply -3 +5 ≡ -15++let example2 = assert : multiply -3 -5 ≡ +15++let example3 = assert : multiply +0 +5 ≡ +0++let example4 = assert : multiply +5 +0 ≡ +0++let example5 = assert : multiply +0 +0 ≡ +0++let example6 = assert : multiply +1 +5 ≡ +5++let example7 = assert : multiply +3 -1 ≡ -3++in  multiply
+ dhall-lang/Prelude/Integer/negate view
@@ -0,0 +1,3 @@+  missing+    sha256:2373c992e1de93634bc6a8781eb073b2a92a70170133e49762a785f3a136df5d+? ./negate.dhall
+ dhall-lang/Prelude/Integer/negate.dhall view
@@ -0,0 +1,12 @@+--| Invert the sign of an `Integer`, with zero remaining unchanged.+let negate+    : Integer → Integer+    = Integer/negate++let example0 = assert : negate -3 ≡ +3++let example2 = assert : negate +7 ≡ -7++let example3 = assert : negate +0 ≡ +0++in  negate
+ dhall-lang/Prelude/Integer/negative view
@@ -0,0 +1,3 @@+  missing+    sha256:23e4b3c61eea9e878a7f83bf25fd0ea2c6a6d60174890d65be885828b690a570+? ./negative.dhall
+ dhall-lang/Prelude/Integer/negative.dhall view
@@ -0,0 +1,21 @@+{-|+Returns `True` for any `Integer` less than `+0`.++`negative` is more efficient than `./lessThan +0` or `./lessThanEqual -1`.+-}+let positive =+        missing+          sha256:7bdbf50fcdb83d01f74c7e2a92bf5c9104eff5d8c5b4587e9337f0caefcfdbe3+      ? ./positive.dhall++let negative+    : Integer → Bool+    = λ(n : Integer) → positive (Integer/negate n)++let example0 = assert : negative +1 ≡ False++let example1 = assert : negative +0 ≡ False++let example2 = assert : negative -1 ≡ True++in  negative
+ dhall-lang/Prelude/Integer/nonNegative view
@@ -0,0 +1,3 @@+  missing+    sha256:b463373f070df6b1c8c7082051e0810fee38b360bab35256187c8c2b6af5c663+? ./nonNegative.dhall
+ dhall-lang/Prelude/Integer/nonNegative.dhall view
@@ -0,0 +1,21 @@+{-|+Returns `True` for `+0` and any positive `Integer`.++`nonNegative` is more efficient than `./greaterThanEqual +0` or `./greaterThan -1`.+-}+let nonPositive =+        missing+          sha256:e00a852eed5b84ff60487097d8aadce53c9e5301f53ff4954044bd68949fac3b+      ? ./nonPositive.dhall++let nonNegative+    : Integer → Bool+    = λ(n : Integer) → nonPositive (Integer/negate n)++let example0 = assert : nonNegative +1 ≡ True++let example1 = assert : nonNegative +0 ≡ True++let example2 = assert : nonNegative -1 ≡ False++in  nonNegative
+ dhall-lang/Prelude/Integer/nonPositive view
@@ -0,0 +1,3 @@+  missing+    sha256:e00a852eed5b84ff60487097d8aadce53c9e5301f53ff4954044bd68949fac3b+? ./nonPositive.dhall
+ dhall-lang/Prelude/Integer/nonPositive.dhall view
@@ -0,0 +1,16 @@+{-|+Returns `True` for `+0` and any negative `Integer`.++`nonPositive` is more efficient than `./lessThanEqual +0` or `./lessThan +1`.+-}+let nonPositive+    : Integer → Bool+    = λ(n : Integer) → Natural/isZero (Integer/clamp n)++let example0 = assert : nonPositive +1 ≡ False++let example1 = assert : nonPositive +0 ≡ True++let example2 = assert : nonPositive -1 ≡ True++in  nonPositive
+ dhall-lang/Prelude/Integer/package.dhall view
@@ -0,0 +1,73 @@+{ abs =+      missing+        sha256:35212fcbe1e60cb95b033a4a9c6e45befca4a298aa9919915999d09e69ddced1+    ? ./abs.dhall+, add =+      missing+        sha256:7da1306a0bf87c5668beead2a1db1b18861e53d7ce1f38057b2964b649f59c3b+    ? ./add.dhall+, clamp =+      missing+        sha256:ea42096cf3e024fadfaf910e0b839005b0ea7514fff11e5a3950a77694d9c5d2+    ? ./clamp.dhall+, equal =+      missing+        sha256:2d99a205086aa77eea17ae1dab22c275f3eb007bccdc8d9895b93497ebfc39f8+    ? ./equal.dhall+, greaterThan =+      missing+        sha256:d23affd73029fc9aaf867c2c7b86510ca2802d3f0d1f3e1d1a93ffd87b7cb64b+    ? ./greaterThan.dhall+, greaterThanEqual =+      missing+        sha256:a9fa2dc5cd6067a23b39d7fe8d14a63109583b320429fb0e446658a5aae0a958+    ? ./greaterThanEqual.dhall+, lessThan =+      missing+        sha256:eeaa0081d10c6c97464ef193c40f1aa5cbb12f0202972ab42f3d310c2fd6a3f0+    ? ./lessThan.dhall+, lessThanEqual =+      missing+        sha256:e3cca9f3942f81fa78a2bea23c0c24519c67cfe438116c38e797e12dcd26f6bc+    ? ./lessThanEqual.dhall+, multiply =+      missing+        sha256:dcb1ed7c8475ece8d67db92cd249fc728541778ff82509e28c3760e341880e4d+    ? ./multiply.dhall+, negate =+      missing+        sha256:2373c992e1de93634bc6a8781eb073b2a92a70170133e49762a785f3a136df5d+    ? ./negate.dhall+, negative =+      missing+        sha256:23e4b3c61eea9e878a7f83bf25fd0ea2c6a6d60174890d65be885828b690a570+    ? ./negative.dhall+, nonNegative =+      missing+        sha256:b463373f070df6b1c8c7082051e0810fee38b360bab35256187c8c2b6af5c663+    ? ./nonNegative.dhall+, nonPositive =+      missing+        sha256:e00a852eed5b84ff60487097d8aadce53c9e5301f53ff4954044bd68949fac3b+    ? ./nonPositive.dhall+, positive =+      missing+        sha256:7bdbf50fcdb83d01f74c7e2a92bf5c9104eff5d8c5b4587e9337f0caefcfdbe3+    ? ./positive.dhall+, show =+      missing+        sha256:ecf8b0594cd5181bc45d3b7ea0d44d3ba9ad5dac6ec17bb8968beb65f4b1baa9+    ? ./show.dhall+, subtract =+      missing+        sha256:a34d36272fa8ae4f1ec8b56222fe8dc8a2ec55ec6538b840de0cbe207b006fda+    ? ./subtract.dhall+, toDouble =+      missing+        sha256:77bc5d635dc4d952f37cc96f2a681d5ac503b4e8b21fc00055b1946adb5beda7+    ? ./toDouble.dhall+, toNatural =+      missing+        sha256:4d128730d74e7f832e53873cb5204aa91b79758be5ce4e1aa991fe1951304a0e+    ? ./toNatural.dhall+}
+ dhall-lang/Prelude/Integer/positive view
@@ -0,0 +1,3 @@+  missing+    sha256:7bdbf50fcdb83d01f74c7e2a92bf5c9104eff5d8c5b4587e9337f0caefcfdbe3+? ./positive.dhall
+ dhall-lang/Prelude/Integer/positive.dhall view
@@ -0,0 +1,26 @@+{-|+Returns `True` for any `Integer` greater than `+0`.++`positive` is more efficient than `./greaterThan +0` or `./greaterThanEqual +1`.+-}+let not =+        missing+          sha256:723df402df24377d8a853afed08d9d69a0a6d86e2e5b2bac8960b0d4756c7dc4+      ? ../Bool/not.dhall++let nonPositive =+        missing+          sha256:e00a852eed5b84ff60487097d8aadce53c9e5301f53ff4954044bd68949fac3b+      ? ./nonPositive.dhall++let positive+    : Integer → Bool+    = λ(n : Integer) → not (nonPositive n)++let example0 = assert : positive +1 ≡ True++let example1 = assert : positive +0 ≡ False++let example2 = assert : positive -1 ≡ False++in  positive
+ dhall-lang/Prelude/Integer/show view
@@ -0,0 +1,3 @@+  missing+    sha256:ecf8b0594cd5181bc45d3b7ea0d44d3ba9ad5dac6ec17bb8968beb65f4b1baa9+? ./show.dhall
+ dhall-lang/Prelude/Integer/show.dhall view
@@ -0,0 +1,14 @@+{-|+Render an `Integer` as `Text` using the same representation as Dhall source+code (i.e. a decimal number with a leading `-` sign if negative and a leading+`+` sign if non-negative)+-}+let show+    : Integer → Text+    = Integer/show++let example0 = assert : show -3 ≡ "-3"++let example1 = assert : show +0 ≡ "+0"++in  show
+ dhall-lang/Prelude/Integer/subtract view
@@ -0,0 +1,3 @@+  missing+    sha256:a34d36272fa8ae4f1ec8b56222fe8dc8a2ec55ec6538b840de0cbe207b006fda+? ./subtract.dhall
+ dhall-lang/Prelude/Integer/subtract.dhall view
@@ -0,0 +1,54 @@+--| `subtract m n` computes `n - m`.+let nonPositive =+        missing+          sha256:e00a852eed5b84ff60487097d8aadce53c9e5301f53ff4954044bd68949fac3b+      ? ./nonPositive.dhall++let subtractNonNegative =+      λ(xi : Integer) →+      λ(yi : Integer) →+        let xn = Integer/clamp xi++        let yn = Integer/clamp yi++        let dn = Natural/subtract xn yn++        in  if    Natural/isZero dn+            then  Integer/negate (Natural/toInteger (Natural/subtract yn xn))+            else  Natural/toInteger dn++let subtract+    : Integer → Integer → Integer+    = λ(m : Integer) →+      λ(n : Integer) →+        if    nonPositive m+        then  if    nonPositive n+              then  subtractNonNegative (Integer/negate n) (Integer/negate m)+              else  Natural/toInteger+                      (Integer/clamp (Integer/negate m) + Integer/clamp n)+        else  if nonPositive n+        then  Integer/negate+                ( Natural/toInteger+                    (Integer/clamp m + Integer/clamp (Integer/negate n))+                )+        else  subtractNonNegative m n++let example0 = assert : subtract +3 +5 ≡ +2++let example1 = assert : subtract +4 +4 ≡ +0++let example2 = assert : subtract +5 +3 ≡ -2++let example3 = assert : subtract -3 -5 ≡ -2++let example4 = assert : subtract -4 -4 ≡ +0++let example5 = assert : subtract -5 -3 ≡ +2++let example6 = assert : subtract -3 +5 ≡ +8++let example7 = assert : subtract +3 -5 ≡ -8++let example8 = assert : subtract +0 -3 ≡ -3++in  subtract
+ dhall-lang/Prelude/Integer/toDouble view
@@ -0,0 +1,3 @@+  missing+    sha256:77bc5d635dc4d952f37cc96f2a681d5ac503b4e8b21fc00055b1946adb5beda7+? ./toDouble.dhall
+ dhall-lang/Prelude/Integer/toDouble.dhall view
@@ -0,0 +1,10 @@+--| Convert an `Integer` to the corresponding `Double`+let toDouble+    : Integer → Double+    = Integer/toDouble++let example0 = assert : toDouble -3 ≡ -3.0++let example1 = assert : toDouble +2 ≡ 2.0++in  toDouble
+ dhall-lang/Prelude/Integer/toNatural view
@@ -0,0 +1,3 @@+  missing+    sha256:4d128730d74e7f832e53873cb5204aa91b79758be5ce4e1aa991fe1951304a0e+? ./toNatural.dhall
+ dhall-lang/Prelude/Integer/toNatural.dhall view
@@ -0,0 +1,20 @@+{-|+Convert an `Integer` to an `Optional Natural`, with negative numbers becoming `None Natural`.+-}+let nonNegative =+        missing+          sha256:b463373f070df6b1c8c7082051e0810fee38b360bab35256187c8c2b6af5c663+      ? ./nonNegative.dhall++let toNatural+    : Integer → Optional Natural+    = λ(n : Integer) →+        if nonNegative n then Some (Integer/clamp n) else None Natural++let example0 = assert : toNatural +7 ≡ Some 7++let example2 = assert : toNatural +0 ≡ Some 0++let example3 = assert : toNatural -3 ≡ None Natural++in  toNatural
+ dhall-lang/Prelude/JSON/Format view
@@ -0,0 +1,3 @@+  missing+    sha256:d7936b510cfc091faa994652af0eb5feb889cd44bc989edbe4f1eb8c5623caac+? ./Format.dhall
+ dhall-lang/Prelude/JSON/Format.dhall view
@@ -0,0 +1,7 @@+{-|+An internal type used by `./renderAs` to select the output format.++You should not need to use this type directly, simply use `./render`+or `./renderYAML` as appropriate.+-}+< YAML | JSON >
+ dhall-lang/Prelude/JSON/Nesting view
@@ -0,0 +1,3 @@+  missing+    sha256:6284802edd41d5d725aa1ec7687e614e21ad1be7e14dd10996bfa9625105c335+? ./Nesting.dhall
+ dhall-lang/Prelude/JSON/Nesting.dhall view
@@ -0,0 +1,35 @@+{-|+This type is used as part of `dhall-json`'s support for preserving alternative+names++For example, this Dhall code:++```+let Example = < Left : { foo : Natural } | Right : { bar : Bool } >++let Nesting = < Inline | Nested : Text >++in  { field =+        "name"+    , nesting =+        Nesting.Inline+    , contents =+        Example.Left { foo = 2 }+    }+```++... generates this JSON:++```+{+  "foo": 2,+  "name": "Left"+}+```++-}+let Nesting+    : Type+    = < Inline | Nested : Text >++in  Nesting
+ dhall-lang/Prelude/JSON/Tagged view
@@ -0,0 +1,3 @@+  missing+    sha256:21feca7d2b23f210d0696131d792e18a7d24fdcc85d41a49ba85b98670eba194+? ./Tagged.dhall
+ dhall-lang/Prelude/JSON/Tagged.dhall view
@@ -0,0 +1,74 @@+{-|+This is a convenient type-level function when using `dhall-to-json`'s support+for preserving alternative names++For example, this code:++```+let map = ../List/map++let Provisioner =+      < shell :+          { inline : List Text }+      | file :+          { source : Text, destination : Text }+      >++let Tagged = ./Tagged++let Nesting = ./Nesting++let wrap+    : Provisioner → Tagged Provisioner+    = λ(x : Provisioner) →+        { field = "type", nesting = Nesting.Nested "params", contents = x }++in  { provisioners =+        map+        Provisioner+        (Tagged Provisioner)+        wrap+        [ Provisioner.shell { inline = [ "echo foo" ] }+        , Provisioner.file+          { source = "app.tar.gz", destination = "/tmp/app.tar.gz" }+        ]+    }+```++... produces this JSON:++```+{+  "provisioners": [+    {+      "params": {+        "inline": [+          "echo foo"+        ]+      },+      "type": "shell"+    },+    {+      "params": {+        "destination": "/tmp/app.tar.gz",+        "source": "app.tar.gz"+      },+      "type": "file"+    }+  ]+}+```++-}+let Tagged+    : Type → Type+    = λ(a : Type) →+        { field : Text+        , nesting :+              missing+                sha256:6284802edd41d5d725aa1ec7687e614e21ad1be7e14dd10996bfa9625105c335+            ? ./Nesting.dhall+        , contents : a+        }++in  Tagged
+ dhall-lang/Prelude/JSON/Type view
@@ -0,0 +1,3 @@+  missing+    sha256:40edbc9371979426df63e064333b02689b969c4cfbbccfa481216d2d1a6e9759+? ./Type.dhall
+ dhall-lang/Prelude/JSON/Type.dhall view
@@ -0,0 +1,63 @@+{-|+Dhall encoding of an arbitrary JSON value++For example, the following JSON value:++```+[ { "foo": null, "bar": [ 1.0, true ] } ]+```++... corresponds to the following Dhall expression:++```+λ(JSON : Type) →+λ ( json+  : { array : List JSON → JSON+    , bool : Bool → JSON+    , null : JSON+    , double : Double → JSON+    , integer : Integer → JSON+    , object : List { mapKey : Text, mapValue : JSON } → JSON+    , string : Text → JSON+    }+  ) →+  json.object+    [ { mapKey = "foo", mapValue = json.null }+    , { mapKey = "bar"+      , mapValue = json.array [ json.double 1.0, json.bool True ]+      }+    ]+```++  You do not need to create these values directly, though.  You can use+  the utilities exported by `./package.dhall` to create values of this type,+  such as:++```+let JSON = ./package.dhall++in  JSON.object+      [ { mapKey = "foo", mapValue = JSON.null }+      , { mapKey = "bar"+        , mapValue = JSON.array [ JSON.double 1.0, JSON.bool True ]+        }+      ]+```++-}+let JSON/Type+    : Type+    = ∀(JSON : Type) →+      ∀ ( json+        : { array : List JSON → JSON+          , bool : Bool → JSON+          , double : Double → JSON+          , integer : Integer → JSON+          , null : JSON+          , object : List { mapKey : Text, mapValue : JSON } → JSON+          , string : Text → JSON+          }+        ) →+        JSON++in  JSON/Type
+ dhall-lang/Prelude/JSON/array view
@@ -0,0 +1,3 @@+  missing+    sha256:fb6346a9c63638fe3c59f8108e19eebdbddc51389ec5570bab4c25f890ccccc8+? ./array.dhall
+ dhall-lang/Prelude/JSON/array.dhall view
@@ -0,0 +1,41 @@+{-|+Create a JSON array from a `List` of JSON values++```+let JSON = ./package.dhall+in  JSON.render (JSON.array [ JSON.double 1.0, JSON.bool True ])+= "[ 1.0, true ]"++let JSON/Type = ./Type+let JSON = ./package.dhall+in  JSON.render (JSON.array ([] : List JSON/Type))+= "[ ]"+```+-}+let JSON =+        missing+          sha256:40edbc9371979426df63e064333b02689b969c4cfbbccfa481216d2d1a6e9759+      ? ./Type.dhall++let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ../List/map.dhall++let array+    : List JSON → JSON+    = λ(x : List JSON) →+      λ(JSON : Type) →+      λ ( json+        : { array : List JSON → JSON+          , bool : Bool → JSON+          , double : Double → JSON+          , integer : Integer → JSON+          , null : JSON+          , object : List { mapKey : Text, mapValue : JSON } → JSON+          , string : Text → JSON+          }+        ) →+        json.array (List/map JSON@1 JSON (λ(j : JSON@1) → j JSON json) x)++in  array
+ dhall-lang/Prelude/JSON/bool view
@@ -0,0 +1,3 @@+  missing+    sha256:e043d9ed01e5b45899059e128243f3dae7ce65f293f0015ce816fc36d30f7f39+? ./bool.dhall
+ dhall-lang/Prelude/JSON/bool.dhall view
@@ -0,0 +1,35 @@+{-|+Create a JSON bool from a Dhall `Bool`++```+let JSON = ./package.dhall+in  JSON.render (JSON.bool True)+= "true"++let JSON = ./package.dhall+in  JSON.render (JSON.bool False)+= "false"+```+-}+let JSON =+        missing+          sha256:40edbc9371979426df63e064333b02689b969c4cfbbccfa481216d2d1a6e9759+      ? ./Type.dhall++let bool+    : Bool → JSON+    = λ(x : Bool) →+      λ(JSON : Type) →+      λ ( json+        : { array : List JSON → JSON+          , bool : Bool → JSON+          , double : Double → JSON+          , integer : Integer → JSON+          , null : JSON+          , object : List { mapKey : Text, mapValue : JSON } → JSON+          , string : Text → JSON+          }+        ) →+        json.bool x++in  bool
+ dhall-lang/Prelude/JSON/core.dhall view
@@ -0,0 +1,70 @@+{-|+A record of functions useful for constructing `JSON` values.++This is only a subset of what `package.dhall` exports. If you are not writing a+JSON prelude function, you should use the `package.dhall` file instead.++It is used internally by `render`, `renderYAML` and `omitNullFields` instead of+`package.dhall` to avoid import cycles.+-}+{ Type =+      missing+        sha256:40edbc9371979426df63e064333b02689b969c4cfbbccfa481216d2d1a6e9759+    ? ./Type.dhall+, Tagged =+      missing+        sha256:21feca7d2b23f210d0696131d792e18a7d24fdcc85d41a49ba85b98670eba194+    ? ./Tagged.dhall+, Nesting =+      missing+        sha256:6284802edd41d5d725aa1ec7687e614e21ad1be7e14dd10996bfa9625105c335+    ? ./Nesting.dhall+, keyText =+      missing+        sha256:f7b6c802ca5764d03d5e9a6e48d9cb167c01392f775d9c2c87b83cdaa60ea0cc+    ? ./keyText.dhall+, keyValue =+      missing+        sha256:a0a97199d280c4cce72ffcbbf93b7ceda0a569cf4d173ac98e0aaaa78034b98c+    ? ./keyValue.dhall+, string =+      missing+        sha256:7ddb3a3b9f3ed09ed011d621a10ad9825185cd03503be98a81d42f6afb77940e+    ? ./string.dhall+, number =+      missing+        sha256:e70162c73c4978ad0d0d99505f61c7d990f3abadfcc08b34388b29c0934a7a32+    ? ./number.dhall+, double =+      missing+        sha256:e70162c73c4978ad0d0d99505f61c7d990f3abadfcc08b34388b29c0934a7a32+    ? ./double.dhall+, integer =+      missing+        sha256:c81a417397fc6f62155ec71fdd8d2047f981f0881295b307de3dd88747bf7e40+    ? ./integer.dhall+, natural =+      missing+        sha256:a839dc6789f19f820e9cbf70c60f41f3b057c59ece1d226d04db5aca447eb0e5+    ? ./natural.dhall+, object =+      missing+        sha256:869aede785c34798be9f9fd457ece73e7f683f352ae4555f791516a365faf4ac+    ? ./object.dhall+, array =+      missing+        sha256:fb6346a9c63638fe3c59f8108e19eebdbddc51389ec5570bab4c25f890ccccc8+    ? ./array.dhall+, bool =+      missing+        sha256:e043d9ed01e5b45899059e128243f3dae7ce65f293f0015ce816fc36d30f7f39+    ? ./bool.dhall+, null =+      missing+        sha256:1eeb9aee38eb8dde0e64efbaf60f24612c8194cc00b510bfb627c2ee2e1877b8+    ? ./null.dhall+, renderInteger =+      missing+        sha256:15b8d2ae46d5002832741927af787761df49798c911e2bf85db7a7b9cb5c078c+    ? ./renderInteger.dhall+}
+ dhall-lang/Prelude/JSON/double view
@@ -0,0 +1,3 @@+  missing+    sha256:e70162c73c4978ad0d0d99505f61c7d990f3abadfcc08b34388b29c0934a7a32+? ./double.dhall
+ dhall-lang/Prelude/JSON/double.dhall view
@@ -0,0 +1,35 @@+{-|+Create a JSON number from a Dhall `Double`++```+let JSON = ./package.dhall+in  JSON.render (JSON.double 42.0)+= "42.0"++let JSON = ./package.dhall+in  JSON.render (JSON.double -1.5e-10)+= "-1.5e-10"+```+-}+let JSON =+        missing+          sha256:40edbc9371979426df63e064333b02689b969c4cfbbccfa481216d2d1a6e9759+      ? ./Type.dhall++let double+    : Double → JSON+    = λ(x : Double) →+      λ(JSON : Type) →+      λ ( json+        : { array : List JSON → JSON+          , bool : Bool → JSON+          , double : Double → JSON+          , integer : Integer → JSON+          , null : JSON+          , object : List { mapKey : Text, mapValue : JSON } → JSON+          , string : Text → JSON+          }+        ) →+        json.double x++in  double
+ dhall-lang/Prelude/JSON/integer view
@@ -0,0 +1,3 @@+  missing+    sha256:c81a417397fc6f62155ec71fdd8d2047f981f0881295b307de3dd88747bf7e40+? ./integer.dhall
+ dhall-lang/Prelude/JSON/integer.dhall view
@@ -0,0 +1,35 @@+{-|+Create a JSON number from a Dhall `Integer`++```+let JSON = ./package.dhall+in  JSON.render (JSON.integer -1)+= "-1"++let JSON = ./package.dhall+in  JSON.render (JSON.integer +2)+= "+2"+```+-}+let JSON =+        missing+          sha256:40edbc9371979426df63e064333b02689b969c4cfbbccfa481216d2d1a6e9759+      ? ./Type.dhall++let integer+    : Integer → JSON+    = λ(x : Integer) →+      λ(JSON : Type) →+      λ ( json+        : { array : List JSON → JSON+          , bool : Bool → JSON+          , double : Double → JSON+          , integer : Integer → JSON+          , null : JSON+          , object : List { mapKey : Text, mapValue : JSON } → JSON+          , string : Text → JSON+          }+        ) →+        json.integer x++in  integer
+ dhall-lang/Prelude/JSON/keyText view
@@ -0,0 +1,3 @@+  missing+    sha256:f7b6c802ca5764d03d5e9a6e48d9cb167c01392f775d9c2c87b83cdaa60ea0cc+? ./keyText.dhall
+ dhall-lang/Prelude/JSON/keyText.dhall view
@@ -0,0 +1,3 @@+  missing+    sha256:f7b6c802ca5764d03d5e9a6e48d9cb167c01392f775d9c2c87b83cdaa60ea0cc+? ../Map/keyText.dhall
+ dhall-lang/Prelude/JSON/keyValue view
@@ -0,0 +1,3 @@+  missing+    sha256:a0a97199d280c4cce72ffcbbf93b7ceda0a569cf4d173ac98e0aaaa78034b98c+? ./keyValue.dhall
+ dhall-lang/Prelude/JSON/keyValue.dhall view
@@ -0,0 +1,3 @@+  missing+    sha256:a0a97199d280c4cce72ffcbbf93b7ceda0a569cf4d173ac98e0aaaa78034b98c+? ../Map/keyValue.dhall
+ dhall-lang/Prelude/JSON/natural view
@@ -0,0 +1,3 @@+  missing+    sha256:a839dc6789f19f820e9cbf70c60f41f3b057c59ece1d226d04db5aca447eb0e5+? ./natural.dhall
+ dhall-lang/Prelude/JSON/natural.dhall view
@@ -0,0 +1,31 @@+{-|+Create a JSON number from a Dhall `Natural`++```+let JSON = ./package.dhall+in  JSON.render (JSON.natural 42)+= "42"+```+-}+let JSON =+        missing+          sha256:40edbc9371979426df63e064333b02689b969c4cfbbccfa481216d2d1a6e9759+      ? ./Type.dhall++let natural+    : Natural → JSON+    = λ(x : Natural) →+      λ(JSON : Type) →+      λ ( json+        : { array : List JSON → JSON+          , bool : Bool → JSON+          , double : Double → JSON+          , integer : Integer → JSON+          , null : JSON+          , object : List { mapKey : Text, mapValue : JSON } → JSON+          , string : Text → JSON+          }+        ) →+        json.integer (Natural/toInteger x)++in  natural
+ dhall-lang/Prelude/JSON/null view
@@ -0,0 +1,3 @@+  missing+    sha256:1eeb9aee38eb8dde0e64efbaf60f24612c8194cc00b510bfb627c2ee2e1877b8+? ./null.dhall
+ dhall-lang/Prelude/JSON/null.dhall view
@@ -0,0 +1,30 @@+{-|+Create a JSON null++```+let JSON = ./package.dhall+in  JSON.render JSON.null+= "null"+```+-}+let JSON =+        missing+          sha256:40edbc9371979426df63e064333b02689b969c4cfbbccfa481216d2d1a6e9759+      ? ./Type.dhall++let null+    : JSON+    = λ(JSON : Type) →+      λ ( json+        : { array : List JSON → JSON+          , bool : Bool → JSON+          , double : Double → JSON+          , integer : Integer → JSON+          , null : JSON+          , object : List { mapKey : Text, mapValue : JSON } → JSON+          , string : Text → JSON+          }+        ) →+        json.null++in  null
+ dhall-lang/Prelude/JSON/number view
@@ -0,0 +1,3 @@+  missing+    sha256:e70162c73c4978ad0d0d99505f61c7d990f3abadfcc08b34388b29c0934a7a32+? ./number.dhall
+ dhall-lang/Prelude/JSON/number.dhall view
@@ -0,0 +1,28 @@+{-|+Create a JSON number from a Dhall `Double`++```+let JSON = ./package.dhall+in  JSON.render (JSON.number 42.0)+= "42.0"++let JSON = ./package.dhall+in  JSON.render (JSON.number -1.5e-10)+= "-1.5e-10"+```+-}+let JSON =+        missing+          sha256:40edbc9371979426df63e064333b02689b969c4cfbbccfa481216d2d1a6e9759+      ? ./Type.dhall++let double =+        missing+          sha256:e70162c73c4978ad0d0d99505f61c7d990f3abadfcc08b34388b29c0934a7a32+      ? ./double.dhall++let number+    : Double → JSON+    = double++in  number
+ dhall-lang/Prelude/JSON/object view
@@ -0,0 +1,3 @@+  missing+    sha256:869aede785c34798be9f9fd457ece73e7f683f352ae4555f791516a365faf4ac+? ./object.dhall
+ dhall-lang/Prelude/JSON/object.dhall view
@@ -0,0 +1,55 @@+{-|+Create a JSON object from a Dhall `Map`++```+let JSON = ./package.dhall+in  JSON.render+    ( JSON.object+      [ { mapKey = "foo", mapValue = JSON.double 1.0 }+      , { mapKey = "bar", mapValue = JSON.bool True  }+      ]+    )+= "{ \"foo\": 1.0, \"bar\": true }"++let JSON/Type = ./Type+let JSON = ./package.dhall+in  JSON.render+    (JSON.object ([] : List { mapKey : Text, mapValue : JSON/Type }))+= "{ }"+```+-}+let JSON =+        missing+          sha256:40edbc9371979426df63e064333b02689b969c4cfbbccfa481216d2d1a6e9759+      ? ./Type.dhall++let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ../List/map.dhall++let object+    : List { mapKey : Text, mapValue : JSON } → JSON+    = λ(x : List { mapKey : Text, mapValue : JSON }) →+      λ(JSON : Type) →+      λ ( json+        : { array : List JSON → JSON+          , bool : Bool → JSON+          , double : Double → JSON+          , integer : Integer → JSON+          , null : JSON+          , object : List { mapKey : Text, mapValue : JSON } → JSON+          , string : Text → JSON+          }+        ) →+        json.object+          ( List/map+              { mapKey : Text, mapValue : JSON@1 }+              { mapKey : Text, mapValue : JSON }+              ( λ(kv : { mapKey : Text, mapValue : JSON@1 }) →+                  { mapKey = kv.mapKey, mapValue = kv.mapValue JSON json }+              )+              x+          )++in  object
+ dhall-lang/Prelude/JSON/omitNullFields view
@@ -0,0 +1,3 @@+  missing+    sha256:e6850e70094540b75edeb46f4d6038324a62def8d63544a1e9541f79739db6f0+? ./omitNullFields.dhall
+ dhall-lang/Prelude/JSON/omitNullFields.dhall view
@@ -0,0 +1,145 @@+{-|+This utility omits all `null` record fields, which is often the idiomatic way+for a configuration to encode absent fields+-}+let JSON =+        missing+          sha256:5dc1135d5481cfd6fde625aaed9fcbdb7aa7c14f2e76726aa5fdef028a5c10f5+      ? ./core.dhall++let List/concatMap =+        missing+          sha256:3b2167061d11fda1e4f6de0522cbe83e0d5ac4ef5ddf6bb0b2064470c5d3fb64+      ? ../List/concatMap.dhall++let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ../List/map.dhall++let omitNullFields+    : JSON.Type → JSON.Type+    = λ(old : JSON.Type) →+      λ(JSON : Type) →+      λ ( json+        : { array : List JSON → JSON+          , bool : Bool → JSON+          , double : Double → JSON+          , integer : Integer → JSON+          , null : JSON+          , object : List { mapKey : Text, mapValue : JSON } → JSON+          , string : Text → JSON+          }+        ) →+        let result =+              old+                { value : JSON, isNull : Bool }+                { string =+                    λ(x : Text) → { value = json.string x, isNull = False }+                , double =+                    λ(x : Double) → { value = json.double x, isNull = False }+                , integer =+                    λ(x : Integer) → { value = json.integer x, isNull = False }+                , object =+                    λ ( keyValues+                      : List+                          { mapKey : Text+                          , mapValue : { value : JSON, isNull : Bool }+                          }+                      ) →+                      let value =+                            json.object+                              ( List/concatMap+                                  { mapKey : Text+                                  , mapValue : { value : JSON, isNull : Bool }+                                  }+                                  { mapKey : Text, mapValue : JSON }+                                  ( λ ( keyValue+                                      : { mapKey : Text+                                        , mapValue :+                                            { value : JSON, isNull : Bool }+                                        }+                                      ) →+                                      if    keyValue.mapValue.isNull+                                      then  [] : List+                                                   { mapKey : Text+                                                   , mapValue : JSON+                                                   }+                                      else  [   keyValue.{ mapKey }+                                              ∧ { mapValue =+                                                    keyValue.mapValue.value+                                                }+                                            ]+                                  )+                                  keyValues+                              )++                      in  { value, isNull = False }+                , array =+                    λ(xs : List { value : JSON, isNull : Bool }) →+                      let value =+                            json.array+                              ( List/map+                                  { value : JSON, isNull : Bool }+                                  JSON+                                  ( λ(x : { value : JSON, isNull : Bool }) →+                                      x.value+                                  )+                                  xs+                              )++                      in  { value, isNull = False }+                , bool = λ(x : Bool) → { value = json.bool x, isNull = False }+                , null = { value = json.null, isNull = True }+                }++        in  result.value++let property =+      λ(a : Text) →+      λ(b : Double) →+      λ(c : Bool) →+          assert+        :   omitNullFields+              ( JSON.object+                  ( toMap+                      { string = JSON.string a+                      , double = JSON.double b+                      , bool = JSON.bool c+                      , null = JSON.null+                      }+                  )+              )+          ≡ JSON.object+              ( toMap+                  { string = JSON.string a+                  , double = JSON.double b+                  , bool = JSON.bool c+                  }+              )++let example =+        assert+      :   omitNullFields+            ( JSON.object+                ( toMap+                    { array =+                        JSON.array [ JSON.object (toMap { null = JSON.null }) ]+                    }+                )+            )+        ≡ JSON.object+            ( toMap+                { array =+                    JSON.array+                      [ JSON.object+                          ([] : List { mapKey : Text, mapValue : JSON.Type })+                      ]+                }+            )++let example =+        assert+      : omitNullFields (JSON.array [ JSON.null ]) ≡ JSON.array [ JSON.null ]++in  omitNullFields
+ dhall-lang/Prelude/JSON/package.dhall view
@@ -0,0 +1,29 @@+  { render =+        missing+          sha256:36befdd8bb5a1c2b372709da245a8d074533b86429e137b894c08ad16fa34836+      ? ./render.dhall+  , renderCompact =+        missing+          sha256:e6c8809fbe193fddd430f94350d69cefd45e7aaf8bd379e51b750fde75008562+      ? ./renderCompact.dhall+  , renderYAML =+        missing+          sha256:bc71449397bbf48103c3ebbdd570cd27313115e94b2b1b96761d257d5c02d478+      ? ./renderYAML.dhall+  , omitNullFields =+        missing+          sha256:e6850e70094540b75edeb46f4d6038324a62def8d63544a1e9541f79739db6f0+      ? ./omitNullFields.dhall+  , tagInline =+        missing+          sha256:49559ac11906ba6cc9eac25753e31e7addb13bc760df108024174c55523984c4+      ? ./tagInline.dhall+  , tagNested =+        missing+          sha256:93a7415853b7677c832246efadc8e880c1b641a23589286a836a384ca311d26f+      ? ./tagNested.dhall+  }+∧ (   missing+        sha256:5dc1135d5481cfd6fde625aaed9fcbdb7aa7c14f2e76726aa5fdef028a5c10f5+    ? ./core.dhall+  )
+ dhall-lang/Prelude/JSON/render view
@@ -0,0 +1,3 @@+  missing+    sha256:36befdd8bb5a1c2b372709da245a8d074533b86429e137b894c08ad16fa34836+? ./render.dhall
+ dhall-lang/Prelude/JSON/render.dhall view
@@ -0,0 +1,52 @@+{-|+Render a `JSON` value as `Text`++This is useful for debugging `JSON` values or for tests.  For anything+more sophisticated you should use `dhall-to-json` or `dhall-to-yaml`+-}+let JSON =+        missing+          sha256:5dc1135d5481cfd6fde625aaed9fcbdb7aa7c14f2e76726aa5fdef028a5c10f5+      ? ./core.dhall++let renderAs =+        missing+          sha256:c23be039c9601a33d6546fd99a8d72bee8dde5f46176d57cc96613b31a3bb471+      ? ./renderAs.dhall++let Format =+        missing+          sha256:d7936b510cfc091faa994652af0eb5feb889cd44bc989edbe4f1eb8c5623caac+      ? ./Format.dhall++let render+    : JSON.Type → Text+    = renderAs Format.JSON++let example0 =+      let data =+              assert+            :   render+                  ( JSON.array+                      [ JSON.bool True+                      , JSON.string "Hello"+                      , JSON.object+                          [ { mapKey = "foo", mapValue = JSON.null }+                          , { mapKey = "bar", mapValue = JSON.double 1.0 }+                          ]+                      ]+                  )+              ≡ ''+                [+                  true,+                  "Hello",+                  {+                    "foo": null,+                    "bar": 1.0+                  }+                ]+                ''++      in  True++in  render
+ dhall-lang/Prelude/JSON/renderAs view
@@ -0,0 +1,3 @@+  missing+    sha256:c23be039c9601a33d6546fd99a8d72bee8dde5f46176d57cc96613b31a3bb471+? ./renderAs.dhall
+ dhall-lang/Prelude/JSON/renderAs.dhall view
@@ -0,0 +1,458 @@+--| Render a `JSON` value as `Text` in either JSON or YAML format.+let JSON =+        missing+          sha256:5dc1135d5481cfd6fde625aaed9fcbdb7aa7c14f2e76726aa5fdef028a5c10f5+      ? ./core.dhall++let Function/identity =+        missing+          sha256:f78b96792b459cb664f41c6119bd8897dd04353a3343521d436cd82ad71cb4d4+      ? ../Function/identity.dhall++let Text/concatMap =+        missing+          sha256:7a0b0b99643de69d6f94ba49441cd0fa0507cbdfa8ace0295f16097af37e226f+      ? ../Text/concatMap.dhall++let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ../List/map.dhall++let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ../NonEmpty/Type.dhall++let NonEmpty/toList =+        missing+          sha256:0977fe14b77232a4451dcf409c43df4589c4b3cdde7b613aab8df183be1b53f5+      ? ../NonEmpty/toList.dhall++let NonEmpty/concat =+        missing+          sha256:6d55181938c06c6b806877028f6a241912e9c0935d9a10dd958775bf21e0f64d+      ? ../NonEmpty/concat.dhall++let NonEmpty/map =+        missing+          sha256:93d53afe874bb2eed946c21ca5ada3c9716b7d00e6d8edfaba6484cd9c5a00bd+      ? ../NonEmpty/map.dhall++let NonEmpty/singleton =+        missing+          sha256:c9197aabe97695f7ca66f7419bf172d806b2c915594a8fc0d2ff6495db496ff2+      ? ../NonEmpty/singleton.dhall++let List/uncons+    : ∀(a : Type) → List a → Optional (NonEmpty a)+    = {- This version uses the `ls` argument only once to prevent cache blowups at the price+         of performing two passes over the list:+         A first one to reverse it, a second one with `List/fold` to determine+         the head element.+         See https://github.com/dhall-lang/dhall-lang/pull/1015#issuecomment-633381024+         for some context regarding the caching issue.+      -}+      λ(a : Type) →+      λ(ls : List a) →+        List/fold+          a+          (List/reverse a ls)+          (Optional (NonEmpty a))+          ( λ(x : a) →+            λ(acc : Optional (NonEmpty a)) →+              merge+                { None = Some (NonEmpty/singleton a x)+                , Some =+                    λ(ne : NonEmpty a) → Some (ne ⫽ { tail = ne.tail # [ x ] })+                }+                acc+          )+          (None (NonEmpty a))++let NonEmpty/mapHead+    : ∀(a : Type) → (a → a) → NonEmpty a → NonEmpty a+    = λ(a : Type) →+      λ(fn : a → a) →+      λ(ls : NonEmpty a) →+        ls ⫽ { head = fn ls.head }++let NonEmpty/mapTail+    : ∀(a : Type) → (a → a) → NonEmpty a → NonEmpty a+    = λ(a : Type) →+      λ(fn : a → a) →+      λ(ls : NonEmpty a) →+        ls ⫽ { tail = List/map a a fn ls.tail }++let NonEmpty/prepend+    : ∀(a : Type) → a → NonEmpty a → NonEmpty a+    = λ(a : Type) →+      λ(prefix : a) →+      λ(ls : NonEmpty a) →+        { head = prefix, tail = NonEmpty/toList a ls }++let NonYtpme+    : Type → Type+    = λ(a : Type) → { init : List a, last : a }++let List/unsnoc+    : ∀(a : Type) → List a → Optional (NonYtpme a)+    = λ(a : Type) →+      λ(ls : List a) →+        List/fold+          a+          ls+          (Optional (NonYtpme a))+          ( λ(x : a) →+            λ(acc : Optional (NonYtpme a)) →+              merge+                { None = Some { init = [] : List a, last = x }+                , Some =+                    λ(ny : NonYtpme a) → Some (ny ⫽ { init = [ x ] # ny.init })+                }+                acc+          )+          (None (NonYtpme a))++let NonEmpty/mapLast+    : ∀(a : Type) → (a → a) → NonEmpty a → NonEmpty a+    = λ(a : Type) →+      λ(fn : a → a) →+      λ(ls : NonEmpty a) →+        merge+          { Some = λ(x : NonYtpme a) → ls ⫽ { tail = x.init # [ fn x.last ] }+          , None = NonEmpty/singleton a (fn ls.head)+          }+          (List/unsnoc a ls.tail)++let NonEmpty/mapLeading+    : ∀(a : Type) → (a → a) → NonEmpty a → NonEmpty a+    = λ(a : Type) →+      λ(fn : a → a) →+      λ(ls : NonEmpty a) →+        merge+          { Some =+              λ(x : NonYtpme a) →+                { head = fn ls.head+                , tail = List/map a a fn x.init # [ x.last ]+                }+          , None = ls+          }+          (List/unsnoc a ls.tail)++let Lines+    : Type+    = NonEmpty Text++let Block+    : Type+    = < Simple : Text | Complex : Lines >++let Block/toLines+    : Block → Lines+    = λ(block : Block) →+        merge+          { Simple = NonEmpty/singleton Text+          , Complex = Function/identity Lines+          }+          block++let manyBlocks+    : ∀(a : Type) → Text → (NonEmpty a → Lines) → List a → Block+    = λ(a : Type) →+      λ(ifEmpty : Text) →+      λ(render : NonEmpty a → Lines) →+      λ(inputs : List a) →+        merge+          { Some = λ(inputs : NonEmpty a) → Block.Complex (render inputs)+          , None = Block.Simple ifEmpty+          }+          (List/uncons a inputs)++let blockToText+    : Block → Text+    = λ(block : Block) →+        Text/concatMap+          Text+          (λ(line : Text) → line ++ "\n")+          (NonEmpty/toList Text (Block/toLines block))++let addPrefix = λ(prefix : Text) → λ(line : Text) → prefix ++ line++let addIndent = addPrefix "  "++let indentTail = NonEmpty/mapTail Text addIndent++let Format =+        missing+          sha256:d7936b510cfc091faa994652af0eb5feb889cd44bc989edbe4f1eb8c5623caac+      ? ./Format.dhall++let ObjectField = { mapKey : Text, mapValue : Block }++let -- Essentially the same thing as `Text/show`, except that this does not+    -- escape `$`+    escape =+      List/fold+        (Text → Text)+        [ Text/replace "\"" "\\\""+        , Text/replace "\b" "\\b"+        , Text/replace "\f" "\\f"+        , Text/replace "\n" "\\n"+        , Text/replace "\r" "\\r"+        , Text/replace "\t" "\\t"+        , Text/replace "\\" "\\\\"+        ]+        Text+        (λ(replace : Text → Text) → λ(text : Text) → replace text)++let renderJSONStruct =+      λ(prefix : Text) →+      λ(suffix : Text) →+      λ(blocks : NonEmpty Lines) →+        let indent = List/map Text Text addIndent++        let appendComma+            : Lines → Lines+            = NonEmpty/mapLast Text (λ(line : Text) → line ++ ",")++        let blocks = NonEmpty/mapLeading Lines appendComma blocks++        let block = NonEmpty/concat Text blocks++        in  merge+              { None =+                  NonEmpty/singleton Text "${prefix} ${block.head} ${suffix}"+              , Some =+                  λ(ny : NonYtpme Text) →+                    { head = prefix+                    , tail =+                          indent ([ block.head ] # ny.init # [ ny.last ])+                        # [ suffix ]+                    }+              }+              (List/unsnoc Text block.tail)++let renderObject =+      λ(format : Format) →+      λ(fields : NonEmpty ObjectField) →+        let keystr = λ(field : ObjectField) → "\"${escape field.mapKey}\":"++        let prefixKeyOnFirst =+              λ(field : ObjectField) →+                NonEmpty/mapHead+                  Text+                  (addPrefix "${keystr field} ")+                  (Block/toLines field.mapValue)++        let prependKeyLine =+              λ(field : ObjectField) →+                NonEmpty/prepend+                  Text+                  (keystr field)+                  (Block/toLines field.mapValue)++        let renderYAMLField =+              λ(field : ObjectField) →+                merge+                  { Simple =+                      λ(line : Text) →+                        NonEmpty/singleton Text "${keystr field} ${line}"+                  , Complex = λ(_ : Lines) → indentTail (prependKeyLine field)+                  }+                  field.mapValue++        in  merge+              { JSON =+                  renderJSONStruct+                    "{"+                    "}"+                    (NonEmpty/map ObjectField Lines prefixKeyOnFirst fields)+              , YAML =+                  NonEmpty/concat+                    Text+                    (NonEmpty/map ObjectField Lines renderYAMLField fields)+              }+              format++let renderYAMLArrayField =+      λ(block : Block) →+        NonEmpty/mapHead+          Text+          (addPrefix "- ")+          (indentTail (Block/toLines block))++let renderArray =+      λ(format : Format) →+      λ(fields : NonEmpty Block) →+        merge+          { JSON =+              renderJSONStruct+                "["+                "]"+                (NonEmpty/map Block Lines Block/toLines fields)+          , YAML =+              NonEmpty/concat+                Text+                (NonEmpty/map Block Lines renderYAMLArrayField fields)+          }+          format++let renderAs+    : Format → JSON.Type → Text+    = λ(format : Format) →+      λ(json : JSON.Type) →+        blockToText+          ( json+              Block+              { string = λ(x : Text) → Block.Simple "\"${escape x}\""+              , double = λ(x : Double) → Block.Simple (Double/show x)+              , integer = λ(x : Integer) → Block.Simple (JSON.renderInteger x)+              , object = manyBlocks ObjectField "{}" (renderObject format)+              , array = manyBlocks Block "[]" (renderArray format)+              , bool =+                  λ(x : Bool) → Block.Simple (if x then "true" else "false")+              , null = Block.Simple "null"+              }+          )++let example0 =+      let data =+            JSON.array+              [ JSON.bool True+              , JSON.string "Hello"+              , JSON.object+                  [ { mapKey = "foo", mapValue = JSON.null }+                  , { mapKey = "bar", mapValue = JSON.double 1.0 }+                  ]+              ]++      let yaml =+              assert+            :   renderAs Format.YAML data+              ≡ ''+                - true+                - "Hello"+                - "foo": null+                  "bar": 1.0+                ''++      let json =+              assert+            :   renderAs Format.JSON data+              ≡ ''+                [+                  true,+                  "Hello",+                  {+                    "foo": null,+                    "bar": 1.0+                  }+                ]+                ''++      in  True++let example1 =+      let data =+            JSON.object+              [ { mapKey = "zero", mapValue = JSON.array ([] : List JSON.Type) }+              , { mapKey = "one", mapValue = JSON.array [ JSON.string "a" ] }+              , { mapKey = "two"+                , mapValue = JSON.array [ JSON.string "a", JSON.string "b" ]+                }+              ]++      let yaml =+              assert+            :   renderAs Format.YAML data+              ≡ ''+                "zero": []+                "one":+                  - "a"+                "two":+                  - "a"+                  - "b"+                ''++      let json =+              assert+            :   renderAs Format.JSON data+              ≡ ''+                {+                  "zero": [],+                  "one": [ "a" ],+                  "two": [+                    "a",+                    "b"+                  ]+                }+                ''++      in  True++let example2 =+      let data =+            JSON.object+              [ { mapKey = "zero"+                , mapValue =+                    JSON.object+                      (toMap {=} : List { mapKey : Text, mapValue : JSON.Type })+                }+              , { mapKey = "one"+                , mapValue = JSON.object (toMap { a = JSON.null })+                }+              , { mapKey = "two"+                , mapValue =+                    JSON.object (toMap { a = JSON.null, b = JSON.null })+                }+              ]++      let yaml =+              assert+            :   renderAs Format.YAML data+              ≡ ''+                "zero": {}+                "one":+                  "a": null+                "two":+                  "a": null+                  "b": null+                ''++      let json =+              assert+            :   renderAs Format.JSON data+              ≡ ''+                {+                  "zero": {},+                  "one": { "a": null },+                  "two": {+                    "a": null,+                    "b": null+                  }+                }+                ''++      in  True++let example3 =+      let specialCharacters =+            ''+            "\${"\b\f"}+            ${"\r"}	$''++      let data =+            JSON.object+              [ { mapKey = specialCharacters+                , mapValue = JSON.string specialCharacters+                }+              ]++      in    assert+          :   renderAs Format.JSON data+            ≡ ''+              { "\"\\\b\f\n\r\t$": "\"\\\b\f\n\r\t$" }+              ''++in  renderAs
+ dhall-lang/Prelude/JSON/renderCompact.dhall view
@@ -0,0 +1,61 @@+--| This renders JSON on a single line+let JSON =+        missing+          sha256:5dc1135d5481cfd6fde625aaed9fcbdb7aa7c14f2e76726aa5fdef028a5c10f5+      ? ./core.dhall++let Text/concatMapSep =+        missing+          sha256:c272aca80a607bc5963d1fcb38819e7e0d3e72ac4d02b1183b1afb6a91340840+      ? ../Text/concatMapSep++let renderInteger =+        missing+          sha256:15b8d2ae46d5002832741927af787761df49798c911e2bf85db7a7b9cb5c078c+      ? ./renderInteger.dhall++let renderCompact+    : JSON.Type → Text+    = λ(j : JSON.Type) →+        j+          Text+          { string = Text/show+          , double = Double/show+          , integer = renderInteger+          , object =+              λ(x : List { mapKey : Text, mapValue : Text }) →+                let body =+                      Text/concatMapSep+                        ","+                        { mapKey : Text, mapValue : Text }+                        ( λ(e : { mapKey : Text, mapValue : Text }) →+                            " ${Text/show e.mapKey}: ${e.mapValue}"+                        )+                        x++                in  "{${body} }"+          , array =+              λ(x : List Text) →+                let body = Text/concatMapSep "," Text (λ(y : Text) → " ${y}") x++                in  "[${body} ]"+          , bool = λ(x : Bool) → if x then "true" else "false"+          , null = "null"+          }++let example =+        assert+      :   renderCompact+            ( JSON.array+                [ JSON.bool True+                , JSON.string "Hello"+                , JSON.object+                    [ { mapKey = "foo", mapValue = JSON.null }+                    , { mapKey = "bar", mapValue = JSON.double 1.1 }+                    , { mapKey = "baz", mapValue = JSON.integer +2 }+                    ]+                ]+            )+        ≡ "[ true, \"Hello\", { \"foo\": null, \"bar\": 1.1, \"baz\": 2 } ]"++in  renderCompact
+ dhall-lang/Prelude/JSON/renderInteger.dhall view
@@ -0,0 +1,23 @@+{-|+Render an `Integer` value as a `JSON number`, according to the JSON standard, in+which a number may not start with a plus sign (`+`).+-}+let Integer/nonNegative =+        missing+          sha256:b463373f070df6b1c8c7082051e0810fee38b360bab35256187c8c2b6af5c663+      ? ../Integer/nonNegative.dhall++let renderInteger+    : Integer → Text+    = λ(integer : Integer) →+        if    Integer/nonNegative integer+        then  Natural/show (Integer/clamp integer)+        else  Integer/show integer++let positive = assert : renderInteger +1 ≡ "1"++let zero = assert : renderInteger +0 ≡ "0"++let negative = assert : renderInteger -1 ≡ "-1"++in  renderInteger
+ dhall-lang/Prelude/JSON/renderYAML view
@@ -0,0 +1,3 @@+  missing+    sha256:bc71449397bbf48103c3ebbdd570cd27313115e94b2b1b96761d257d5c02d478+? ./renderYAML.dhall
+ dhall-lang/Prelude/JSON/renderYAML.dhall view
@@ -0,0 +1,49 @@+{-|+Render a `JSON` value as `Text` in YAML format.++The generated YAML text will only contain escaped object keys and+string values and might therefore not be very human readable.++However, it is useful for debugging `JSON` values or for tests.+For anything more sophisticated you should use `dhall-to-json` or+`dhall-to-yaml`.+-}+let JSON =+        missing+          sha256:5dc1135d5481cfd6fde625aaed9fcbdb7aa7c14f2e76726aa5fdef028a5c10f5+      ? ./core.dhall++let renderAs =+        missing+          sha256:c23be039c9601a33d6546fd99a8d72bee8dde5f46176d57cc96613b31a3bb471+      ? ./renderAs.dhall++let Format =+        missing+          sha256:d7936b510cfc091faa994652af0eb5feb889cd44bc989edbe4f1eb8c5623caac+      ? ./Format.dhall++let renderYAML+    : JSON.Type → Text+    = renderAs Format.YAML++let example0 =+        assert+      :   renderYAML+            ( JSON.array+                [ JSON.bool True+                , JSON.string "Hello"+                , JSON.object+                    [ { mapKey = "foo", mapValue = JSON.null }+                    , { mapKey = "bar", mapValue = JSON.double 1.0 }+                    ]+                ]+            )+        ≡ ''+          - true+          - "Hello"+          - "foo": null+            "bar": 1.0+          ''++in  renderYAML
+ dhall-lang/Prelude/JSON/string view
@@ -0,0 +1,3 @@+  missing+    sha256:7ddb3a3b9f3ed09ed011d621a10ad9825185cd03503be98a81d42f6afb77940e+? ./string.dhall
+ dhall-lang/Prelude/JSON/string.dhall view
@@ -0,0 +1,35 @@+{-|+Create a JSON string from Dhall `Text`++```+let JSON = ./package.dhall+in  JSON.render (JSON.string "ABC $ \" 🙂")+= "\"ABC \\u0024 \\\" 🙂\""++let JSON = ./package.dhall+in  JSON.render (JSON.string "")+= "\"\""+```+-}+let JSON =+        missing+          sha256:40edbc9371979426df63e064333b02689b969c4cfbbccfa481216d2d1a6e9759+      ? ./Type.dhall++let string+    : Text → JSON+    = λ(x : Text) →+      λ(JSON : Type) →+      λ ( json+        : { array : List JSON → JSON+          , bool : Bool → JSON+          , double : Double → JSON+          , integer : Integer → JSON+          , null : JSON+          , object : List { mapKey : Text, mapValue : JSON } → JSON+          , string : Text → JSON+          }+        ) →+        json.string x++in  string
+ dhall-lang/Prelude/JSON/tagInline view
@@ -0,0 +1,3 @@+  missing+    sha256:49559ac11906ba6cc9eac25753e31e7addb13bc760df108024174c55523984c4+? ./tagInline.dhall
+ dhall-lang/Prelude/JSON/tagInline.dhall view
@@ -0,0 +1,29 @@+--| Prepare a union value for JSON- or YAML-encoding with the inline layout+let Nesting =+        missing+          sha256:6284802edd41d5d725aa1ec7687e614e21ad1be7e14dd10996bfa9625105c335+      ? ./Nesting.dhall++let Tagged =+        missing+          sha256:21feca7d2b23f210d0696131d792e18a7d24fdcc85d41a49ba85b98670eba194+      ? ./Tagged.dhall++let tagInline+    : Text → ∀(a : Type) → a → Tagged a+    = λ(tagFieldName : Text) →+      λ(a : Type) →+      λ(contents : a) →+        { nesting = Nesting.Inline, field = tagFieldName, contents }++let example0 =+      let Example = < Left : { foo : Natural } | Right : { bar : Bool } >++      in    assert+          :   tagInline "name" Example (Example.Left { foo = 2 })+            ≡ { field = "name"+              , nesting = Nesting.Inline+              , contents = Example.Left { foo = 2 }+              }++in  tagInline
+ dhall-lang/Prelude/JSON/tagNested view
@@ -0,0 +1,3 @@+  missing+    sha256:93a7415853b7677c832246efadc8e880c1b641a23589286a836a384ca311d26f+? ./tagNested.dhall
+ dhall-lang/Prelude/JSON/tagNested.dhall view
@@ -0,0 +1,33 @@+--| Prepare a union value for JSON- or YAML-encoding with the nested layout+let Nesting =+        missing+          sha256:6284802edd41d5d725aa1ec7687e614e21ad1be7e14dd10996bfa9625105c335+      ? ./Nesting.dhall++let Tagged =+        missing+          sha256:21feca7d2b23f210d0696131d792e18a7d24fdcc85d41a49ba85b98670eba194+      ? ./Tagged.dhall++let tagNested+    : Text → Text → ∀(a : Type) → a → Tagged a+    = λ(contentsFieldName : Text) →+      λ(tagFieldName : Text) →+      λ(a : Type) →+      λ(contents : a) →+        { nesting = Nesting.Nested contentsFieldName+        , field = tagFieldName+        , contents+        }++let example0 =+      let Example = < Left : { foo : Natural } | Right : { bar : Bool } >++      in    assert+          :   tagNested "value" "name" Example (Example.Left { foo = 2 })+            ≡ { field = "name"+              , nesting = Nesting.Nested "value"+              , contents = Example.Left { foo = 2 }+              }++in  tagNested
+ dhall-lang/Prelude/List/all view
@@ -0,0 +1,3 @@+  missing+    sha256:7ac5bb6f77e9ffe9e2356d90968d39764a9a32f75980206e6b12f815bb83dd15+? ./all.dhall
+ dhall-lang/Prelude/List/all.dhall view
@@ -0,0 +1,16 @@+{-|+Returns `True` if the supplied function returns `True` for all elements in the+`List`+-}+let all+    : ∀(a : Type) → (a → Bool) → List a → Bool+    = λ(a : Type) →+      λ(f : a → Bool) →+      λ(xs : List a) →+        List/fold a xs Bool (λ(x : a) → λ(r : Bool) → f x && r) True++let example0 = assert : all Natural Natural/even [ 2, 3, 5 ] ≡ False++let example1 = assert : all Natural Natural/even ([] : List Natural) ≡ True++in  all
+ dhall-lang/Prelude/List/any view
@@ -0,0 +1,3 @@+  missing+    sha256:b8e9e13b25e799f342a81f6eda4075906eb1a19dfdcb10a0ca25925eba4033b8+? ./any.dhall
+ dhall-lang/Prelude/List/any.dhall view
@@ -0,0 +1,16 @@+{-|+Returns `True` if the supplied function returns `True` for any element in the+`List`+-}+let any+    : ∀(a : Type) → (a → Bool) → List a → Bool+    = λ(a : Type) →+      λ(f : a → Bool) →+      λ(xs : List a) →+        List/fold a xs Bool (λ(x : a) → λ(r : Bool) → f x || r) False++let example0 = assert : any Natural Natural/even [ 2, 3, 5 ] ≡ True++let example1 = assert : any Natural Natural/even ([] : List Natural) ≡ False++in  any
+ dhall-lang/Prelude/List/build view
@@ -0,0 +1,3 @@+  missing+    sha256:8cf73fc1e115cfcb79bb9cd490bfcbd45c824e93c57a0e64c86c0c72e9ebbe42+? ./build.dhall
+ dhall-lang/Prelude/List/build.dhall view
@@ -0,0 +1,30 @@+--| `build` is the inverse of `fold`+let build+    : ∀(a : Type) →+      (∀(list : Type) → ∀(cons : a → list → list) → ∀(nil : list) → list) →+        List a+    = List/build++let example0 =+        assert+      :   build+            Text+            ( λ(list : Type) →+              λ(cons : Text → list → list) →+              λ(nil : list) →+                cons "ABC" (cons "DEF" nil)+            )+        ≡ [ "ABC", "DEF" ]++let example1 =+        assert+      :   build+            Text+            ( λ(list : Type) →+              λ(cons : Text → list → list) →+              λ(nil : list) →+                nil+            )+        ≡ ([] : List Text)++in  build
+ dhall-lang/Prelude/List/concat view
@@ -0,0 +1,3 @@+  missing+    sha256:54e43278be13276e03bd1afa89e562e94a0a006377ebea7db14c7562b0de292b+? ./concat.dhall
+ dhall-lang/Prelude/List/concat.dhall view
@@ -0,0 +1,34 @@+--| Concatenate a `List` of `List`s into a single `List`+let concat+    : ∀(a : Type) → List (List a) → List a+    = λ(a : Type) →+      λ(xss : List (List a)) →+        List/build+          a+          ( λ(list : Type) →+            λ(cons : a → list → list) →+            λ(nil : list) →+              List/fold+                (List a)+                xss+                list+                (λ(xs : List a) → λ(ys : list) → List/fold a xs list cons ys)+                nil+          )++let example0 =+        assert+      :   concat Natural [ [ 0, 1, 2 ], [ 3, 4 ], [ 5, 6, 7, 8 ] ]+        ≡ [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]++let example1 =+        assert+      :   concat+            Natural+            [ [] : List Natural, [] : List Natural, [] : List Natural ]+        ≡ ([] : List Natural)++let example2 =+      assert : concat Natural ([] : List (List Natural)) ≡ ([] : List Natural)++in  concat
+ dhall-lang/Prelude/List/concatMap view
@@ -0,0 +1,3 @@+  missing+    sha256:3b2167061d11fda1e4f6de0522cbe83e0d5ac4ef5ddf6bb0b2064470c5d3fb64+? ./concatMap.dhall
+ dhall-lang/Prelude/List/concatMap.dhall view
@@ -0,0 +1,32 @@+{-|+Transform a list by applying a function to each element and flattening the+results+-}+let concatMap+    : ∀(a : Type) → ∀(b : Type) → (a → List b) → List a → List b+    = λ(a : Type) →+      λ(b : Type) →+      λ(f : a → List b) →+      λ(xs : List a) →+        List/build+          b+          ( λ(list : Type) →+            λ(cons : b → list → list) →+              List/fold a xs list (λ(x : a) → List/fold b (f x) list cons)+          )++let example0 =+        assert+      :   concatMap Natural Natural (λ(n : Natural) → [ n, n ]) [ 2, 3, 5 ]+        ≡ [ 2, 2, 3, 3, 5, 5 ]++let example1 =+        assert+      :   concatMap+            Natural+            Natural+            (λ(n : Natural) → [ n, n ])+            ([] : List Natural)+        ≡ ([] : List Natural)++in  concatMap
+ dhall-lang/Prelude/List/default view
@@ -0,0 +1,3 @@+  missing+    sha256:fd77809e497227403f42848ffcda05a3efab442d961027c34f3e31d5d24e6379+? ./default.dhall
+ dhall-lang/Prelude/List/default.dhall view
@@ -0,0 +1,15 @@+{-|+Unpack an `Optional` containing a `List`, defaulting to an empty list when the+`Optional` is `None`+-}+let default+    : ∀(a : Type) → Optional (List a) → List a+    = λ(a : Type) →+      λ(o : Optional (List a)) →+        merge { Some = λ(l : List a) → l, None = [] : List a } o++let example0 = assert : default Bool (None (List Bool)) ≡ ([] : List Bool)++let example1 = assert : default Bool (Some [ True ]) ≡ [ True ]++in  default
+ dhall-lang/Prelude/List/drop view
@@ -0,0 +1,3 @@+  missing+    sha256:af983ba3ead494dd72beed05c0f3a17c36a4244adedf7ced502c6512196ed0cf+? ./drop.dhall
+ dhall-lang/Prelude/List/drop.dhall view
@@ -0,0 +1,28 @@+--| Remove first `n` elements of a list+let Natural/greaterThanEqual =+        missing+          sha256:30ebfab0febd7aa0ccccfdf3dc36ee6d50f0117f35dd4a9b034750b7e885a1a4+      ? ../Natural/greaterThanEqual.dhall++let drop+    : ∀(n : Natural) → ∀(a : Type) → List a → List a+    = λ(n : Natural) →+      λ(a : Type) →+      λ(xs : List a) →+        List/fold+          { index : Natural, value : a }+          (List/indexed a xs)+          (List a)+          ( λ(x : { index : Natural, value : a }) →+            λ(xs : List a) →+              if    Natural/greaterThanEqual x.index n+              then  [ x.value ] # xs+              else  xs+          )+          ([] : List a)++let example = assert : drop 2 Natural [ 2, 3, 5 ] ≡ [ 5 ]++let example = assert : drop 5 Natural [ 2, 3, 5 ] ≡ ([] : List Natural)++in  drop
+ dhall-lang/Prelude/List/empty view
@@ -0,0 +1,3 @@+  missing+    sha256:b2f561f35098c457353723c93a22bd5de28d26ecc5370814bef9dfda421e0147+? ./empty.dhall
+ dhall-lang/Prelude/List/empty.dhall view
@@ -0,0 +1,8 @@+--| An empty list of the given type+let empty+    : ∀(a : Type) → List a+    = λ(a : Type) → [] : List a++let example0 = assert : empty Bool ≡ ([] : List Bool)++in  empty
+ dhall-lang/Prelude/List/filter view
@@ -0,0 +1,3 @@+  missing+    sha256:8ebfede5bbfe09675f246c33eb83964880ac615c4b1be8d856076fdbc4b26ba6+? ./filter.dhall
+ dhall-lang/Prelude/List/filter.dhall view
@@ -0,0 +1,22 @@+--| Only keep elements of the list where the supplied function returns `True`+let filter+    : ∀(a : Type) → (a → Bool) → List a → List a+    = λ(a : Type) →+      λ(f : a → Bool) →+      λ(xs : List a) →+        List/build+          a+          ( λ(list : Type) →+            λ(cons : a → list → list) →+              List/fold+                a+                xs+                list+                (λ(x : a) → λ(xs : list) → if f x then cons x xs else xs)+          )++let example0 = assert : filter Natural Natural/even [ 2, 3, 5 ] ≡ [ 2 ]++let example1 = assert : filter Natural Natural/odd [ 2, 3, 5 ] ≡ [ 3, 5 ]++in  filter
+ dhall-lang/Prelude/List/filterMap.dhall view
@@ -0,0 +1,45 @@+--| Transform a list by applying a function to each element and omitting None results.+let List/concatMap =+        missing+          sha256:3b2167061d11fda1e4f6de0522cbe83e0d5ac4ef5ddf6bb0b2064470c5d3fb64+      ? ./concatMap.dhall++let Optional/toList =+        missing+          sha256:d78f160c619119ef12389e48a629ce293d69f7624c8d016b7a4767ab400344c4+      ? ../Optional/toList.dhall++let filterMap+    : ∀(a : Type) → ∀(b : Type) → (a → Optional b) → List a → List b+    = λ(a : Type) →+      λ(b : Type) →+      λ(f : a → Optional b) →+        List/concatMap a b (λ(x : a) → Optional/toList b (f x))++let example0 =+        assert+      :   filterMap+            (List Natural)+            Natural+            (List/head Natural)+            [ [ 1 ], [] : List Natural, [ 3, 4 ] ]+        ≡ [ 1, 3 ]++let example1 =+      let Example = < Left : Bool | Right : Natural >++      in    assert+          :   filterMap+                Example+                Natural+                ( λ(x : Example) →+                    merge+                      { Left = λ(_ : Bool) → None Natural+                      , Right = λ(n : Natural) → Some n+                      }+                      x+                )+                [ Example.Left False, Example.Right 2, Example.Left True ]+            ≡ [ 2 ]++in  filterMap
+ dhall-lang/Prelude/List/fold view
@@ -0,0 +1,3 @@+  missing+    sha256:10bb945c25ab3943bd9df5a32e633cbfae112b7d3af38591784687e436a8d814+? ./fold.dhall
+ dhall-lang/Prelude/List/fold.dhall view
@@ -0,0 +1,43 @@+{-|+`fold` is the primitive function for consuming `List`s++If you treat the list `[ x, y, z ]` as `cons x (cons y (cons z nil))`, then a+`fold` just replaces each `cons` and `nil` with something else+-}+let fold+    : ∀(a : Type) →+      List a →+      ∀(list : Type) →+      ∀(cons : a → list → list) →+      ∀(nil : list) →+        list+    = List/fold++let example0 =+        assert+      :   fold+            Natural+            [ 2, 3, 5 ]+            Text+            (λ(x : Natural) → λ(y : Text) → Natural/show x ++ y)+            "0"+        ≡ "2350"++let example1 =+      λ(nil : Text) →+          assert+        :   fold+              Natural+              [ 2, 3, 5 ]+              Text+              (λ(x : Natural) → λ(y : Text) → Natural/show x ++ y)+              nil+          ≡ "2" ++ ("3" ++ ("5" ++ nil))++let example2 =+      λ(cons : Natural → Text → Text) →+      λ(nil : Text) →+          assert+        : fold Natural [ 2, 3, 5 ] Text cons nil ≡ cons 2 (cons 3 (cons 5 nil))++in  fold
+ dhall-lang/Prelude/List/foldLeft.dhall view
@@ -0,0 +1,60 @@+{-|+`foldLeft` is like `List/fold` except that the accumulation starts from the left++If you treat the list `[ x, y, z ]` as `cons (cons (cons nil x) y) z`, then+`foldLeft` just replaces each `cons` and `nil` with something else+-}+let foldLeft+    : ∀(a : Type) →+      List a →+      ∀(list : Type) →+      ∀(cons : list → a → list) →+      ∀(nil : list) →+        list+    = λ(a : Type) →+      λ(xs : List a) →+      λ(list : Type) →+      λ(cons : list → a → list) →+      λ(nil : list) →+        List/fold+          a+          xs+          (list → list)+          (λ(x : a) → λ(f : list → list) → λ(l : list) → f (cons l x))+          (λ(l : list) → l)+          nil++let example0 =+        assert+      :   foldLeft+            Natural+            [ 2, 3, 5 ]+            Text+            (λ(x : Text) → λ(y : Natural) → x ++ Natural/show y)+            "0"+        ≡ "0235"++let example1 =+        assert+      :   ( λ(nil : Text) →+              foldLeft+                Natural+                [ 2, 3, 5 ]+                Text+                (λ(x : Text) → λ(y : Natural) → x ++ Natural/show y)+                nil+          )+        ≡ (λ(nil : Text) → nil ++ "2" ++ "3" ++ "5")++let example2 =+        assert+      :   ( λ(cons : Text → Natural → Text) →+            λ(nil : Text) →+              foldLeft Natural [ 2, 3, 5 ] Text cons nil+          )+        ≡ ( λ(cons : Text → Natural → Text) →+            λ(nil : Text) →+              cons (cons (cons nil 2) 3) 5+          )++in  foldLeft
+ dhall-lang/Prelude/List/generate view
@@ -0,0 +1,3 @@+  missing+    sha256:78ff1ad96c08b88a8263eea7bc8381c078225cfcb759c496f792edb5a5e0b1a4+? ./generate.dhall
+ dhall-lang/Prelude/List/generate.dhall view
@@ -0,0 +1,35 @@+{-|+Build a list by calling the supplied function on all `Natural` numbers from `0`+up to but not including the supplied `Natural` number+-}+let generate+    : Natural → ∀(a : Type) → (Natural → a) → List a+    = λ(n : Natural) →+      λ(a : Type) →+      λ(f : Natural → a) →+        List/build+          a+          ( λ(list : Type) →+            λ(cons : a → list → list) →+              List/fold+                { index : Natural, value : {} }+                ( List/indexed+                    {}+                    ( List/build+                        {}+                        ( λ(list : Type) →+                          λ(cons : {} → list → list) →+                            Natural/fold n list (cons {=})+                        )+                    )+                )+                list+                (λ(x : { index : Natural, value : {} }) → cons (f x.index))+          )++let example0 =+      assert : generate 5 Bool Natural/even ≡ [ True, False, True, False, True ]++let example1 = assert : generate 0 Bool Natural/even ≡ ([] : List Bool)++in  generate
+ dhall-lang/Prelude/List/head view
@@ -0,0 +1,3 @@+  missing+    sha256:0d2e65ba0aea908377e46d22020dc3ad970284f4ee4eb8e6b8c51e53038c0026+? ./head.dhall
+ dhall-lang/Prelude/List/head.dhall view
@@ -0,0 +1,10 @@+--| Retrieve the first element of the list+let head+    : ∀(a : Type) → List a → Optional a+    = List/head++let example0 = assert : head Natural [ 0, 1, 2 ] ≡ Some 0++let example1 = assert : head Natural ([] : List Natural) ≡ None Natural++in  head
+ dhall-lang/Prelude/List/index view
@@ -0,0 +1,3 @@+  missing+    sha256:e657b55ecae4d899465c3032cb1a64c6aa6dc2aa3034204f3c15ce5c96c03e63+? ./index.dhall
+ dhall-lang/Prelude/List/index.dhall view
@@ -0,0 +1,18 @@+--| Retrieve an element from a `List` using its 0-based index+let drop =+        missing+          sha256:af983ba3ead494dd72beed05c0f3a17c36a4244adedf7ced502c6512196ed0cf+      ? ./drop.dhall++let index+    : Natural → ∀(a : Type) → List a → Optional a+    = λ(n : Natural) → λ(a : Type) → λ(xs : List a) → List/head a (drop n a xs)++let property =+      λ(n : Natural) → λ(a : Type) → assert : index n a ([] : List a) ≡ None a++let example0 = assert : index 1 Natural [ 2, 3, 5 ] ≡ Some 3++let example1 = assert : index 1 Natural ([] : List Natural) ≡ None Natural++in  index
+ dhall-lang/Prelude/List/indexed view
@@ -0,0 +1,3 @@+  missing+    sha256:58bb44457fa81adf26f5123c1b2e8bef0c5aa22dac5fa5ebdfb7da84563b027f+? ./indexed.dhall
+ dhall-lang/Prelude/List/indexed.dhall view
@@ -0,0 +1,19 @@+--| Tag each element of the list with its index+let indexed+    : ∀(a : Type) → List a → List { index : Natural, value : a }+    = List/indexed++let example0 =+        assert+      :   indexed Bool [ True, False, True ]+        ≡ [ { index = 0, value = True }+          , { index = 1, value = False }+          , { index = 2, value = True }+          ]++let example1 =+        assert+      :   indexed Bool ([] : List Bool)+        ≡ ([] : List { index : Natural, value : Bool })++in  indexed
+ dhall-lang/Prelude/List/iterate view
@@ -0,0 +1,3 @@+  missing+    sha256:e4999ccce190a2e2a6ab9cb188e3af6c40df474087827153005293f11bfe1d26+? ./iterate.dhall
+ dhall-lang/Prelude/List/iterate.dhall view
@@ -0,0 +1,42 @@+{-|+Generate a list of the specified length given a seed value and transition+function+-}+let iterate+    : Natural → ∀(a : Type) → (a → a) → a → List a+    = λ(n : Natural) →+      λ(a : Type) →+      λ(f : a → a) →+      λ(x : a) →+        List/build+          a+          ( λ(list : Type) →+            λ(cons : a → list → list) →+              List/fold+                { index : Natural, value : {} }+                ( List/indexed+                    {}+                    ( List/build+                        {}+                        ( λ(list : Type) →+                          λ(cons : {} → list → list) →+                            Natural/fold n list (cons {=})+                        )+                    )+                )+                list+                ( λ(y : { index : Natural, value : {} }) →+                    cons (Natural/fold y.index a f x)+                )+          )++let example0 =+        assert+      :   iterate 10 Natural (λ(x : Natural) → x * 2) 1+        ≡ [ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 ]++let example1 =+        assert+      : iterate 0 Natural (λ(x : Natural) → x * 2) 1 ≡ ([] : List Natural)++in  iterate
+ dhall-lang/Prelude/List/last view
@@ -0,0 +1,3 @@+  missing+    sha256:741226b741af152a1638491cdff7f3aa74baf080ada2e63429483f3d195a984d+? ./last.dhall
+ dhall-lang/Prelude/List/last.dhall view
@@ -0,0 +1,10 @@+--| Retrieve the last element of the list+let last+    : ∀(a : Type) → List a → Optional a+    = List/last++let example0 = assert : last Natural [ 0, 1, 2 ] ≡ Some 2++let example1 = assert : last Natural ([] : List Natural) ≡ None Natural++in  last
+ dhall-lang/Prelude/List/length view
@@ -0,0 +1,3 @@+  missing+    sha256:42c6812c7a9e3c6e6fad88f77c5b3849503964e071cb784e22c38c888a401461+? ./length.dhall
+ dhall-lang/Prelude/List/length.dhall view
@@ -0,0 +1,10 @@+--| Returns the number of elements in a list+let length+    : ∀(a : Type) → List a → Natural+    = List/length++let example0 = assert : length Natural [ 0, 1, 2 ] ≡ 3++let example1 = assert : length Natural ([] : List Natural) ≡ 0++in  length
+ dhall-lang/Prelude/List/map view
@@ -0,0 +1,3 @@+  missing+    sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+? ./map.dhall
+ dhall-lang/Prelude/List/map.dhall view
@@ -0,0 +1,23 @@+--| Transform a list by applying a function to each element+let map+    : ∀(a : Type) → ∀(b : Type) → (a → b) → List a → List b+    = λ(a : Type) →+      λ(b : Type) →+      λ(f : a → b) →+      λ(xs : List a) →+        List/build+          b+          ( λ(list : Type) →+            λ(cons : b → list → list) →+              List/fold a xs list (λ(x : a) → cons (f x))+          )++let example0 =+        assert+      : map Natural Bool Natural/even [ 2, 3, 5 ] ≡ [ True, False, False ]++let example1 =+        assert+      : map Natural Bool Natural/even ([] : List Natural) ≡ ([] : List Bool)++in  map
+ dhall-lang/Prelude/List/mapMaybe.dhall view
@@ -0,0 +1,37 @@+--| Apply a function across a list, keeping only the `Some` results.+let List/unpackOptionals =+        missing+          sha256:0cbaa920f429cf7fc3907f8a9143203fe948883913560e6e1043223e6b3d05e4+      ? ./unpackOptionals.dhall++let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ./map.dhall++let mapMaybe+    : ∀(a : Type) → ∀(b : Type) → (a → Optional b) → List a → List b+    = λ(a : Type) →+      λ(b : Type) →+      λ(f : a → Optional b) →+      λ(xs : List a) →+        List/unpackOptionals b (List/map a (Optional b) f xs)++let property =+      λ(a : Type) →+      λ(b : Type) →+      λ(f : a → Optional b) →+        assert : mapMaybe a b f ([] : List a) ≡ ([] : List b)++let example0 =+        assert+      :   mapMaybe+            Natural+            Text+            ( λ(n : Natural) →+                if Natural/isZero n then None Text else Some (Natural/show n)+            )+            [ 0, 1, 2, 3 ]+        ≡ [ "1", "2", "3" ]++in  mapMaybe
+ dhall-lang/Prelude/List/mapWithIndex.dhall view
@@ -0,0 +1,41 @@+--| Transform a list by applying a function to each element with its index+let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ./map.dhall++let List/mapWithIndex+    : ∀(a : Type) → ∀(b : Type) → (Natural → a → b) → List a → List b+    = λ(a : Type) →+      λ(b : Type) →+      λ(f : Natural → a → b) →+      λ(xs : List a) →+        List/map+          { index : Natural, value : a }+          b+          (λ(i : { index : Natural, value : a }) → f i.index i.value)+          (List/indexed a xs)++let List/empty =+        missing+          sha256:b2f561f35098c457353723c93a22bd5de28d26ecc5370814bef9dfda421e0147+      ? ./empty.dhall++let List/replicate =+        missing+          sha256:d4250b45278f2d692302489ac3e78280acb238d27541c837ce46911ff3baa347+      ? ./replicate.dhall++let example0 =+        assert+      :   List/mapWithIndex+            Text+            (List Text)+            ( λ(index : Natural) →+              λ(value : Text) →+                List/replicate index Text value+            )+            [ "A", "B", "C" ]+        ≡ [ List/empty Text, [ "B" ], [ "C", "C" ] ]++in  List/mapWithIndex
+ dhall-lang/Prelude/List/null view
@@ -0,0 +1,3 @@+  missing+    sha256:2338e39637e9a50d66ae1482c0ed559bbcc11e9442bfca8f8c176bbcd9c4fc80+? ./null.dhall
+ dhall-lang/Prelude/List/null.dhall view
@@ -0,0 +1,10 @@+--| Returns `True` if the `List` is empty and `False` otherwise+let null+    : ∀(a : Type) → List a → Bool+    = λ(a : Type) → λ(xs : List a) → Natural/isZero (List/length a xs)++let example0 = assert : null Natural [ 0, 1, 2 ] ≡ False++let example1 = assert : null Natural ([] : List Natural) ≡ True++in  null
+ dhall-lang/Prelude/List/package.dhall view
@@ -0,0 +1,125 @@+{ all =+      missing+        sha256:7ac5bb6f77e9ffe9e2356d90968d39764a9a32f75980206e6b12f815bb83dd15+    ? ./all.dhall+, any =+      missing+        sha256:b8e9e13b25e799f342a81f6eda4075906eb1a19dfdcb10a0ca25925eba4033b8+    ? ./any.dhall+, build =+      missing+        sha256:8cf73fc1e115cfcb79bb9cd490bfcbd45c824e93c57a0e64c86c0c72e9ebbe42+    ? ./build.dhall+, concat =+      missing+        sha256:54e43278be13276e03bd1afa89e562e94a0a006377ebea7db14c7562b0de292b+    ? ./concat.dhall+, concatMap =+      missing+        sha256:3b2167061d11fda1e4f6de0522cbe83e0d5ac4ef5ddf6bb0b2064470c5d3fb64+    ? ./concatMap.dhall+, default =+      missing+        sha256:fd77809e497227403f42848ffcda05a3efab442d961027c34f3e31d5d24e6379+    ? ./default.dhall+, drop =+      missing+        sha256:af983ba3ead494dd72beed05c0f3a17c36a4244adedf7ced502c6512196ed0cf+    ? ./drop.dhall+, empty =+      missing+        sha256:b2f561f35098c457353723c93a22bd5de28d26ecc5370814bef9dfda421e0147+    ? ./empty.dhall+, filter =+      missing+        sha256:8ebfede5bbfe09675f246c33eb83964880ac615c4b1be8d856076fdbc4b26ba6+    ? ./filter.dhall+, filterMap =+      missing+        sha256:94b7ed4204d1c79aaf55527ef51024e7085b8dd2896952cffbd12d8f95e16f46+    ? ./filterMap.dhall+, fold =+      missing+        sha256:10bb945c25ab3943bd9df5a32e633cbfae112b7d3af38591784687e436a8d814+    ? ./fold.dhall+, foldLeft =+      missing+        sha256:3c6ab57950fe644906b7bbdef0b9523440b6ee17773ebb8cbd41ffacb8bfab61+    ? ./foldLeft.dhall+, generate =+      missing+        sha256:78ff1ad96c08b88a8263eea7bc8381c078225cfcb759c496f792edb5a5e0b1a4+    ? ./generate.dhall+, head =+      missing+        sha256:0d2e65ba0aea908377e46d22020dc3ad970284f4ee4eb8e6b8c51e53038c0026+    ? ./head.dhall+, index =+      missing+        sha256:e657b55ecae4d899465c3032cb1a64c6aa6dc2aa3034204f3c15ce5c96c03e63+    ? ./index.dhall+, indexed =+      missing+        sha256:58bb44457fa81adf26f5123c1b2e8bef0c5aa22dac5fa5ebdfb7da84563b027f+    ? ./indexed.dhall+, iterate =+      missing+        sha256:e4999ccce190a2e2a6ab9cb188e3af6c40df474087827153005293f11bfe1d26+    ? ./iterate.dhall+, last =+      missing+        sha256:741226b741af152a1638491cdff7f3aa74baf080ada2e63429483f3d195a984d+    ? ./last.dhall+, length =+      missing+        sha256:42c6812c7a9e3c6e6fad88f77c5b3849503964e071cb784e22c38c888a401461+    ? ./length.dhall+, map =+      missing+        sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+    ? ./map.dhall+, mapMaybe =+      missing+        sha256:6f3c4f8c94577b46e7d30f8df7e82a269b0ad0a7e18c0f0370f243fd1127e77f+    ? ./mapMaybe.dhall+, mapWithIndex =+      missing+        sha256:98599e0b55c5d3ae75264ba90657c6f68c7ce32834bd12b215acaea711eed6eb+    ? ./mapWithIndex.dhall+, null =+      missing+        sha256:2338e39637e9a50d66ae1482c0ed559bbcc11e9442bfca8f8c176bbcd9c4fc80+    ? ./null.dhall+, partition =+      missing+        sha256:38147ac6d750a6492736dd90cc967bf09aa405c499de943c64fab7b86ae02f03+    ? ./partition.dhall+, replicate =+      missing+        sha256:d4250b45278f2d692302489ac3e78280acb238d27541c837ce46911ff3baa347+    ? ./replicate.dhall+, reverse =+      missing+        sha256:ad99d224d61852de6696da5a7d04c98dbe676fe67d5e4ef4f19e9aaa27006e9d+    ? ./reverse.dhall+, shifted =+      missing+        sha256:54fb22c7e952ebce1cfc0fcdd33ce4cfa817bff9d6564af268dea6685f8b5dfe+    ? ./shifted.dhall+, take =+      missing+        sha256:b3e08ee8c3a5bf3d8ccee6b2b2008fbb8e51e7373aef6f1af67ad10078c9fbfa+    ? ./take.dhall+, unpackOptionals =+      missing+        sha256:0cbaa920f429cf7fc3907f8a9143203fe948883913560e6e1043223e6b3d05e4+    ? ./unpackOptionals.dhall+, unzip =+      missing+        sha256:4d6003e9e683a289fe33f4c90f958eb1e08ea0bbb474210fcd90d1885c9660e9+    ? ./unzip.dhall+, zip =+      missing+        sha256:85ed955eabf3998767f4ad2a28e57d40cd4c68a95519d79e9b622f1d26d979da+    ? ./zip.dhall+}
+ dhall-lang/Prelude/List/partition view
@@ -0,0 +1,3 @@+  missing+    sha256:38147ac6d750a6492736dd90cc967bf09aa405c499de943c64fab7b86ae02f03+? ./partition.dhall
+ dhall-lang/Prelude/List/partition.dhall view
@@ -0,0 +1,31 @@+{-|+`partition` divides a `List` of elements into those that satisfy a predicate+and those that do not+-}+let Partition+    : Type → Type+    = λ(a : Type) → { true : List a, false : List a }++let partition+    : ∀(a : Type) → (a → Bool) → List a → Partition a+    = λ(a : Type) →+      λ(f : a → Bool) →+      λ(xs : List a) →+        List/fold+          a+          xs+          (Partition a)+          ( λ(x : a) →+            λ(p : Partition a) →+              if    f x+              then  { true = [ x ] # p.true, false = p.false }+              else  { true = p.true, false = [ x ] # p.false }+          )+          { true = [] : List a, false = [] : List a }++let example0 =+        assert+      :   partition Natural Natural/even [ 0, 1, 2, 3 ]+        ≡ { true = [ 0, 2 ], false = [ 1, 3 ] }++in  partition
+ dhall-lang/Prelude/List/replicate view
@@ -0,0 +1,3 @@+  missing+    sha256:d4250b45278f2d692302489ac3e78280acb238d27541c837ce46911ff3baa347+? ./replicate.dhall
+ dhall-lang/Prelude/List/replicate.dhall view
@@ -0,0 +1,18 @@+--| Build a list by copying the given element the specified number of times+let replicate+    : Natural → ∀(a : Type) → a → List a+    = λ(n : Natural) →+      λ(a : Type) →+      λ(x : a) →+        List/build+          a+          ( λ(list : Type) →+            λ(cons : a → list → list) →+              Natural/fold n list (cons x)+          )++let example0 = assert : replicate 9 Natural 1 ≡ [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ]++let example1 = assert : replicate 0 Natural 1 ≡ ([] : List Natural)++in  replicate
+ dhall-lang/Prelude/List/reverse view
@@ -0,0 +1,3 @@+  missing+    sha256:ad99d224d61852de6696da5a7d04c98dbe676fe67d5e4ef4f19e9aaa27006e9d+? ./reverse.dhall
+ dhall-lang/Prelude/List/reverse.dhall view
@@ -0,0 +1,11 @@+--| Reverse a list+let reverse+    : ∀(a : Type) → List a → List a+    = List/reverse++let example0 = assert : reverse Natural [ 0, 1, 2 ] ≡ [ 2, 1, 0 ]++let example1 =+      assert : reverse Natural ([] : List Natural) ≡ ([] : List Natural)++in  reverse
+ dhall-lang/Prelude/List/shifted view
@@ -0,0 +1,3 @@+  missing+    sha256:54fb22c7e952ebce1cfc0fcdd33ce4cfa817bff9d6564af268dea6685f8b5dfe+? ./shifted.dhall
+ dhall-lang/Prelude/List/shifted.dhall view
@@ -0,0 +1,83 @@+{-|+Combine a `List` of `List`s, offsetting the `index` of each element by the+number of elements in preceding lists+-}+let shifted+    : ∀(a : Type) →+      List (List { index : Natural, value : a }) →+        List { index : Natural, value : a }+    = λ(a : Type) →+      λ(kvss : List (List { index : Natural, value : a })) →+        List/build+          { index : Natural, value : a }+          ( λ(list : Type) →+            λ(cons : { index : Natural, value : a } → list → list) →+            λ(nil : list) →+              let result =+                    List/fold+                      (List { index : Natural, value : a })+                      kvss+                      { count : Natural, diff : Natural → list }+                      ( λ(kvs : List { index : Natural, value : a }) →+                        λ(y : { count : Natural, diff : Natural → list }) →+                          let length =+                                List/length { index : Natural, value : a } kvs++                          in  { count = y.count + length+                              , diff =+                                  λ(n : Natural) →+                                    List/fold+                                      { index : Natural, value : a }+                                      kvs+                                      list+                                      ( λ ( kvOld+                                          : { index : Natural, value : a }+                                          ) →+                                        λ(z : list) →+                                          let kvNew =+                                                { index = kvOld.index + n+                                                , value = kvOld.value+                                                }++                                          in  cons kvNew z+                                      )+                                      (y.diff (n + length))+                              }+                      )+                      { count = 0, diff = λ(_ : Natural) → nil }++              in  result.diff 0+          )++let example0 =+        assert+      :   shifted+            Bool+            [ [ { index = 0, value = True }+              , { index = 1, value = True }+              , { index = 2, value = True }+              ]+            , [ { index = 0, value = False }, { index = 1, value = False } ]+            , [ { index = 0, value = True }+              , { index = 1, value = True }+              , { index = 2, value = True }+              , { index = 3, value = True }+              ]+            ]+        ≡ [ { index = 0, value = True }+          , { index = 1, value = True }+          , { index = 2, value = True }+          , { index = 3, value = False }+          , { index = 4, value = False }+          , { index = 5, value = True }+          , { index = 6, value = True }+          , { index = 7, value = True }+          , { index = 8, value = True }+          ]++let example1 =+        assert+      :   shifted Bool ([] : List (List { index : Natural, value : Bool }))+        ≡ ([] : List { index : Natural, value : Bool })++in  shifted
+ dhall-lang/Prelude/List/take view
@@ -0,0 +1,3 @@+  missing+    sha256:b3e08ee8c3a5bf3d8ccee6b2b2008fbb8e51e7373aef6f1af67ad10078c9fbfa+? ./take.dhall
+ dhall-lang/Prelude/List/take.dhall view
@@ -0,0 +1,26 @@+--| Truncate a list to the first `n` elements+let Natural/lessThan =+        missing+          sha256:3381b66749290769badf8855d8a3f4af62e8de52d1364d838a9d1e20c94fa70c+      ? ../Natural/lessThan.dhall++let take+    : ∀(n : Natural) → ∀(a : Type) → List a → List a+    = λ(n : Natural) →+      λ(a : Type) →+      λ(xs : List a) →+        List/fold+          { index : Natural, value : a }+          (List/indexed a xs)+          (List a)+          ( λ(x : { index : Natural, value : a }) →+            λ(xs : List a) →+              if Natural/lessThan x.index n then [ x.value ] # xs else xs+          )+          ([] : List a)++let example = assert : take 2 Natural [ 2, 3, 5 ] ≡ [ 2, 3 ]++let example = assert : take 5 Natural [ 2, 3, 5 ] ≡ [ 2, 3, 5 ]++in  take
+ dhall-lang/Prelude/List/unpackOptionals view
@@ -0,0 +1,3 @@+  missing+    sha256:0cbaa920f429cf7fc3907f8a9143203fe948883913560e6e1043223e6b3d05e4+? ./unpackOptionals.dhall
+ dhall-lang/Prelude/List/unpackOptionals.dhall view
@@ -0,0 +1,31 @@+--| Unpack Optionals in a List, omitting None items.+let List/filterMap =+        missing+          sha256:94b7ed4204d1c79aaf55527ef51024e7085b8dd2896952cffbd12d8f95e16f46+      ? ./filterMap.dhall++let unpackOptionals+    : ∀(a : Type) → ∀(l : List (Optional a)) → List a+    = λ(a : Type) → List/filterMap (Optional a) a (λ(x : Optional a) → x)++let property1 =+      λ(a : Type) → λ(x : a) → assert : unpackOptionals a [ Some x ] ≡ [ x ]++let property2 =+      λ(a : Type) → assert : unpackOptionals a [ None a ] ≡ ([] : List a)++let example0 =+        assert+      : unpackOptionals Natural [ Some 1, None Natural, Some 3 ] ≡ [ 1, 3 ]++let example1 =+        assert+      :   unpackOptionals Natural ([] : List (Optional Natural))+        ≡ ([] : List Natural)++let example2 =+        assert+      :   unpackOptionals Natural [ None Natural, None Natural ]+        ≡ ([] : List Natural)++in  unpackOptionals
+ dhall-lang/Prelude/List/unzip view
@@ -0,0 +1,3 @@+  missing+    sha256:4d6003e9e683a289fe33f4c90f958eb1e08ea0bbb474210fcd90d1885c9660e9+? ./unzip.dhall
+ dhall-lang/Prelude/List/unzip.dhall view
@@ -0,0 +1,50 @@+--| Unzip a `List` into two separate `List`s+let unzip+    : ∀(a : Type) →+      ∀(b : Type) →+      List { _1 : a, _2 : b } →+        { _1 : List a, _2 : List b }+    = λ(a : Type) →+      λ(b : Type) →+      λ(xs : List { _1 : a, _2 : b }) →+        { _1 =+            List/build+              a+              ( λ(list : Type) →+                λ(cons : a → list → list) →+                  List/fold+                    { _1 : a, _2 : b }+                    xs+                    list+                    (λ(x : { _1 : a, _2 : b }) → cons x._1)+              )+        , _2 =+            List/build+              b+              ( λ(list : Type) →+                λ(cons : b → list → list) →+                  List/fold+                    { _1 : a, _2 : b }+                    xs+                    list+                    (λ(x : { _1 : a, _2 : b }) → cons x._2)+              )+        }++let example0 =+        assert+      :   unzip+            Text+            Bool+            [ { _1 = "ABC", _2 = True }+            , { _1 = "DEF", _2 = False }+            , { _1 = "GHI", _2 = True }+            ]+        ≡ { _1 = [ "ABC", "DEF", "GHI" ], _2 = [ True, False, True ] }++let example1 =+        assert+      :   unzip Text Bool ([] : List { _1 : Text, _2 : Bool })+        ≡ { _1 = [] : List Text, _2 = [] : List Bool }++in  unzip
+ dhall-lang/Prelude/List/zip view
@@ -0,0 +1,3 @@+  missing+    sha256:85ed955eabf3998767f4ad2a28e57d40cd4c68a95519d79e9b622f1d26d979da+? ./zip.dhall
+ dhall-lang/Prelude/List/zip.dhall view
@@ -0,0 +1,58 @@+{-|+Zip two `List` into a single `List`++The resulting `List` will have the length of the shortest of its arguments.+-}+let List/index =+        missing+          sha256:e657b55ecae4d899465c3032cb1a64c6aa6dc2aa3034204f3c15ce5c96c03e63+      ? ./index.dhall++let zip+    : ∀(a : Type) → List a → ∀(b : Type) → List b → List { _1 : a, _2 : b }+    = λ(a : Type) →+      λ(xs : List a) →+      λ(b : Type) →+      λ(ys : List b) →+        let ixs = List/indexed a xs++        in  List/build+              { _1 : a, _2 : b }+              ( λ(list : Type) →+                λ(cons : { _1 : a, _2 : b } → list → list) →+                λ(nil : list) →+                  List/fold+                    { index : Natural, value : a }+                    ixs+                    list+                    ( λ(ix : { index : Natural, value : a }) →+                      λ(rest : list) →+                        merge+                          { None = rest+                          , Some =+                              λ(y : b) → cons { _1 = ix.value, _2 = y } rest+                          }+                          (List/index ix.index b ys)+                    )+                    nil+              )++let example0 =+        assert+      :   zip Text [ "ABC", "DEF", "GHI" ] Natural [ 1, 2, 3 ]+        ≡ [ { _1 = "ABC", _2 = 1 }+          , { _1 = "DEF", _2 = 2 }+          , { _1 = "GHI", _2 = 3 }+          ]++let example1 =+        assert+      :   zip Text [ "ABC" ] Bool ([] : List Bool)+        ≡ ([] : List { _1 : Text, _2 : Bool })++let example2 =+        assert+      :   zip Text [ "ABC", "DEF", "GHI" ] Natural [ 1 ]+        ≡ [ { _1 = "ABC", _2 = 1 } ]++in  zip
+ dhall-lang/Prelude/Location/Type view
@@ -0,0 +1,3 @@+  missing+    sha256:613ebb491aeef4ff06368058b4f0e6e3bb8a58d8c145131fc0b947aac045a529+? ./Type.dhall
+ dhall-lang/Prelude/Location/Type.dhall view
@@ -0,0 +1,15 @@+--| This is the union type returned when you import something `as Location`+let Location+    : Type+    = < Environment : Text | Local : Text | Missing | Remote : Text >++let example0 =+        assert+      :   missing as Location+        ≡ < Environment : Text+          | Local : Text+          | Missing+          | Remote : Text+          >.Missing++in  Location
+ dhall-lang/Prelude/Location/package.dhall view
@@ -0,0 +1,5 @@+{ Type =+      missing+        sha256:613ebb491aeef4ff06368058b4f0e6e3bb8a58d8c145131fc0b947aac045a529+    ? ./Type.dhall+}
+ dhall-lang/Prelude/Map/Entry view
@@ -0,0 +1,3 @@+  missing+    sha256:f334283bdd9cd88e6ea510ca914bc221fc2dab5fb424d24514b2e0df600d5346+? ./Entry.dhall
+ dhall-lang/Prelude/Map/Entry.dhall view
@@ -0,0 +1,6 @@+--| The type of each key-value pair in a `Map`+let Entry+    : Type → Type → Type+    = λ(k : Type) → λ(v : Type) → { mapKey : k, mapValue : v }++in  Entry
+ dhall-lang/Prelude/Map/Type view
@@ -0,0 +1,3 @@+  missing+    sha256:210c7a9eba71efbb0f7a66b3dcf8b9d3976ffc2bc0e907aadfb6aa29c333e8ed+? ./Type.dhall
+ dhall-lang/Prelude/Map/Type.dhall view
@@ -0,0 +1,25 @@+{-|+This is the canonical way to encode a dynamic list of key-value pairs.++Tools (such as `dhall-to-json`/`dhall-to-yaml` will recognize values of this+type and convert them to maps/dictionaries/hashes in the target language++For example, `dhall-to-json` converts a Dhall value like this:++```+[ { mapKey = "foo", mapValue = 1 }+, { mapKey = "bar", mapValue = 2 }+] : ./Map Text Natural+```++... to a JSON value like this:++```+{ "foo": 1, "bar", 2 }+```+-}+let Map+    : Type → Type → Type+    = λ(k : Type) → λ(v : Type) → List { mapKey : k, mapValue : v }++in  Map
+ dhall-lang/Prelude/Map/empty view
@@ -0,0 +1,3 @@+  missing+    sha256:4c612558b8bbe8f955550ed3fb295d57b1b864c85cd52615b52d0ee0e9682e52+? ./empty.dhall
+ dhall-lang/Prelude/Map/empty.dhall view
@@ -0,0 +1,14 @@+--| An empty `Map` of the given key and value types+let Map =+        missing+          sha256:210c7a9eba71efbb0f7a66b3dcf8b9d3976ffc2bc0e907aadfb6aa29c333e8ed+      ? ./Type.dhall++let empty+    : ∀(k : Type) → ∀(v : Type) → Map k v+    = λ(k : Type) → λ(v : Type) → [] : Map k v++let example0 =+      assert : empty Text Bool ≡ ([] : List { mapKey : Text, mapValue : Bool })++in  empty
+ dhall-lang/Prelude/Map/keyText view
@@ -0,0 +1,3 @@+  missing+    sha256:f7b6c802ca5764d03d5e9a6e48d9cb167c01392f775d9c2c87b83cdaa60ea0cc+? ./keyText.dhall
+ dhall-lang/Prelude/Map/keyText.dhall view
@@ -0,0 +1,15 @@+{-|+Builds a key-value record such that a `List` of them will be converted to a+homogeneous record by dhall-to-json and dhall-to-yaml.++Both key and value are fixed to `Text`.++Take a look at `./keyValue` for a polymorphic version.+-}+let keyText =+      λ(key : Text) → λ(value : Text) → { mapKey = key, mapValue = value }++let example0 =+      assert : keyText "foo" "bar" ≡ { mapKey = "foo", mapValue = "bar" }++in  keyText
+ dhall-lang/Prelude/Map/keyValue view
@@ -0,0 +1,3 @@+  missing+    sha256:a0a97199d280c4cce72ffcbbf93b7ceda0a569cf4d173ac98e0aaaa78034b98c+? ./keyValue.dhall
+ dhall-lang/Prelude/Map/keyValue.dhall view
@@ -0,0 +1,17 @@+{-|+Builds a key-value record such that a List of them will be converted to a+homogeneous record by dhall-to-json and dhall-to-yaml.+-}+let keyValue =+      λ(v : Type) →+      λ(key : Text) →+      λ(value : v) →+        { mapKey = key, mapValue = value }++let example0 =+      assert : keyValue Natural "foo" 2 ≡ { mapKey = "foo", mapValue = 2 }++let example1 =+      assert : keyValue Text "bar" "baz" ≡ { mapKey = "bar", mapValue = "baz" }++in  keyValue
+ dhall-lang/Prelude/Map/keys view
@@ -0,0 +1,3 @@+  missing+    sha256:d13ec34e6acf7c349d82272ef09a37c7bdf37f0dab489e9df47a1ff215d9f5e7+? ./keys.dhall
+ dhall-lang/Prelude/Map/keys.dhall view
@@ -0,0 +1,39 @@+--| Get all of the keys of a `Map` as a `List`+let Map =+        missing+          sha256:210c7a9eba71efbb0f7a66b3dcf8b9d3976ffc2bc0e907aadfb6aa29c333e8ed+      ? ./Type.dhall++let Entry =+        missing+          sha256:f334283bdd9cd88e6ea510ca914bc221fc2dab5fb424d24514b2e0df600d5346+      ? ./Entry.dhall++let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ../List/map++let keys+    : ∀(k : Type) → ∀(v : Type) → Map k v → List k+    = λ(k : Type) →+      λ(v : Type) →+        List/map (Entry k v) k (λ(x : Entry k v) → x.mapKey)++let example0 =+        assert+      :   keys+            Text+            Natural+            [ { mapKey = "A", mapValue = 2 }+            , { mapKey = "B", mapValue = 3 }+            , { mapKey = "C", mapValue = 5 }+            ]+        ≡ [ "A", "B", "C" ]++let example1 =+        assert+      :   keys Text Natural ([] : List { mapKey : Text, mapValue : Natural })+        ≡ ([] : List Text)++in  keys
+ dhall-lang/Prelude/Map/map view
@@ -0,0 +1,3 @@+  missing+    sha256:23e09b0b9f08649797dfe1ca39755d5e1c7cad2d0944bdd36c7a0bf804bde8d0+? ./map.dhall
+ dhall-lang/Prelude/Map/map.dhall view
@@ -0,0 +1,58 @@+--| Transform a `Map` by applying a function to each value+let Map =+        missing+          sha256:210c7a9eba71efbb0f7a66b3dcf8b9d3976ffc2bc0e907aadfb6aa29c333e8ed+      ? ./Type.dhall++let Entry =+        missing+          sha256:f334283bdd9cd88e6ea510ca914bc221fc2dab5fb424d24514b2e0df600d5346+      ? ./Entry.dhall++let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ../List/map.dhall++let map+    : ∀(k : Type) → ∀(a : Type) → ∀(b : Type) → (a → b) → Map k a → Map k b+    = λ(k : Type) →+      λ(a : Type) →+      λ(b : Type) →+      λ(f : a → b) →+      λ(m : Map k a) →+        List/map+          (Entry k a)+          (Entry k b)+          ( λ(before : Entry k a) →+              { mapKey = before.mapKey, mapValue = f before.mapValue }+          )+          m++let example0 =+        assert+      :   map+            Text+            Natural+            Bool+            Natural/even+            [ { mapKey = "A", mapValue = 2 }+            , { mapKey = "B", mapValue = 3 }+            , { mapKey = "C", mapValue = 5 }+            ]+        ≡ [ { mapKey = "A", mapValue = True }+          , { mapKey = "B", mapValue = False }+          , { mapKey = "C", mapValue = False }+          ]++let example1 =+        assert+      :   map+            Text+            Natural+            Bool+            Natural/even+            ([] : List { mapKey : Text, mapValue : Natural })+        ≡ ([] : List { mapKey : Text, mapValue : Bool })++in  map
+ dhall-lang/Prelude/Map/mapMaybe.dhall view
@@ -0,0 +1,56 @@+--| Apply a function across the values of a `Map k v`, dropping+--  entries whose values return `None`.+let Map/empty =+        missing+          sha256:4c612558b8bbe8f955550ed3fb295d57b1b864c85cd52615b52d0ee0e9682e52+      ? ./empty.dhall++let Map/unpackOptionals =+        missing+          sha256:66c3e6f6f81418cf99342e1dba739617c01af4b27c1ca5e2e1d7bce64a522e22+      ? ./unpackOptionals.dhall++let Map/map =+        missing+          sha256:23e09b0b9f08649797dfe1ca39755d5e1c7cad2d0944bdd36c7a0bf804bde8d0+      ? ./map.dhall++let Map/Type =+        missing+          sha256:210c7a9eba71efbb0f7a66b3dcf8b9d3976ffc2bc0e907aadfb6aa29c333e8ed+      ? ./Type.dhall++let mapMaybe+    : ∀(k : Type) →+      ∀(a : Type) →+      ∀(b : Type) →+      (a → Optional b) →+      Map/Type k a →+        Map/Type k b+    = λ(k : Type) →+      λ(a : Type) →+      λ(b : Type) →+      λ(f : a → Optional b) →+      λ(m : Map/Type k a) →+        Map/unpackOptionals k b (Map/map k a (Optional b) f m)++let property =+      λ(k : Type) →+      λ(a : Type) →+      λ(b : Type) →+      λ(f : a → Optional b) →+        assert : mapMaybe k a b f (Map/empty k a) ≡ Map/empty k b++let example0 =+        assert+      :   mapMaybe+            Text+            Natural+            Text+            ( λ(n : Natural) →+                if Natural/isZero n then None Text else Some (Natural/show n)+            )+            (toMap { foo = 2, bar = 0 })+        ≡ toMap { foo = "2" }++in  mapMaybe
+ dhall-lang/Prelude/Map/package.dhall view
@@ -0,0 +1,41 @@+{ Type =+      missing+        sha256:210c7a9eba71efbb0f7a66b3dcf8b9d3976ffc2bc0e907aadfb6aa29c333e8ed+    ? ./Type+, Entry =+      missing+        sha256:f334283bdd9cd88e6ea510ca914bc221fc2dab5fb424d24514b2e0df600d5346+    ? ./Entry+, empty =+      missing+        sha256:4c612558b8bbe8f955550ed3fb295d57b1b864c85cd52615b52d0ee0e9682e52+    ? ./empty+, keyText =+      missing+        sha256:f7b6c802ca5764d03d5e9a6e48d9cb167c01392f775d9c2c87b83cdaa60ea0cc+    ? ./keyText+, keyValue =+      missing+        sha256:a0a97199d280c4cce72ffcbbf93b7ceda0a569cf4d173ac98e0aaaa78034b98c+    ? ./keyValue+, keys =+      missing+        sha256:d13ec34e6acf7c349d82272ef09a37c7bdf37f0dab489e9df47a1ff215d9f5e7+    ? ./keys+, map =+      missing+        sha256:23e09b0b9f08649797dfe1ca39755d5e1c7cad2d0944bdd36c7a0bf804bde8d0+    ? ./map+, mapMaybe =+      missing+        sha256:4ea58b720d7af38cef3ef07bef36e476caeed21032cd4a9dc733868a74d9a521+    ? ./mapMaybe.dhall+, unpackOptionals =+      missing+        sha256:66c3e6f6f81418cf99342e1dba739617c01af4b27c1ca5e2e1d7bce64a522e22+    ? ./unpackOptionals.dhall+, values =+      missing+        sha256:ae02cfb06a9307cbecc06130e84fd0c7b96b7f1f11648961e1b030ec00940be8+    ? ./values+}
+ dhall-lang/Prelude/Map/unpackOptionals.dhall view
@@ -0,0 +1,41 @@+--| Turn a `Map k (Optional v)` into a `Map k v` by dropping all+--  entries with value `None`.+let List/concatMap =+        missing+          sha256:3b2167061d11fda1e4f6de0522cbe83e0d5ac4ef5ddf6bb0b2064470c5d3fb64+      ? ../List/concatMap.dhall++let Map/Entry =+        missing+          sha256:f334283bdd9cd88e6ea510ca914bc221fc2dab5fb424d24514b2e0df600d5346+      ? ./Entry.dhall++let Map/Type =+        missing+          sha256:210c7a9eba71efbb0f7a66b3dcf8b9d3976ffc2bc0e907aadfb6aa29c333e8ed+      ? ./Type.dhall++let unpackOptionals+    : ∀(k : Type) → ∀(v : Type) → Map/Type k (Optional v) → Map/Type k v+    = λ(k : Type) →+      λ(v : Type) →+        List/concatMap+          (Map/Entry k (Optional v))+          (Map/Entry k v)+          ( λ(e : Map/Entry k (Optional v)) →+              merge+                { None = [] : Map/Type k v+                , Some = λ(v : v) → [ { mapKey = e.mapKey, mapValue = v } ]+                }+                e.mapValue+          )++let example0 =+        assert+      :   unpackOptionals+            Text+            Text+            (toMap { foo = Some "bar", baz = None Text })+        ≡ toMap { foo = "bar" }++in  unpackOptionals
+ dhall-lang/Prelude/Map/values view
@@ -0,0 +1,3 @@+  missing+    sha256:ae02cfb06a9307cbecc06130e84fd0c7b96b7f1f11648961e1b030ec00940be8+? ./values.dhall
+ dhall-lang/Prelude/Map/values.dhall view
@@ -0,0 +1,39 @@+--| Get all of the values of a `Map` as a `List`+let Map =+        missing+          sha256:210c7a9eba71efbb0f7a66b3dcf8b9d3976ffc2bc0e907aadfb6aa29c333e8ed+      ? ./Type.dhall++let Entry =+        missing+          sha256:f334283bdd9cd88e6ea510ca914bc221fc2dab5fb424d24514b2e0df600d5346+      ? ./Entry.dhall++let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ../List/map.dhall++let values+    : ∀(k : Type) → ∀(v : Type) → Map k v → List v+    = λ(k : Type) →+      λ(v : Type) →+        List/map (Entry k v) v (λ(x : Entry k v) → x.mapValue)++let example0 =+        assert+      :   values+            Text+            Natural+            [ { mapKey = "A", mapValue = 2 }+            , { mapKey = "B", mapValue = 3 }+            , { mapKey = "C", mapValue = 5 }+            ]+        ≡ [ 2, 3, 5 ]++let example1 =+        assert+      :   values Text Natural ([] : List { mapKey : Text, mapValue : Natural })+        ≡ ([] : List Natural)++in  values
+ dhall-lang/Prelude/Monoid view
@@ -0,0 +1,3 @@+  missing+    sha256:26fafa098600ef7a54ef9dba5ada416bbbdd21df1af306c052420c61553ad4af+? ./Monoid.dhall
+ dhall-lang/Prelude/Monoid.dhall view
@@ -0,0 +1,43 @@+{-|+Any function `f` that is a `Monoid` must satisfy the following law:++```+t  : Type+f  : ./Monoid t+xs : List (List t)++f (./List/concat t xs) = f (./map (List t) t f xs)+```++Examples:++```+./Bool/and+    : ./Monoid Bool+./Bool/or+    : ./Monoid Bool+./Bool/even+    : ./Monoid Bool+./Bool/odd+    : ./Monoid Bool+./List/concat+    : ∀(a : Type) → ./Monoid (List a)+./List/shifted+    : ∀(a : Type) → ./Monoid (List { index : Natural, value : a })+./Natural/sum+    : ./Monoid Natural+./Natural/product+    : ./Monoid Natural+./Optional/head+    : ∀(a : Type) → ./Monoid (Optional a)+./Optional/last+    : ∀(a : Type) → ./Monoid (Optional a)+./Text/concat+    : ./Monoid Text+```+-}+let Monoid+    : ∀(m : Type) → Type+    = λ(m : Type) → List m → m++in  Monoid
+ dhall-lang/Prelude/Natural/build view
@@ -0,0 +1,3 @@+  missing+    sha256:e7e25e6c4f1d8e573606ed1bef725396ac2de5c68f7c5d329ffc5822085b984c+? ./build.dhall
+ dhall-lang/Prelude/Natural/build.dhall view
@@ -0,0 +1,31 @@+--| `build` is the inverse of `fold`+let build+    : ( ∀(natural : Type) →+        ∀(succ : natural → natural) →+        ∀(zero : natural) →+          natural+      ) →+        Natural+    = Natural/build++let example0 =+        assert+      :   build+            ( λ(natural : Type) →+              λ(succ : natural → natural) →+              λ(zero : natural) →+                succ (succ (succ zero))+            )+        ≡ 3++let example1 =+        assert+      :   build+            ( λ(natural : Type) →+              λ(succ : natural → natural) →+              λ(zero : natural) →+                zero+            )+        ≡ 0++in  build
+ dhall-lang/Prelude/Natural/enumerate view
@@ -0,0 +1,3 @@+  missing+    sha256:0cf083980a752b21ce0df9fc2222a4c139f50909e2353576e26a191002aa1ce3+? ./enumerate.dhall
+ dhall-lang/Prelude/Natural/enumerate.dhall view
@@ -0,0 +1,32 @@+{-|+Generate a list of numbers from `0` up to but not including the specified+number+-}+let enumerate+    : Natural → List Natural+    = λ(n : Natural) →+        List/build+          Natural+          ( λ(list : Type) →+            λ(cons : Natural → list → list) →+              List/fold+                { index : Natural, value : {} }+                ( List/indexed+                    {}+                    ( List/build+                        {}+                        ( λ(list : Type) →+                          λ(cons : {} → list → list) →+                            Natural/fold n list (cons {=})+                        )+                    )+                )+                list+                (λ(x : { index : Natural, value : {} }) → cons x.index)+          )++let example0 = assert : enumerate 10 ≡ [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]++let example1 = assert : enumerate 0 ≡ ([] : List Natural)++in  enumerate
+ dhall-lang/Prelude/Natural/equal view
@@ -0,0 +1,3 @@+  missing+    sha256:7f108edfa35ddc7cebafb24dc073478e93a802e13b5bc3fd22f4768c9b066e60+? ./equal.dhall
+ dhall-lang/Prelude/Natural/equal.dhall view
@@ -0,0 +1,17 @@+--| `equal` checks if two Naturals are equal.+let lessThanEqual =+        missing+          sha256:1a5caa2b80a42b9f58fff58e47ac0d9a9946d0b2d36c54034b8ddfe3cb0f3c99+      ? ./lessThanEqual.dhall++let equal+    : Natural → Natural → Bool+    = λ(a : Natural) → λ(b : Natural) → lessThanEqual a b && lessThanEqual b a++let example0 = assert : equal 5 5 ≡ True++let example1 = assert : equal 5 6 ≡ False++let property0 = λ(n : Natural) → assert : equal n n ≡ True++in  equal
+ dhall-lang/Prelude/Natural/even view
@@ -0,0 +1,3 @@+  missing+    sha256:b85b8b56892dfef881e1c0e79eade0b949528f792aac0ea42432b315ede4ee66+? ./even.dhall
+ dhall-lang/Prelude/Natural/even.dhall view
@@ -0,0 +1,10 @@+--| Returns `True` if a number if even and returns `False` otherwise+let even+    : Natural → Bool+    = Natural/even++let example0 = assert : even 3 ≡ False++let example1 = assert : even 0 ≡ True++in  even
+ dhall-lang/Prelude/Natural/fold view
@@ -0,0 +1,3 @@+  missing+    sha256:fd01c931e585a8f5fd049af7b076b862ea164f1813b34800c7616a49e549ee06+? ./fold.dhall
+ dhall-lang/Prelude/Natural/fold.dhall view
@@ -0,0 +1,28 @@+{-|+`fold` is the primitive function for consuming `Natural` numbers++If you treat the number `3` as `succ (succ (succ zero))` then a `fold` just+replaces each `succ` and `zero` with something else+-}+let fold+    : Natural →+      ∀(natural : Type) →+      ∀(succ : natural → natural) →+      ∀(zero : natural) →+        natural+    = Natural/fold++let example0 = assert : fold 3 Text (λ(x : Text) → "A" ++ x) "B" ≡ "AAAB"++let example1 =+      λ(zero : Text) →+          assert+        :   fold 3 Text (λ(x : Text) → "A" ++ x) zero+          ≡ "A" ++ ("A" ++ ("A" ++ zero))++let example2 =+      λ(succ : Text → Text) →+      λ(zero : Text) →+        assert : fold 3 Text succ zero ≡ succ (succ (succ zero))++in  fold
+ dhall-lang/Prelude/Natural/greaterThan view
@@ -0,0 +1,3 @@+  missing+    sha256:f702abcdfcd7ad73619b9285d7e41c3a1d017fb6b8d037cf40bd93bf30c09b2c+? ./greaterThan.dhall
+ dhall-lang/Prelude/Natural/greaterThan.dhall view
@@ -0,0 +1,21 @@+--| `greaterThan` checks if one Natural is strictly greater than another.+let lessThan =+        missing+          sha256:3381b66749290769badf8855d8a3f4af62e8de52d1364d838a9d1e20c94fa70c+      ? ./lessThan.dhall++let greaterThan+    : Natural → Natural → Bool+    = λ(x : Natural) → λ(y : Natural) → lessThan y x++let example0 = assert : greaterThan 5 6 ≡ False++let example1 = assert : greaterThan 5 5 ≡ False++let example2 = assert : greaterThan 5 4 ≡ True++let property0 = λ(n : Natural) → assert : greaterThan 0 n ≡ False++let property1 = λ(n : Natural) → assert : greaterThan n n ≡ False++in  greaterThan
+ dhall-lang/Prelude/Natural/greaterThanEqual view
@@ -0,0 +1,3 @@+  missing+    sha256:30ebfab0febd7aa0ccccfdf3dc36ee6d50f0117f35dd4a9b034750b7e885a1a4+? ./greaterThanEqual.dhall
+ dhall-lang/Prelude/Natural/greaterThanEqual.dhall view
@@ -0,0 +1,23 @@+{-|+`greaterThanEqual` checks if one Natural is greater than or equal to another.+-}+let lessThanEqual =+        missing+          sha256:1a5caa2b80a42b9f58fff58e47ac0d9a9946d0b2d36c54034b8ddfe3cb0f3c99+      ? ./lessThanEqual.dhall++let greaterThanEqual+    : Natural → Natural → Bool+    = λ(x : Natural) → λ(y : Natural) → lessThanEqual y x++let example0 = assert : greaterThanEqual 5 6 ≡ False++let example1 = assert : greaterThanEqual 5 5 ≡ True++let example2 = assert : greaterThanEqual 5 4 ≡ True++let property0 = λ(n : Natural) → assert : greaterThanEqual n 0 ≡ True++let property1 = λ(n : Natural) → assert : greaterThanEqual n n ≡ True++in  greaterThanEqual
+ dhall-lang/Prelude/Natural/isZero view
@@ -0,0 +1,3 @@+  missing+    sha256:1be98236800ed2d5cff44f16ca02b34b0c37dfa239d9e0d63d9d2c6eeae3d1d1+? ./isZero.dhall
+ dhall-lang/Prelude/Natural/isZero.dhall view
@@ -0,0 +1,10 @@+--| Returns `True` if a number is `0` and returns `False` otherwise+let isZero+    : Natural → Bool+    = Natural/isZero++let example0 = assert : isZero 2 ≡ False++let example1 = assert : isZero 0 ≡ True++in  isZero
+ dhall-lang/Prelude/Natural/lessThan view
@@ -0,0 +1,3 @@+  missing+    sha256:3381b66749290769badf8855d8a3f4af62e8de52d1364d838a9d1e20c94fa70c+? ./lessThan.dhall
+ dhall-lang/Prelude/Natural/lessThan.dhall view
@@ -0,0 +1,26 @@+--| `lessThan` checks if one Natural is strictly less than another.+let greaterThanEqual =+        missing+          sha256:30ebfab0febd7aa0ccccfdf3dc36ee6d50f0117f35dd4a9b034750b7e885a1a4+      ? ./greaterThanEqual.dhall++let Bool/not =+        missing+          sha256:723df402df24377d8a853afed08d9d69a0a6d86e2e5b2bac8960b0d4756c7dc4+      ? ../Bool/not.dhall++let lessThan+    : Natural → Natural → Bool+    = λ(x : Natural) → λ(y : Natural) → Bool/not (greaterThanEqual x y)++let example0 = assert : lessThan 5 6 ≡ True++let example1 = assert : lessThan 5 5 ≡ False++let example2 = assert : lessThan 5 4 ≡ False++let property0 = λ(n : Natural) → assert : lessThan n 0 ≡ False++let property1 = λ(n : Natural) → assert : lessThan n n ≡ False++in  lessThan
+ dhall-lang/Prelude/Natural/lessThanEqual view
@@ -0,0 +1,3 @@+  missing+    sha256:1a5caa2b80a42b9f58fff58e47ac0d9a9946d0b2d36c54034b8ddfe3cb0f3c99+? ./lessThanEqual.dhall
+ dhall-lang/Prelude/Natural/lessThanEqual.dhall view
@@ -0,0 +1,16 @@+--| `lessThanEqual` checks if one Natural is less than or equal to another.+let lessThanEqual+    : Natural → Natural → Bool+    = λ(x : Natural) → λ(y : Natural) → Natural/isZero (Natural/subtract y x)++let example0 = assert : lessThanEqual 5 6 ≡ True++let example1 = assert : lessThanEqual 5 5 ≡ True++let example2 = assert : lessThanEqual 5 4 ≡ False++let property0 = λ(n : Natural) → assert : lessThanEqual 0 n ≡ True++let property1 = λ(n : Natural) → assert : lessThanEqual n n ≡ True++in  lessThanEqual
+ dhall-lang/Prelude/Natural/listMax view
@@ -0,0 +1,3 @@+  missing+    sha256:20906ffcc9970f740106d4516cb7868b43d75ff8c9f00ff8a9680ae68c48a472+? ./listMax.dhall
+ dhall-lang/Prelude/Natural/listMax.dhall view
@@ -0,0 +1,30 @@+{-|+`listMax` returns the largest element of a `List` or `None Natural` if the+`List` is empty+-}+let max =+        missing+          sha256:1f3b18da330223ab039fad11693da72c7e68d516f50502c73f41a89a097b62f7+      ? ./max.dhall++let Optional/map =+        missing+          sha256:501534192d988218d43261c299cc1d1e0b13d25df388937add784778ab0054fa+      ? ../Optional/map.dhall++let listMax+    : List Natural → Optional Natural+    = λ(xs : List Natural) →+        Optional/map+          Natural+          Natural+          (λ(n : Natural) → List/fold Natural xs Natural max n)+          (List/head Natural xs)++let example0 = assert : listMax [ 1, 2 ] ≡ Some 2++let example1 = assert : listMax ([] : List Natural) ≡ None Natural++let property0 = λ(n : Natural) → assert : listMax [ n ] ≡ Some n++in  listMax
+ dhall-lang/Prelude/Natural/listMin view
@@ -0,0 +1,3 @@+  missing+    sha256:ee70b0d010bbca6012162e8ae1f6e9d9bd10a152675509b0f23145b98b5d43c6+? ./listMin.dhall
+ dhall-lang/Prelude/Natural/listMin.dhall view
@@ -0,0 +1,34 @@+{-|+`listMin` returns the smallest element of a `List` or `None Natural` if the+`List` is empty+-}+let min =+        missing+          sha256:f25f9c462e4dbf0eb15f9ff6ac840c6e9c82255a7f4f2ab408bdab338e028710+      ? ./min.dhall++let Optional/map =+        missing+          sha256:501534192d988218d43261c299cc1d1e0b13d25df388937add784778ab0054fa+      ? ../Optional/map.dhall++let listMin+    : List Natural → Optional Natural+    = λ(xs : List Natural) →+        Optional/map+          Natural+          Natural+          ( λ(n : Natural) →+              if Natural/isZero n then n else List/fold Natural xs Natural min n+          )+          (List/head Natural xs)++let example0 = assert : listMin [ 0, 1 ] ≡ Some 0++let example1 = assert : listMin ([] : List Natural) ≡ None Natural++let example2 = assert : listMin [ 3, 2, 1 ] ≡ Some 1++let property0 = λ(n : Natural) → assert : listMin [ n ] ≡ Some n++in  listMin
+ dhall-lang/Prelude/Natural/max view
@@ -0,0 +1,3 @@+  missing+    sha256:1f3b18da330223ab039fad11693da72c7e68d516f50502c73f41a89a097b62f7+? ./max.dhall
+ dhall-lang/Prelude/Natural/max.dhall view
@@ -0,0 +1,19 @@+--| `max a b` returns the larger of `a` or `b`+let lessThanEqual =+        missing+          sha256:1a5caa2b80a42b9f58fff58e47ac0d9a9946d0b2d36c54034b8ddfe3cb0f3c99+      ? ./lessThanEqual.dhall++let max+    : Natural → Natural → Natural+    = λ(a : Natural) → λ(b : Natural) → if lessThanEqual a b then b else a++let example0 = assert : max 1 2 ≡ 2++let example1 = assert : max 2 1 ≡ 2++let property0 = λ(n : Natural) → assert : max n n ≡ n++let property1 = λ(n : Natural) → assert : max 0 n ≡ n++in  max
+ dhall-lang/Prelude/Natural/min view
@@ -0,0 +1,3 @@+  missing+    sha256:f25f9c462e4dbf0eb15f9ff6ac840c6e9c82255a7f4f2ab408bdab338e028710+? ./min.dhall
+ dhall-lang/Prelude/Natural/min.dhall view
@@ -0,0 +1,17 @@+--| `min a b` returns the smaller of `a` or `b`+let lessThanEqual =+        missing+          sha256:1a5caa2b80a42b9f58fff58e47ac0d9a9946d0b2d36c54034b8ddfe3cb0f3c99+      ? ./lessThanEqual.dhall++let min+    : Natural → Natural → Natural+    = λ(a : Natural) → λ(b : Natural) → if lessThanEqual a b then a else b++let example0 = assert : min 1 2 ≡ 1++let example1 = assert : min 2 1 ≡ 1++let property0 = λ(n : Natural) → assert : min n n ≡ n++in  min
+ dhall-lang/Prelude/Natural/odd view
@@ -0,0 +1,3 @@+  missing+    sha256:ab3c729262c642ec1cdb72a81e910fcfaf2aea13e3961d0bf1bec83efea5aac5+? ./odd.dhall
+ dhall-lang/Prelude/Natural/odd.dhall view
@@ -0,0 +1,10 @@+--| Returns `True` if a number is odd and returns `False` otherwise+let odd+    : Natural → Bool+    = Natural/odd++let example0 = assert : odd 3 ≡ True++let example1 = assert : odd 0 ≡ False++in  odd
+ dhall-lang/Prelude/Natural/package.dhall view
@@ -0,0 +1,89 @@+{ build =+      missing+        sha256:e7e25e6c4f1d8e573606ed1bef725396ac2de5c68f7c5d329ffc5822085b984c+    ? ./build.dhall+, enumerate =+      missing+        sha256:0cf083980a752b21ce0df9fc2222a4c139f50909e2353576e26a191002aa1ce3+    ? ./enumerate.dhall+, even =+      missing+        sha256:b85b8b56892dfef881e1c0e79eade0b949528f792aac0ea42432b315ede4ee66+    ? ./even.dhall+, fold =+      missing+        sha256:fd01c931e585a8f5fd049af7b076b862ea164f1813b34800c7616a49e549ee06+    ? ./fold.dhall+, isZero =+      missing+        sha256:1be98236800ed2d5cff44f16ca02b34b0c37dfa239d9e0d63d9d2c6eeae3d1d1+    ? ./isZero.dhall+, odd =+      missing+        sha256:ab3c729262c642ec1cdb72a81e910fcfaf2aea13e3961d0bf1bec83efea5aac5+    ? ./odd.dhall+, product =+      missing+        sha256:e3e6fd76207875b81d39f79fdbc90b5e640444c04fb3d84c2c9326748f0b26e6+    ? ./product.dhall+, sum =+      missing+        sha256:33f7f4c3aff62e5ecf4848f964363133452d420dcde045784518fb59fa970037+    ? ./sum.dhall+, show =+      missing+        sha256:684ed560ad86f438efdea229eca122c29e8e14f397ed32ec97148d578ca5aa21+    ? ./show.dhall+, toDouble =+      missing+        sha256:d5eb52143dcd35b46a6f0cdb2d3cbf31a14b6daeba56e29066f8e344c9fb6e81+    ? ./toDouble.dhall+, toInteger =+      missing+        sha256:160d2d278619f3da34a1f4f02e739a447e4f2aa5a2978c45b710515b41491e1f+    ? ./toInteger.dhall+, lessThan =+      missing+        sha256:3381b66749290769badf8855d8a3f4af62e8de52d1364d838a9d1e20c94fa70c+    ? ./lessThan.dhall+, lessThanEqual =+      missing+        sha256:1a5caa2b80a42b9f58fff58e47ac0d9a9946d0b2d36c54034b8ddfe3cb0f3c99+    ? ./lessThanEqual.dhall+, equal =+      missing+        sha256:7f108edfa35ddc7cebafb24dc073478e93a802e13b5bc3fd22f4768c9b066e60+    ? ./equal.dhall+, greaterThanEqual =+      missing+        sha256:30ebfab0febd7aa0ccccfdf3dc36ee6d50f0117f35dd4a9b034750b7e885a1a4+    ? ./greaterThanEqual.dhall+, greaterThan =+      missing+        sha256:f702abcdfcd7ad73619b9285d7e41c3a1d017fb6b8d037cf40bd93bf30c09b2c+    ? ./greaterThan.dhall+, min =+      missing+        sha256:f25f9c462e4dbf0eb15f9ff6ac840c6e9c82255a7f4f2ab408bdab338e028710+    ? ./min.dhall+, max =+      missing+        sha256:1f3b18da330223ab039fad11693da72c7e68d516f50502c73f41a89a097b62f7+    ? ./max.dhall+, listMin =+      missing+        sha256:ee70b0d010bbca6012162e8ae1f6e9d9bd10a152675509b0f23145b98b5d43c6+    ? ./listMin.dhall+, listMax =+      missing+        sha256:20906ffcc9970f740106d4516cb7868b43d75ff8c9f00ff8a9680ae68c48a472+    ? ./listMax.dhall+, sort =+      missing+        sha256:36ce8b3e5538454763987ca904d8d7c5ba34c2147434a19eddd51f684432b260+    ? ./sort.dhall+, subtract =+      missing+        sha256:b9277ac637d09142a3a3ac79137ef5955c42f8b33b6746d59db2c9d75ccdd745+    ? ./subtract.dhall+}
+ dhall-lang/Prelude/Natural/product view
@@ -0,0 +1,3 @@+  missing+    sha256:e3e6fd76207875b81d39f79fdbc90b5e640444c04fb3d84c2c9326748f0b26e6+? ./product.dhall
+ dhall-lang/Prelude/Natural/product.dhall view
@@ -0,0 +1,11 @@+--| Multiply all the numbers in a `List`+let product+    : List Natural → Natural+    = λ(xs : List Natural) →+        List/fold Natural xs Natural (λ(l : Natural) → λ(r : Natural) → l * r) 1++let example0 = assert : product [ 2, 3, 5 ] ≡ 30++let example1 = assert : product ([] : List Natural) ≡ 1++in  product
+ dhall-lang/Prelude/Natural/show view
@@ -0,0 +1,3 @@+  missing+    sha256:684ed560ad86f438efdea229eca122c29e8e14f397ed32ec97148d578ca5aa21+? ./show.dhall
+ dhall-lang/Prelude/Natural/show.dhall view
@@ -0,0 +1,13 @@+{-|+Render a `Natural` number as `Text` using the same representation as Dhall+source code (i.e. a decimal number)+-}+let show+    : Natural → Text+    = Natural/show++let example0 = assert : show 3 ≡ "3"++let example1 = assert : show 0 ≡ "0"++in  show
+ dhall-lang/Prelude/Natural/sort view
@@ -0,0 +1,3 @@+  missing+    sha256:36ce8b3e5538454763987ca904d8d7c5ba34c2147434a19eddd51f684432b260+? ./sort.dhall
+ dhall-lang/Prelude/Natural/sort.dhall view
@@ -0,0 +1,61 @@+--| `sort` sorts a `List` of `Natural`s in ascending order+let greaterThanEqual =+        missing+          sha256:30ebfab0febd7aa0ccccfdf3dc36ee6d50f0117f35dd4a9b034750b7e885a1a4+      ? ./greaterThanEqual.dhall++let listMin =+        missing+          sha256:ee70b0d010bbca6012162e8ae1f6e9d9bd10a152675509b0f23145b98b5d43c6+      ? ./listMin.dhall++let List/partition =+        missing+          sha256:38147ac6d750a6492736dd90cc967bf09aa405c499de943c64fab7b86ae02f03+      ? ../List/partition.dhall++let Accumulator = { sorted : List Natural, rest : List Natural }++let partitionMinima =+      λ(xs : List Natural) →+        merge+          { Some =+              λ(m : Natural) → List/partition Natural (greaterThanEqual m) xs+          , None = { true = [] : List Natural, false = [] : List Natural }+          }+          (listMin xs)++let test0 =+        assert+      : partitionMinima [ 2, 1, 1, 3 ] ≡ { true = [ 1, 1 ], false = [ 2, 3 ] }++let step =+      λ(x : Accumulator) →+        let p = partitionMinima x.rest++        in  { sorted = x.sorted # p.true, rest = p.false }++let test1 =+        assert+      :   step { sorted = [ 1, 1 ], rest = [ 2, 3 ] }+        ≡ { sorted = [ 1, 1, 2 ], rest = [ 3 ] }++let sort+    : List Natural → List Natural+    = λ(xs : List Natural) →+        let x =+              Natural/fold+                (List/length Natural xs)+                Accumulator+                step+                { sorted = [] : List Natural, rest = xs }++        in  x.sorted++let example0 = assert : sort ([] : List Natural) ≡ ([] : List Natural)++let example1 = assert : sort [ 1 ] ≡ [ 1 ]++let example2 = assert : sort [ 3, 2, 1, 3, 2, 1 ] ≡ [ 1, 1, 2, 2, 3, 3 ]++in  sort
+ dhall-lang/Prelude/Natural/subtract view
@@ -0,0 +1,3 @@+  missing+    sha256:b9277ac637d09142a3a3ac79137ef5955c42f8b33b6746d59db2c9d75ccdd745+? ./subtract.dhall
+ dhall-lang/Prelude/Natural/subtract.dhall view
@@ -0,0 +1,18 @@+--| `subtract m n` computes `n - m`, truncating to `0` if `m > n`+let subtract+    : Natural → Natural → Natural+    = Natural/subtract++let example0 = assert : subtract 1 2 ≡ 1++let example1 = assert : subtract 1 1 ≡ 0++let example2 = assert : subtract 2 1 ≡ 0++let property0 = λ(n : Natural) → assert : subtract 0 n ≡ n++let property1 = λ(n : Natural) → assert : subtract n 0 ≡ 0++let property2 = λ(n : Natural) → assert : subtract n n ≡ 0++in  subtract
+ dhall-lang/Prelude/Natural/sum view
@@ -0,0 +1,3 @@+  missing+    sha256:33f7f4c3aff62e5ecf4848f964363133452d420dcde045784518fb59fa970037+? ./sum.dhall
+ dhall-lang/Prelude/Natural/sum.dhall view
@@ -0,0 +1,11 @@+--| Add all the numbers in a `List`+let sum+    : List Natural → Natural+    = λ(xs : List Natural) →+        List/fold Natural xs Natural (λ(l : Natural) → λ(r : Natural) → l + r) 0++let example = assert : sum [ 2, 3, 5 ] ≡ 10++let example = assert : sum ([] : List Natural) ≡ 0++in  sum
+ dhall-lang/Prelude/Natural/toDouble view
@@ -0,0 +1,3 @@+  missing+    sha256:d5eb52143dcd35b46a6f0cdb2d3cbf31a14b6daeba56e29066f8e344c9fb6e81+? ./toDouble.dhall
+ dhall-lang/Prelude/Natural/toDouble.dhall view
@@ -0,0 +1,10 @@+--| Convert a `Natural` number to the corresponding `Double`+let toDouble+    : Natural → Double+    = λ(n : Natural) → Integer/toDouble (Natural/toInteger n)++let example0 = assert : toDouble 3 ≡ 3.0++let example1 = assert : toDouble 0 ≡ 0.0++in  toDouble
+ dhall-lang/Prelude/Natural/toInteger view
@@ -0,0 +1,3 @@+  missing+    sha256:160d2d278619f3da34a1f4f02e739a447e4f2aa5a2978c45b710515b41491e1f+? ./toInteger.dhall
+ dhall-lang/Prelude/Natural/toInteger.dhall view
@@ -0,0 +1,10 @@+--| Convert a `Natural` number to the corresponding `Integer`+let toInteger+    : Natural → Integer+    = Natural/toInteger++let example0 = assert : toInteger 3 ≡ +3++let example1 = assert : toInteger 0 ≡ +0++in  toInteger
+ dhall-lang/Prelude/NonEmpty/Type.dhall view
@@ -0,0 +1,9 @@+{-|+A `NonEmpty` list has at least one element and supports many of the same+operations as `List`s+-}+let NonEmpty+    : Type → Type+    = λ(a : Type) → { head : a, tail : List a }++in  NonEmpty
+ dhall-lang/Prelude/NonEmpty/all.dhall view
@@ -0,0 +1,34 @@+{-|+Returns `True` if the supplied function returns `True` for all elements in the+`NonEmpty` list+-}+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let NonEmpty/toList =+        missing+          sha256:0977fe14b77232a4451dcf409c43df4589c4b3cdde7b613aab8df183be1b53f5+      ? ./toList.dhall++let all+    : ∀(a : Type) → (a → Bool) → NonEmpty a → Bool+    = λ(a : Type) →+      λ(f : a → Bool) →+      λ(xs : NonEmpty a) →+        List/fold+          a+          (NonEmpty/toList a xs)+          Bool+          (λ(x : a) → λ(r : Bool) → f x && r)+          True++let example0 =+      assert : all Natural Natural/even { head = 2, tail = [ 3, 5 ] } ≡ False++let example1 =+        assert+      : all Natural Natural/even { head = 2, tail = [] : List Natural } ≡ True++in  all
+ dhall-lang/Prelude/NonEmpty/any.dhall view
@@ -0,0 +1,34 @@+{-|+Returns `True` if the supplied function returns `True` for any element in the+`NonEmpty` list+-}+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let NonEmpty/toList =+        missing+          sha256:0977fe14b77232a4451dcf409c43df4589c4b3cdde7b613aab8df183be1b53f5+      ? ./toList.dhall++let any+    : ∀(a : Type) → (a → Bool) → NonEmpty a → Bool+    = λ(a : Type) →+      λ(f : a → Bool) →+      λ(xs : NonEmpty a) →+        List/fold+          a+          (NonEmpty/toList a xs)+          Bool+          (λ(x : a) → λ(r : Bool) → f x || r)+          False++let example0 =+      assert : any Natural Natural/even { head = 2, tail = [ 3, 5 ] } ≡ True++let example1 =+        assert+      : any Natural Natural/even { head = 3, tail = [] : List Natural } ≡ False++in  any
+ dhall-lang/Prelude/NonEmpty/concat.dhall view
@@ -0,0 +1,61 @@+{-|+Concatenate a `NonEmpty` list of `NonEmpty` lists into a single `NonEmpty`+list+-}+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let NonEmpty/toList =+        missing+          sha256:0977fe14b77232a4451dcf409c43df4589c4b3cdde7b613aab8df183be1b53f5+      ? ./toList.dhall++let List/concatMap =+        missing+          sha256:3b2167061d11fda1e4f6de0522cbe83e0d5ac4ef5ddf6bb0b2064470c5d3fb64+      ? ../List/concatMap.dhall++let concat+    : ∀(a : Type) → NonEmpty (NonEmpty a) → NonEmpty a+    = λ(a : Type) →+      λ(xss : NonEmpty (NonEmpty a)) →+        { head = xss.head.head+        , tail =+              xss.head.tail+            # List/concatMap (NonEmpty a) a (NonEmpty/toList a) xss.tail+        }++let example0 =+        assert+      :   concat+            Natural+            { head = { head = 0, tail = [ 1, 2 ] }+            , tail =+              [ { head = 3, tail = [ 4 ] }, { head = 5, tail = [ 6, 7, 8 ] } ]+            }+        ≡ { head = 0, tail = [ 1, 2, 3, 4, 5, 6, 7, 8 ] }++let example1 =+        assert+      :   concat+            Natural+            { head = { head = 0, tail = [] : List Natural }+            , tail =+              [ { head = 1, tail = [] : List Natural }+              , { head = 2, tail = [] : List Natural }+              ]+            }+        ≡ { head = 0, tail = [ 1, 2 ] : List Natural }++let example2 =+        assert+      :   concat+            Natural+            { head = { head = 0, tail = [] : List Natural }+            , tail = [] : List (NonEmpty Natural)+            }+        ≡ { head = 0, tail = [] : List Natural }++in  concat
+ dhall-lang/Prelude/NonEmpty/concatMap.dhall view
@@ -0,0 +1,56 @@+{-|+Transform a `NonEmpty` list by applying a function to each element and+flattening the results+-}+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let NonEmpty/toList =+        missing+          sha256:0977fe14b77232a4451dcf409c43df4589c4b3cdde7b613aab8df183be1b53f5+      ? ./toList.dhall++let List/concatMap =+        missing+          sha256:3b2167061d11fda1e4f6de0522cbe83e0d5ac4ef5ddf6bb0b2064470c5d3fb64+      ? ../List/concatMap.dhall++let concatMap+    : ∀(a : Type) → ∀(b : Type) → (a → NonEmpty b) → NonEmpty a → NonEmpty b+    = λ(a : Type) →+      λ(b : Type) →+      λ(f : a → NonEmpty b) →+      λ(xs : NonEmpty a) →+        let ys = f xs.head++        in  { head = ys.head+            , tail =+                  ys.tail+                # List/concatMap+                    a+                    b+                    (λ(x : a) → NonEmpty/toList b (f x))+                    xs.tail+            }++let example0 =+        assert+      :   concatMap+            Natural+            Natural+            (λ(n : Natural) → { head = n, tail = [ n ] })+            { head = 2, tail = [ 3, 5 ] }+        ≡ { head = 2, tail = [ 2, 3, 3, 5, 5 ] }++let example1 =+        assert+      :   concatMap+            Natural+            Natural+            (λ(n : Natural) → { head = n, tail = [ n ] })+            { head = 2, tail = [] : List Natural }+        ≡ { head = 2, tail = [ 2 ] }++in  concatMap
+ dhall-lang/Prelude/NonEmpty/head.dhall view
@@ -0,0 +1,13 @@+--| Retrieve the first element of the `NonEmpty` list+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let head+    : ∀(a : Type) → NonEmpty a → a+    = λ(a : Type) → λ(xs : NonEmpty a) → xs.head++let example = assert : head Natural { head = 0, tail = [ 1, 2 ] } ≡ 0++in  head
+ dhall-lang/Prelude/NonEmpty/index.dhall view
@@ -0,0 +1,33 @@+--| Retrieve an element from a `NonEmpty` list using its 0-based index+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let List/index =+        missing+          sha256:e657b55ecae4d899465c3032cb1a64c6aa6dc2aa3034204f3c15ce5c96c03e63+      ? ../List/index.dhall++let index+    : Natural → ∀(a : Type) → NonEmpty a → Optional a+    = λ(n : Natural) →+      λ(a : Type) →+      λ(xs : NonEmpty a) →+        if    Natural/isZero n+        then  Some xs.head+        else  List/index (Natural/subtract 1 n) a xs.tail++let property =+      λ(n : Natural) →+      λ(a : Type) →+      λ(xs : NonEmpty a) →+        assert : index 0 a xs ≡ Some xs.head++let example0 = assert : index 1 Natural { head = 2, tail = [ 3, 5 ] } ≡ Some 3++let example1 =+        assert+      : index 1 Natural { head = 2, tail = [] : List Natural } ≡ None Natural++in  index
+ dhall-lang/Prelude/NonEmpty/indexed.dhall view
@@ -0,0 +1,41 @@+--| Tag each element of the `NonEmpty` list with its index+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ../List/map.dhall++let indexed+    : ∀(a : Type) → NonEmpty a → NonEmpty { index : Natural, value : a }+    = λ(a : Type) →+      λ(xs : NonEmpty a) →+        { head = { index = 0, value = xs.head }+        , tail =+            List/map+              { index : Natural, value : a }+              { index : Natural, value : a }+              ( λ(ix : { index : Natural, value : a }) →+                  { index = ix.index + 1, value = ix.value }+              )+              (List/indexed a xs.tail)+        }++let example0 =+        assert+      :   indexed Bool { head = True, tail = [ False, True ] }+        ≡ { head = { index = 0, value = True }+          , tail = [ { index = 1, value = False }, { index = 2, value = True } ]+          }++let example1 =+        assert+      :   indexed Bool { head = True, tail = [] : List Bool }+        ≡ { head = { index = 0, value = True }+          , tail = [] : List { index : Natural, value : Bool }+          }++in  indexed
+ dhall-lang/Prelude/NonEmpty/last.dhall view
@@ -0,0 +1,17 @@+--| Retrieve the last element of the `NonEmpty` list+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let last+    : ∀(a : Type) → NonEmpty a → a+    = λ(a : Type) →+      λ(xs : NonEmpty a) →+        merge { Some = λ(x : a) → x, None = xs.head } (List/last a xs.tail)++let example0 = assert : last Natural { head = 0, tail = [ 1, 2 ] } ≡ 2++let example1 = assert : last Natural { head = 0, tail = [] : List Natural } ≡ 0++in  last
+ dhall-lang/Prelude/NonEmpty/length.dhall view
@@ -0,0 +1,16 @@+--| Returns the number of elements in a `NonEmpty` list+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let length+    : ∀(a : Type) → NonEmpty a → Natural+    = λ(a : Type) → λ(xs : NonEmpty a) → List/length a xs.tail + 1++let example0 = assert : length Natural { head = 0, tail = [ 1, 2 ] } ≡ 3++let example1 =+      assert : length Natural { head = 0, tail = [] : List Natural } ≡ 1++in  length
+ dhall-lang/Prelude/NonEmpty/make.dhall view
@@ -0,0 +1,18 @@+{-|+Create a `NonEmpty` list using a function instead of a record++This might come in handy if you want to decouple the `NonEmpty` list+construction from the specific names of the fields.+-}+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let make+    : ∀(a : Type) → ∀(head : a) → ∀(tail : List a) → NonEmpty a+    = λ(a : Type) → λ(head : a) → λ(tail : List a) → { head, tail }++let example = assert : make Natural 1 [ 2, 3 ] ≡ { head = 1, tail = [ 2, 3 ] }++in  make
+ dhall-lang/Prelude/NonEmpty/map.dhall view
@@ -0,0 +1,30 @@+--| Transform a `NonEmpty` list by applying a function to each element+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ../List/map.dhall++let map+    : ∀(a : Type) → ∀(b : Type) → (a → b) → NonEmpty a → NonEmpty b+    = λ(a : Type) →+      λ(b : Type) →+      λ(f : a → b) →+      λ(xs : NonEmpty a) →+        { head = f xs.head, tail = List/map a b f xs.tail }++let example0 =+        assert+      :   map Natural Bool Natural/even { head = 2, tail = [ 3, 5 ] }+        ≡ { head = True, tail = [ False, False ] }++let example1 =+        assert+      :   map Natural Bool Natural/even { head = 2, tail = [] : List Natural }+        ≡ { head = True, tail = [] : List Bool }++in  map
+ dhall-lang/Prelude/NonEmpty/package.dhall view
@@ -0,0 +1,73 @@+{ Type =+      missing+        sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+    ? ./Type.dhall+, all =+      missing+        sha256:f2f9389d94f4deb5b918b2e50c1093b57e00b37ddd3ab2b43959993b1cb519b6+    ? ./all.dhall+, any =+      missing+        sha256:7662b665840e41b12a28190eec3aaab9201fcb90c00a8ec3666d549e1020992f+    ? ./any.dhall+, concat =+      missing+        sha256:6d55181938c06c6b806877028f6a241912e9c0935d9a10dd958775bf21e0f64d+    ? ./concat.dhall+, concatMap =+      missing+        sha256:fc33fa9449dc8f74dd8c8be379b7b7c4b0433e2b65650370d81d9a7111a590e2+    ? ./concatMap.dhall+, head =+      missing+        sha256:6b9551c97b89fe666d2e03392a4af5e87abfdbdb0aa0e29fc4b3aa1b318474e7+    ? ./head.dhall+, index =+      missing+        sha256:0ba2fcc9227fab10676cd61b47a18d779818a19c16727c7cc4b4c78e114fd663+    ? ./index.dhall+, indexed =+      missing+        sha256:9dae2c1fecd142df837e98769b5bbdd0bfe25c35a93af1064b4e62f9c780ae6b+    ? ./indexed.dhall+, last =+      missing+        sha256:f83115492b6e408d0b662a68440620f7f3df07b56e7ed66dab77a6e65b121250+    ? ./last.dhall+, length =+      missing+        sha256:eef3b857a164487cfdb960e3298c4731970b7a430011289cba35a9ad722ac989+    ? ./length.dhall+, make =+      missing+        sha256:549de393673c4773c80a50ea578ea50d7f2c4c2eda31956e73fabc4e486f3b1e+    ? ./make.dhall+, map =+      missing+        sha256:93d53afe874bb2eed946c21ca5ada3c9716b7d00e6d8edfaba6484cd9c5a00bd+    ? ./map.dhall+, reverse =+      missing+        sha256:a6d810cdd3badffd4e7ca82091609a855cffac900c82d7ff3724463fbc2d5ff2+    ? ./reverse.dhall+, shifted =+      missing+        sha256:36156973d6916aed10cfd8c59be7c019516bf0a2c47b499a17a8ef0611e1c189+    ? ./shifted.dhall+, singleton =+      missing+        sha256:c9197aabe97695f7ca66f7419bf172d806b2c915594a8fc0d2ff6495db496ff2+    ? ./singleton.dhall+, toList =+      missing+        sha256:0977fe14b77232a4451dcf409c43df4589c4b3cdde7b613aab8df183be1b53f5+    ? ./toList.dhall+, unzip =+      missing+        sha256:d0b925bea32a29aad5cb48a84e8ef8cff750308afe1dd20b24eca19e4e999abc+    ? ./unzip.dhall+, zip =+      missing+        sha256:073f8b4808b6d1db84964f772f6291e6ea193602163438db43fa282c560c01e4+    ? ./zip.dhall+}
+ dhall-lang/Prelude/NonEmpty/reverse.dhall view
@@ -0,0 +1,35 @@+--| Reverse a `NonEmpty` list+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let List/drop =+        missing+          sha256:af983ba3ead494dd72beed05c0f3a17c36a4244adedf7ced502c6512196ed0cf+      ? ../List/drop.dhall++let reverse+    : ∀(a : Type) → NonEmpty a → NonEmpty a+    = λ(a : Type) →+      λ(xs : NonEmpty a) →+        let ys = List/reverse a xs.tail++        in  merge+              { Some =+                  λ(y : a) → { head = y, tail = List/drop 1 a ys # [ xs.head ] }+              , None = { head = xs.head, tail = [] : List a }+              }+              (List/head a ys)++let example =+        assert+      :   reverse Natural { head = 0, tail = [ 1, 2 ] }+        ≡ { head = 2, tail = [ 1, 0 ] }++let example1 =+        assert+      :   reverse Natural { head = 0, tail = [] : List Natural }+        ≡ { head = 0, tail = [] : List Natural }++in  reverse
+ dhall-lang/Prelude/NonEmpty/shifted.dhall view
@@ -0,0 +1,101 @@+{-|+Combine a `NonEmpty` list of `NonEmpty` lists, offsetting the `index` of each+element by the number of elements in preceding lists+-}+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let NonEmpty/toList =+        missing+          sha256:0977fe14b77232a4451dcf409c43df4589c4b3cdde7b613aab8df183be1b53f5+      ? ./toList.dhall++let List/map =+        missing+          sha256:dd845ffb4568d40327f2a817eb42d1c6138b929ca758d50bc33112ef3c885680+      ? ../List/map.dhall++let List/shifted =+        missing+          sha256:54fb22c7e952ebce1cfc0fcdd33ce4cfa817bff9d6564af268dea6685f8b5dfe+      ? ../List/shifted.dhall++let shifted+    : ∀(a : Type) →+      NonEmpty (NonEmpty { index : Natural, value : a }) →+        NonEmpty { index : Natural, value : a }+    = λ(a : Type) →+      λ(kvss : NonEmpty (NonEmpty { index : Natural, value : a })) →+        { head = kvss.head.head+        , tail =+            List/shifted+              a+              (   [ kvss.head.tail ]+                # List/map+                    (NonEmpty { index : Natural, value : a })+                    (List { index : Natural, value : a })+                    ( λ(kvs : NonEmpty { index : Natural, value : a }) →+                        List/map+                          { index : Natural, value : a }+                          { index : Natural, value : a }+                          ( λ(kv : { index : Natural, value : a }) →+                              { index = kv.index + 1, value = kv.value }+                          )+                          (NonEmpty/toList { index : Natural, value : a } kvs)+                    )+                    kvss.tail+              )+        }++let example0 =+        assert+      :   shifted+            Bool+            { head =+              { head = { index = 0, value = True }+              , tail =+                [ { index = 1, value = True }, { index = 2, value = True } ]+              }+            , tail =+              [ { head = { index = 0, value = False }+                , tail = [ { index = 1, value = False } ]+                }+              , { head = { index = 0, value = True }+                , tail =+                  [ { index = 1, value = True }+                  , { index = 2, value = True }+                  , { index = 3, value = True }+                  ]+                }+              ]+            }+        ≡ { head = { index = 0, value = True }+          , tail =+            [ { index = 1, value = True }+            , { index = 2, value = True }+            , { index = 3, value = False }+            , { index = 4, value = False }+            , { index = 5, value = True }+            , { index = 6, value = True }+            , { index = 7, value = True }+            , { index = 8, value = True }+            ]+          }++let example1 =+        assert+      :   shifted+            Bool+            { head =+              { head = { index = 0, value = True }+              , tail = [] : List { index : Natural, value : Bool }+              }+            , tail = [] : List (NonEmpty { index : Natural, value : Bool })+            }+        ≡ { head = { index = 0, value = True }+          , tail = [] : List { index : Natural, value : Bool }+          }++in  shifted
+ dhall-lang/Prelude/NonEmpty/singleton.dhall view
@@ -0,0 +1,14 @@+--| Create a `NonEmpty` list with just one element+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let singleton+    : ∀(a : Type) → a → NonEmpty a+    = λ(a : Type) → λ(x : a) → { head = x, tail = [] : List a }++let example =+      assert : singleton Natural 2 ≡ { head = 2, tail = [] : List Natural }++in  singleton
+ dhall-lang/Prelude/NonEmpty/toList.dhall view
@@ -0,0 +1,17 @@+--| Convert a `NonEmpty` list into the equivalent `List`+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let toList+    : ∀(a : Type) → NonEmpty a → List a+    = λ(a : Type) → λ(xs : NonEmpty a) → [ xs.head ] # xs.tail++let example0 =+      assert : toList Natural { head = 2, tail = [ 3, 5 ] } ≡ [ 2, 3, 5 ]++let example1 =+      assert : toList Natural { head = 2, tail = [] : List Natural } ≡ [ 2 ]++in  toList
+ dhall-lang/Prelude/NonEmpty/unzip.dhall view
@@ -0,0 +1,58 @@+--| Unzip a `NonEmpty` list into two separate `NonEmpty` lists+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let NonEmpty/map =+        missing+          sha256:93d53afe874bb2eed946c21ca5ada3c9716b7d00e6d8edfaba6484cd9c5a00bd+      ? ./map.dhall++let unzip+    : ∀(a : Type) →+      ∀(b : Type) →+      NonEmpty { _1 : a, _2 : b } →+        { _1 : NonEmpty a, _2 : NonEmpty b }+    = λ(a : Type) →+      λ(b : Type) →+      λ(xs : NonEmpty { _1 : a, _2 : b }) →+        { _1 =+            NonEmpty/map+              { _1 : a, _2 : b }+              a+              (λ(x : { _1 : a, _2 : b }) → x._1)+              xs+        , _2 =+            NonEmpty/map+              { _1 : a, _2 : b }+              b+              (λ(x : { _1 : a, _2 : b }) → x._2)+              xs+        }++let example0 =+        assert+      :   unzip+            Text+            Bool+            { head = { _1 = "ABC", _2 = True }+            , tail = [ { _1 = "DEF", _2 = False }, { _1 = "GHI", _2 = True } ]+            }+        ≡ { _1 = { head = "ABC", tail = [ "DEF", "GHI" ] }+          , _2 = { head = True, tail = [ False, True ] }+          }++let example1 =+        assert+      :   unzip+            Text+            Bool+            { head = { _1 = "ABC", _2 = True }+            , tail = [] : List { _1 : Text, _2 : Bool }+            }+        ≡ { _1 = { head = "ABC", tail = [] : List Text }+          , _2 = { head = True, tail = [] : List Bool }+          }++in  unzip
+ dhall-lang/Prelude/NonEmpty/zip.dhall view
@@ -0,0 +1,63 @@+{-|+Zip two `NonEmpty` lists into a single `NonEmpty`++The resulting `NonEmpty` will have the length of the shortest of its arguments.+-}+let NonEmpty =+        missing+          sha256:e2e247455a858317e470e0e4affca8ac07f9f130570ece9cb7ac1f4ea3deb87f+      ? ./Type.dhall++let List/zip =+        missing+          sha256:85ed955eabf3998767f4ad2a28e57d40cd4c68a95519d79e9b622f1d26d979da+      ? ../List/zip.dhall++let zip+    : ∀(a : Type) →+      NonEmpty a →+      ∀(b : Type) →+      NonEmpty b →+        NonEmpty { _1 : a, _2 : b }+    = λ(a : Type) →+      λ(xs : NonEmpty a) →+      λ(b : Type) →+      λ(ys : NonEmpty b) →+        { head = { _1 = xs.head, _2 = ys.head }+        , tail = List/zip a xs.tail b ys.tail+        }++let example0 =+        assert+      :   zip+            Text+            { head = "ABC", tail = [ "DEF", "GHI" ] }+            Natural+            { head = 1, tail = [ 2, 3 ] }+        ≡ { head = { _1 = "ABC", _2 = 1 }+          , tail = [ { _1 = "DEF", _2 = 2 }, { _1 = "GHI", _2 = 3 } ]+          }++let example1 =+        assert+      :   zip+            Text+            { head = "ABC", tail = [ "DEF" ] }+            Bool+            { head = True, tail = [] : List Bool }+        ≡ { head = { _1 = "ABC", _2 = True }+          , tail = [] : List { _1 : Text, _2 : Bool }+          }++let example2 =+        assert+      :   zip+            Text+            { head = "ABC", tail = [] : List Text }+            Natural+            { head = 1, tail = [ 2 ] }+        ≡ { head = { _1 = "ABC", _2 = 1 }+          , tail = [] : List { _1 : Text, _2 : Natural }+          }++in  zip
+ dhall-lang/Prelude/Operator/package.dhall view
@@ -0,0 +1,85 @@+{-+Note: This package does not use one file per function because the operator+names contain symbols such as `*` that may cause problems.+-}+let {-+        `+` m n++    computes `m + n`+    -} `+`+    : Natural → Natural → Natural+    = λ(m : Natural) → λ(n : Natural) → m + n++let example1 = assert : `+` 2 1 ≡ 3++let {-+        `*` m n++    computes `m * n`+    -} `*`+    : Natural → Natural → Natural+    = λ(m : Natural) → λ(n : Natural) → m * n++let example2 = assert : `*` 21 2 ≡ 42++let {-+        `++` m n++    computes `m ++ n`+    -} `++`+    : Text → Text → Text+    = λ(m : Text) → λ(n : Text) → m ++ n++let example3 = assert : `++` "Hello" "Dhall" ≡ "HelloDhall"++let {-+        `#` Type m n++    computes `m # n`+    -} `#`+    : ∀(type : Type) → List type → List type → List type+    = λ(type : Type) → λ(m : List type) → λ(n : List type) → m # n++let example4 = assert : `#` Natural [ 1, 2 ] [ 3 ] ≡ [ 1, 2, 3 ]++let {-+        `==` m n++    computes `m == n`+    -} `==`+    : Bool → Bool → Bool+    = λ(m : Bool) → λ(n : Bool) → m == n++let example5 = assert : `==` True False ≡ False++let {-+        `!=` m n++    computes `m != n`+    -} `!=`+    : Bool → Bool → Bool+    = λ(m : Bool) → λ(n : Bool) → m != n++let example6 = assert : `!=` True False ≡ True++let {-+        `&&` m n++    computes `m && n`+    -} `&&`+    : Bool → Bool → Bool+    = λ(m : Bool) → λ(n : Bool) → m && n++let example7 = assert : `&&` False True ≡ False++let {-+        `||` m n++    computes `m || n`+    -} `||`+    : Bool → Bool → Bool+    = λ(m : Bool) → λ(n : Bool) → m || n++let example8 = assert : `||` False True ≡ True++in  { `+`, `*`, `++`, `#`, `==`, `!=`, `&&`, `||` }
+ dhall-lang/Prelude/Optional/all view
@@ -0,0 +1,3 @@+  missing+    sha256:a303004b6def0a2a05bf5f0a8d54e84dd45d8bef581789186ac04924956a1695+? ./all.dhall
+ dhall-lang/Prelude/Optional/all.dhall view
@@ -0,0 +1,16 @@+{-|+Returns `False` if the supplied function returns `False` for a present element+and `True` otherwise:+-}+let all+    : ∀(a : Type) → (a → Bool) → Optional a → Bool+    = λ(a : Type) →+      λ(f : a → Bool) →+      λ(xs : Optional a) →+        merge { Some = f, None = True } xs++let example0 = assert : all Natural Natural/even (Some 3) ≡ False++let example1 = assert : all Natural Natural/even (None Natural) ≡ True++in  all
+ dhall-lang/Prelude/Optional/any view
@@ -0,0 +1,3 @@+  missing+    sha256:96a5cf4f31b3c598b09161dd3082f0a09f4328a4cefda6a7e09894b37b17b435+? ./any.dhall
+ dhall-lang/Prelude/Optional/any.dhall view
@@ -0,0 +1,16 @@+{-|+Returns `True` if the supplied function returns `True` for a present element and+`False` otherwise+-}+let any+    : ∀(a : Type) → (a → Bool) → Optional a → Bool+    = λ(a : Type) →+      λ(f : a → Bool) →+      λ(xs : Optional a) →+        merge { Some = f, None = False } xs++let example0 = assert : any Natural Natural/even (Some 2) ≡ True++let example1 = assert : any Natural Natural/even (None Natural) ≡ False++in  any
+ dhall-lang/Prelude/Optional/build view
@@ -0,0 +1,3 @@+  missing+    sha256:28e61294bf2dd59dc57cf74f719d1568e60b5ba46c28eac586bc937eff4a2af1+? ./build.dhall
+ dhall-lang/Prelude/Optional/build.dhall view
@@ -0,0 +1,41 @@+--| `build` is the inverse of `fold`+let build+    : ∀(a : Type) →+      ( ∀(optional : Type) →+        ∀(some : a → optional) →+        ∀(none : optional) →+          optional+      ) →+        Optional a+    = λ(a : Type) →+      λ ( build+        : ∀(optional : Type) →+          ∀(some : a → optional) →+          ∀(none : optional) →+            optional+        ) →+        build (Optional a) (λ(x : a) → Some x) (None a)++let example0 =+        assert+      :   build+            Natural+            ( λ(optional : Type) →+              λ(some : Natural → optional) →+              λ(none : optional) →+                some 1+            )+        ≡ Some 1++let example1 =+        assert+      :   build+            Natural+            ( λ(optional : Type) →+              λ(some : Natural → optional) →+              λ(none : optional) →+                none+            )+        ≡ None Natural++in  build
+ dhall-lang/Prelude/Optional/concat view
@@ -0,0 +1,3 @@+  missing+    sha256:b7736bd3ebeab14c3912dfb534d0c970a025b001d06c2d5461d4b0e289e3cb7a+? ./concat.dhall
+ dhall-lang/Prelude/Optional/concat.dhall view
@@ -0,0 +1,14 @@+--| Flatten two `Optional` layers into a single `Optional` layer+let concat+    : ∀(a : Type) → Optional (Optional a) → Optional a+    = λ(a : Type) →+      λ(x : Optional (Optional a)) →+        merge { Some = λ(y : Optional a) → y, None = None a } x++let example0 = assert : concat Natural (Some (Some 1)) ≡ Some 1++let example1 = assert : concat Natural (Some (None Natural)) ≡ None Natural++let example2 = assert : concat Natural (None (Optional Natural)) ≡ None Natural++in  concat
+ dhall-lang/Prelude/Optional/concatMap.dhall view
@@ -0,0 +1,23 @@+--| Transform the value with a function and flatten the resulting `Optional`+let concatMap+    : ∀(a : Type) → ∀(b : Type) → (a → Optional b) → Optional a → Optional b+    = λ(a : Type) →+      λ(b : Type) →+      λ(f : a → Optional b) →+      λ(o : Optional a) →+        merge { Some = f, None = None b } o++let exampleFun+    : Natural → Optional Natural+    = λ(n : Natural) → if Natural/even n then Some (n + 1) else None Natural++let example0 =+      assert : concatMap Natural Natural exampleFun (Some 1) ≡ None Natural++let example1 = assert : concatMap Natural Natural exampleFun (Some 2) ≡ Some 3++let example2 =+        assert+      : concatMap Natural Natural exampleFun (None Natural) ≡ None Natural++in  concatMap
+ dhall-lang/Prelude/Optional/default view
@@ -0,0 +1,3 @@+  missing+    sha256:5bd665b0d6605c374b3c4a7e2e2bd3b9c1e39323d41441149ed5e30d86e889ad+? ./default.dhall
+ dhall-lang/Prelude/Optional/default.dhall view
@@ -0,0 +1,13 @@+--| Unpack an `Optional`, returning the default when it's `None`.+let default+    : ∀(a : Type) → a → Optional a → a+    = λ(a : Type) →+      λ(default : a) →+      λ(o : Optional a) →+        merge { Some = λ(x : a) → x, None = default } o++let example0 = assert : default Bool False (None Bool) ≡ False++let example1 = assert : default Bool False (Some True) ≡ True++in  default
+ dhall-lang/Prelude/Optional/equal.dhall view
@@ -0,0 +1,24 @@+let Optional/fold =+        missing+          sha256:c5b9d72f6f62bdaa0e196ac1c742cc175cd67a717b880fb8aec1333a5a4132cf+      ? ./fold.dhall++let Optional/null =+        missing+          sha256:3871180b87ecaba8b53fffb2a8b52d3fce98098fab09a6f759358b9e8042eedc+      ? ./null.dhall++let equal+    : forall (a : Type) -> (a -> a -> Bool) -> Optional a -> Optional a -> Bool+    = \(a : Type) ->+      \(compare : a -> a -> Bool) ->+      \(ox : Optional a) ->+      \(oy : Optional a) ->+        Optional/fold+          a+          ox+          Bool+          (\(x : a) -> Optional/fold a oy Bool (compare x) False)+          (Optional/null a oy)++in  equal
+ dhall-lang/Prelude/Optional/filter view
@@ -0,0 +1,3 @@+  missing+    sha256:54f0a487d578801819613fe000050c038c632edf1f9ccc57677e98ae0ef56b83+? ./filter.dhall
+ dhall-lang/Prelude/Optional/filter.dhall view
@@ -0,0 +1,29 @@+--| Only keep an `Optional` element if the supplied function returns `True`+let filter+    : ∀(a : Type) → (a → Bool) → Optional a → Optional a+    = λ(a : Type) →+      λ(f : a → Bool) →+      λ(xs : Optional a) →+        ( λ(a : Type) →+          λ ( build+            : ∀(optional : Type) →+              ∀(some : a → optional) →+              ∀(none : optional) →+                optional+            ) →+            build (Optional a) (λ(x : a) → Some x) (None a)+        )+          a+          ( λ(optional : Type) →+            λ(some : a → optional) →+            λ(none : optional) →+              merge+                { Some = λ(x : a) → if f x then some x else none, None = none }+                xs+          )++let example0 = assert : filter Natural Natural/even (Some 2) ≡ Some 2++let example1 = assert : filter Natural Natural/odd (Some 2) ≡ None Natural++in  filter
+ dhall-lang/Prelude/Optional/fold view
@@ -0,0 +1,3 @@+  missing+    sha256:c5b9d72f6f62bdaa0e196ac1c742cc175cd67a717b880fb8aec1333a5a4132cf+? ./fold.dhall
+ dhall-lang/Prelude/Optional/fold.dhall view
@@ -0,0 +1,20 @@+--| `fold` is the primitive function for consuming `Optional` values+let fold+    : ∀(a : Type) →+      Optional a →+      ∀(optional : Type) →+      ∀(some : a → optional) →+      ∀(none : optional) →+        optional+    = λ(a : Type) →+      λ(o : Optional a) →+      λ(optional : Type) →+      λ(some : a → optional) →+      λ(none : optional) →+        merge { Some = some, None = none } o++let example0 = assert : fold Natural (Some 2) Text Natural/show "0" ≡ "2"++let example1 = assert : fold Natural (None Natural) Text Natural/show "0" ≡ "0"++in  fold
+ dhall-lang/Prelude/Optional/head view
@@ -0,0 +1,3 @@+  missing+    sha256:4f256c9338b60a1933f41f2a8fafd861930a1e41770a644cdbac0622676fa34c+? ./head.dhall
+ dhall-lang/Prelude/Optional/head.dhall view
@@ -0,0 +1,24 @@+--| Returns the first non-empty `Optional` value in a `List`+let head+    : ∀(a : Type) → List (Optional a) → Optional a+    = λ(a : Type) →+      λ(xs : List (Optional a)) →+        List/fold+          (Optional a)+          xs+          (Optional a)+          ( λ(l : Optional a) →+            λ(r : Optional a) →+              merge { Some = λ(x : a) → Some x, None = r } l+          )+          (None a)++let example0 = assert : head Natural [ None Natural, Some 1, Some 2 ] ≡ Some 1++let example1 =+      assert : head Natural [ None Natural, None Natural ] ≡ None Natural++let example2 =+      assert : head Natural ([] : List (Optional Natural)) ≡ None Natural++in  head
+ dhall-lang/Prelude/Optional/last view
@@ -0,0 +1,3 @@+  missing+    sha256:50400771ae19e9b75efa6581feec318ae1ade0b6a60e215df428c66c4b052707+? ./last.dhall
+ dhall-lang/Prelude/Optional/last.dhall view
@@ -0,0 +1,24 @@+--| Returns the last non-empty `Optional` value in a `List`+let last+    : ∀(a : Type) → List (Optional a) → Optional a+    = λ(a : Type) →+      λ(xs : List (Optional a)) →+        List/fold+          (Optional a)+          xs+          (Optional a)+          ( λ(l : Optional a) →+            λ(r : Optional a) →+              merge { Some = λ(x : a) → Some x, None = l } r+          )+          (None a)++let example0 = assert : last Natural [ None Natural, Some 1, Some 2 ] ≡ Some 2++let example1 =+      assert : last Natural [ None Natural, None Natural ] ≡ None Natural++let example2 =+      assert : last Natural ([] : List (Optional Natural)) ≡ None Natural++in  last
+ dhall-lang/Prelude/Optional/length view
@@ -0,0 +1,3 @@+  missing+    sha256:f168337c5244ded68c05ecf32ce068b6b87158881d07e87b8cb6853fc6982a85+? ./length.dhall
+ dhall-lang/Prelude/Optional/length.dhall view
@@ -0,0 +1,14 @@+{-|+Returns `1` if the `Optional` value is present and `0` if the value is absent+-}+let length+    : ∀(a : Type) → Optional a → Natural+    = λ(a : Type) →+      λ(xs : Optional a) →+        merge { Some = λ(_ : a) → 1, None = 0 } xs++let example0 = assert : length Natural (Some 2) ≡ 1++let example1 = assert : length Natural (None Natural) ≡ 0++in  length
+ dhall-lang/Prelude/Optional/map view
@@ -0,0 +1,3 @@+  missing+    sha256:501534192d988218d43261c299cc1d1e0b13d25df388937add784778ab0054fa+? ./map.dhall
+ dhall-lang/Prelude/Optional/map.dhall view
@@ -0,0 +1,14 @@+--| Transform an `Optional` value with a function+let map+    : ∀(a : Type) → ∀(b : Type) → (a → b) → Optional a → Optional b+    = λ(a : Type) →+      λ(b : Type) →+      λ(f : a → b) →+      λ(o : Optional a) →+        merge { Some = λ(x : a) → Some (f x), None = None b } o++let example0 = assert : map Natural Bool Natural/even (Some 3) ≡ Some False++let example1 = assert : map Natural Bool Natural/even (None Natural) ≡ None Bool++in  map
+ dhall-lang/Prelude/Optional/null view
@@ -0,0 +1,3 @@+  missing+    sha256:3871180b87ecaba8b53fffb2a8b52d3fce98098fab09a6f759358b9e8042eedc+? ./null.dhall
+ dhall-lang/Prelude/Optional/null.dhall view
@@ -0,0 +1,12 @@+--| Returns `True` if the `Optional` value is absent and `False` if present+let null+    : ∀(a : Type) → Optional a → Bool+    = λ(a : Type) →+      λ(xs : Optional a) →+        merge { Some = λ(_ : a) → False, None = True } xs++let example0 = assert : null Natural (Some 2) ≡ False++let example1 = assert : null Natural (None Natural) ≡ True++in  null
+ dhall-lang/Prelude/Optional/package.dhall view
@@ -0,0 +1,65 @@+{ all =+      missing+        sha256:a303004b6def0a2a05bf5f0a8d54e84dd45d8bef581789186ac04924956a1695+    ? ./all.dhall+, any =+      missing+        sha256:96a5cf4f31b3c598b09161dd3082f0a09f4328a4cefda6a7e09894b37b17b435+    ? ./any.dhall+, build =+      missing+        sha256:28e61294bf2dd59dc57cf74f719d1568e60b5ba46c28eac586bc937eff4a2af1+    ? ./build.dhall+, concat =+      missing+        sha256:b7736bd3ebeab14c3912dfb534d0c970a025b001d06c2d5461d4b0e289e3cb7a+    ? ./concat.dhall+, concatMap =+      missing+        sha256:c06ae93e900a99299c9b4ec4912ca5395a0103ea88292205b08dd7e345632818+    ? ./concatMap.dhall+, default =+      missing+        sha256:5bd665b0d6605c374b3c4a7e2e2bd3b9c1e39323d41441149ed5e30d86e889ad+    ? ./default.dhall+, equal =+      missing+        sha256:5411888399fe9c6720f7f3b59caf5eff3e8e8c30402d09f34e46a4457649a35a+    ? ./equal.dhall+, filter =+      missing+        sha256:54f0a487d578801819613fe000050c038c632edf1f9ccc57677e98ae0ef56b83+    ? ./filter.dhall+, fold =+      missing+        sha256:c5b9d72f6f62bdaa0e196ac1c742cc175cd67a717b880fb8aec1333a5a4132cf+    ? ./fold.dhall+, head =+      missing+        sha256:4f256c9338b60a1933f41f2a8fafd861930a1e41770a644cdbac0622676fa34c+    ? ./head.dhall+, last =+      missing+        sha256:50400771ae19e9b75efa6581feec318ae1ade0b6a60e215df428c66c4b052707+    ? ./last.dhall+, length =+      missing+        sha256:f168337c5244ded68c05ecf32ce068b6b87158881d07e87b8cb6853fc6982a85+    ? ./length.dhall+, map =+      missing+        sha256:501534192d988218d43261c299cc1d1e0b13d25df388937add784778ab0054fa+    ? ./map.dhall+, null =+      missing+        sha256:3871180b87ecaba8b53fffb2a8b52d3fce98098fab09a6f759358b9e8042eedc+    ? ./null.dhall+, toList =+      missing+        sha256:d78f160c619119ef12389e48a629ce293d69f7624c8d016b7a4767ab400344c4+    ? ./toList.dhall+, unzip =+      missing+        sha256:d016c01ba91657a2f35609aa29087963d0f506bab0f41d5e8b7cd289dff39708+    ? ./unzip.dhall+}
+ dhall-lang/Prelude/Optional/toList view
@@ -0,0 +1,3 @@+  missing+    sha256:d78f160c619119ef12389e48a629ce293d69f7624c8d016b7a4767ab400344c4+? ./toList.dhall
+ dhall-lang/Prelude/Optional/toList.dhall view
@@ -0,0 +1,12 @@+--| Convert an `Optional` value into the equivalent `List`+let toList+    : ∀(a : Type) → Optional a → List a+    = λ(a : Type) →+      λ(o : Optional a) →+        merge { Some = λ(x : a) → [ x ] : List a, None = [] : List a } o++let example0 = assert : toList Natural (Some 1) ≡ [ 1 ]++let example1 = assert : toList Natural (None Natural) ≡ ([] : List Natural)++in  toList
+ dhall-lang/Prelude/Optional/unzip view
@@ -0,0 +1,3 @@+  missing+    sha256:d016c01ba91657a2f35609aa29087963d0f506bab0f41d5e8b7cd289dff39708+? ./unzip.dhall
+ dhall-lang/Prelude/Optional/unzip.dhall view
@@ -0,0 +1,30 @@+--| Unzip an `Optional` value into two separate `Optional` values+let unzip+    : ∀(a : Type) →+      ∀(b : Type) →+      Optional { _1 : a, _2 : b } →+        { _1 : Optional a, _2 : Optional b }+    = λ(a : Type) →+      λ(b : Type) →+      λ(xs : Optional { _1 : a, _2 : b }) →+        { _1 =+            merge+              { Some = λ(x : { _1 : a, _2 : b }) → Some x._1, None = None a }+              xs+        , _2 =+            merge+              { Some = λ(x : { _1 : a, _2 : b }) → Some x._2, None = None b }+              xs+        }++let example0 =+        assert+      :   unzip Text Bool (Some { _1 = "ABC", _2 = True })+        ≡ { _1 = Some "ABC", _2 = Some True }++let example1 =+        assert+      :   unzip Text Bool (None { _1 : Text, _2 : Bool })+        ≡ { _1 = None Text, _2 = None Bool }++in  unzip
+ dhall-lang/Prelude/Text/concat view
@@ -0,0 +1,3 @@+  missing+    sha256:731265b0288e8a905ecff95c97333ee2db614c39d69f1514cb8eed9259745fc0+? ./concat.dhall
+ dhall-lang/Prelude/Text/concat.dhall view
@@ -0,0 +1,11 @@+--| Concatenate all the `Text` values in a `List`+let concat+    : List Text → Text+    = λ(xs : List Text) →+        List/fold Text xs Text (λ(x : Text) → λ(y : Text) → x ++ y) ""++let example0 = assert : concat [ "ABC", "DEF", "GHI" ] ≡ "ABCDEFGHI"++let example1 = assert : concat ([] : List Text) ≡ ""++in  concat
+ dhall-lang/Prelude/Text/concatMap view
@@ -0,0 +1,3 @@+  missing+    sha256:7a0b0b99643de69d6f94ba49441cd0fa0507cbdfa8ace0295f16097af37e226f+? ./concatMap.dhall
+ dhall-lang/Prelude/Text/concatMap.dhall view
@@ -0,0 +1,22 @@+--| Transform each value in a `List` into `Text` and concatenate the result+let concatMap+    : ∀(a : Type) → (a → Text) → List a → Text+    = λ(a : Type) →+      λ(f : a → Text) →+      λ(xs : List a) →+        List/fold a xs Text (λ(x : a) → λ(y : Text) → f x ++ y) ""++let example0 =+        assert+      :   concatMap Natural (λ(n : Natural) → "${Natural/show n} ") [ 0, 1, 2 ]+        ≡ "0 1 2 "++let example1 =+        assert+      :   concatMap+            Natural+            (λ(n : Natural) → "${Natural/show n} ")+            ([] : List Natural)+        ≡ ""++in  concatMap
+ dhall-lang/Prelude/Text/concatMapSep view
@@ -0,0 +1,3 @@+  missing+    sha256:c272aca80a607bc5963d1fcb38819e7e0d3e72ac4d02b1183b1afb6a91340840+? ./concatMapSep.dhall
+ dhall-lang/Prelude/Text/concatMapSep.dhall view
@@ -0,0 +1,38 @@+{-|+Transform each value in a `List` to `Text` and then concatenate them with a+separator in between each value+-}+let Status = < Empty | NonEmpty : Text >++let concatMapSep+    : ∀(separator : Text) → ∀(a : Type) → (a → Text) → List a → Text+    = λ(separator : Text) →+      λ(a : Type) →+      λ(f : a → Text) →+      λ(elements : List a) →+        let status =+              List/fold+                a+                elements+                Status+                ( λ(x : a) →+                  λ(status : Status) →+                    merge+                      { Empty = Status.NonEmpty (f x)+                      , NonEmpty =+                          λ(result : Text) →+                            Status.NonEmpty (f x ++ separator ++ result)+                      }+                      status+                )+                Status.Empty++        in  merge { Empty = "", NonEmpty = λ(result : Text) → result } status++let example0 =+      assert : concatMapSep ", " Natural Natural/show [ 0, 1, 2 ] ≡ "0, 1, 2"++let example1 =+      assert : concatMapSep ", " Natural Natural/show ([] : List Natural) ≡ ""++in  concatMapSep
+ dhall-lang/Prelude/Text/concatSep view
@@ -0,0 +1,3 @@+  missing+    sha256:e4401d69918c61b92a4c0288f7d60a6560ca99726138ed8ebc58dca2cd205e58+? ./concatSep.dhall
+ dhall-lang/Prelude/Text/concatSep.dhall view
@@ -0,0 +1,31 @@+--| Concatenate a `List` of `Text` values with a separator in between each value+let Status = < Empty | NonEmpty : Text >++let concatSep+    : ∀(separator : Text) → ∀(elements : List Text) → Text+    = λ(separator : Text) →+      λ(elements : List Text) →+        let status =+              List/fold+                Text+                elements+                Status+                ( λ(element : Text) →+                  λ(status : Status) →+                    merge+                      { Empty = Status.NonEmpty element+                      , NonEmpty =+                          λ(result : Text) →+                            Status.NonEmpty (element ++ separator ++ result)+                      }+                      status+                )+                Status.Empty++        in  merge { Empty = "", NonEmpty = λ(result : Text) → result } status++let example0 = assert : concatSep ", " [ "ABC", "DEF", "GHI" ] ≡ "ABC, DEF, GHI"++let example1 = assert : concatSep ", " ([] : List Text) ≡ ""++in  concatSep
+ dhall-lang/Prelude/Text/default view
@@ -0,0 +1,3 @@+  missing+    sha256:f532c8891b1e427d90a6cc07cf7e793a4c84b0765e1bfe69f186ee2ec91c1edf+? ./default.dhall
+ dhall-lang/Prelude/Text/default.dhall view
@@ -0,0 +1,10 @@+--| Unwrap an `Optional` `Text` value, defaulting `None` to `""`+let default+    : Optional Text → Text+    = λ(o : Optional Text) → merge { Some = λ(t : Text) → t, None = "" } o++let example0 = assert : default (Some "ABC") ≡ "ABC"++let example1 = assert : default (None Text) ≡ ""++in  default
+ dhall-lang/Prelude/Text/defaultMap view
@@ -0,0 +1,3 @@+  missing+    sha256:3a3fa1264f6198800c27483cb144de2c5366484876d60b9c739a710ce0288588+? ./defaultMap.dhall
+ dhall-lang/Prelude/Text/defaultMap.dhall view
@@ -0,0 +1,13 @@+--| Transform the value in an `Optional` into `Text`, defaulting `None` to `""`+let defaultMap+    : ∀(a : Type) → (a → Text) → Optional a → Text+    = λ(a : Type) →+      λ(f : a → Text) →+      λ(o : Optional a) →+        merge { Some = f, None = "" } o++let example0 = assert : defaultMap Natural Natural/show (Some 0) ≡ "0"++let example1 = assert : defaultMap Natural Natural/show (None Natural) ≡ ""++in  defaultMap
+ dhall-lang/Prelude/Text/lowerASCII.dhall view
@@ -0,0 +1,56 @@+{-|+Lowercase all ASCII characters++Note that this will also lowercase decomposed Unicode characters that contain+codepoints in the ASCII range+-}+let lowerASCII+    : Text → Text+    = List/fold+        (Text → Text)+        [ Text/replace "A" "a"+        , Text/replace "B" "b"+        , Text/replace "C" "c"+        , Text/replace "D" "d"+        , Text/replace "E" "e"+        , Text/replace "F" "f"+        , Text/replace "G" "g"+        , Text/replace "H" "h"+        , Text/replace "I" "i"+        , Text/replace "J" "j"+        , Text/replace "K" "k"+        , Text/replace "L" "l"+        , Text/replace "M" "m"+        , Text/replace "N" "n"+        , Text/replace "O" "o"+        , Text/replace "P" "p"+        , Text/replace "Q" "q"+        , Text/replace "R" "r"+        , Text/replace "S" "s"+        , Text/replace "T" "t"+        , Text/replace "U" "u"+        , Text/replace "V" "v"+        , Text/replace "W" "w"+        , Text/replace "X" "x"+        , Text/replace "Y" "y"+        , Text/replace "Z" "z"+        ]+        Text+        (λ(replacement : Text → Text) → replacement)++let example0 = assert : lowerASCII "ABCdef" ≡ "abcdef"++let -- This does not lowercase precomposed Unicode characters+    --+    -- • The `Á` in the following example is U+00C1+    example1 =+      assert : lowerASCII "Á" ≡ "Á"++let -- … but this does lowercase decomposed Unicode characters+    --+    -- • The `Á` in the following example is U+0041 U+0301+    -- • The `á` in the following example is U+0061 U+0301+    example1 =+      assert : lowerASCII "Á" ≡ "á"++in  lowerASCII
+ dhall-lang/Prelude/Text/package.dhall view
@@ -0,0 +1,53 @@+{ concat =+      missing+        sha256:731265b0288e8a905ecff95c97333ee2db614c39d69f1514cb8eed9259745fc0+    ? ./concat.dhall+, concatMap =+      missing+        sha256:7a0b0b99643de69d6f94ba49441cd0fa0507cbdfa8ace0295f16097af37e226f+    ? ./concatMap.dhall+, concatMapSep =+      missing+        sha256:c272aca80a607bc5963d1fcb38819e7e0d3e72ac4d02b1183b1afb6a91340840+    ? ./concatMapSep.dhall+, concatSep =+      missing+        sha256:e4401d69918c61b92a4c0288f7d60a6560ca99726138ed8ebc58dca2cd205e58+    ? ./concatSep.dhall+, default =+      missing+        sha256:f532c8891b1e427d90a6cc07cf7e793a4c84b0765e1bfe69f186ee2ec91c1edf+    ? ./default.dhall+, defaultMap =+      missing+        sha256:3a3fa1264f6198800c27483cb144de2c5366484876d60b9c739a710ce0288588+    ? ./defaultMap.dhall+, lowerASCII =+      missing+        sha256:26b076651120b907e869396bd3dc16271f2e12433062b2f26f296968a69515e7+    ? ./lowerASCII.dhall+, replace =+      missing+        sha256:7d132df0e091a43817bba8afa06d1bb487ee51c091430404ad6f8c78bc0328a6+    ? ./replace.dhall+, replicate =+      missing+        sha256:1b398b1d464b3a6c7264a690ac3cacb443b5683b43348c859d68e7c2cb925c4f+    ? ./replicate.dhall+, shell-escape =+      missing+        sha256:d53521b3f478cb18a7d63730bc0e3153c2124b70d6ac9a1f610ce7db67cfc7a2+    ? ./shell-escape.dhall+, show =+      missing+        sha256:c9dc5de3e5f32872dbda57166804865e5e80785abe358ff61f1d8ac45f1f4784+    ? ./show.dhall+, spaces =+      missing+        sha256:fccfd4f26601e006bf6a79ca948dbd37c676cdd0db439554447320293d23b3dc+    ? ./spaces.dhall+, upperASCII =+      missing+        sha256:45ae4fbd814b0474e65c28a4ee92b23b979892fa5bb73730bc99675ae790ca29+    ? ./upperASCII.dhall+}
+ dhall-lang/Prelude/Text/replace.dhall view
@@ -0,0 +1,14 @@+{-+Replace a section of `Text` with another inside a `Text` literal.+-}+let replace+    : ∀(needle : Text) → ∀(replacement : Text) → ∀(haystack : Text) → Text+    = Text/replace++let example0 = assert : replace "-" "_" "foo-bar" ≡ "foo_bar"++let example1 = assert : replace "💣" "💥" "💣💣💣" ≡ "💥💥💥"++let example2 = assert : replace "👨" "👩" "👨‍👩‍👧‍👦" ≡ "👩‍👩‍👧‍👦"++in  replace
+ dhall-lang/Prelude/Text/replicate view
@@ -0,0 +1,3 @@+  missing+    sha256:1b398b1d464b3a6c7264a690ac3cacb443b5683b43348c859d68e7c2cb925c4f+? ./replicate.dhall
+ dhall-lang/Prelude/Text/replicate.dhall view
@@ -0,0 +1,20 @@+--| Build a Text by copying the given Text the specified number of times+let concat =+        missing+          sha256:731265b0288e8a905ecff95c97333ee2db614c39d69f1514cb8eed9259745fc0+      ? ./concat.dhall++let List/replicate =+        missing+          sha256:d4250b45278f2d692302489ac3e78280acb238d27541c837ce46911ff3baa347+      ? ../List/replicate.dhall++let replicate+    : Natural → Text → Text+    = λ(num : Natural) → λ(text : Text) → concat (List/replicate num Text text)++let example0 = assert : replicate 3 "foo" ≡ "foofoofoo"++let property = λ(text : Text) → assert : replicate 0 text ≡ ""++in  replicate
+ dhall-lang/Prelude/Text/shell-escape.dhall view
@@ -0,0 +1,16 @@+{-|+Escape a Text value such that it can be used safely in shells.+The escaping is done by replacing all `'` with `'"'"'` and wraps that string in+single quotes.++This works for all POSIX-compliant shells and some other shells like csh.+-}+let shell-escape+    : Text -> Text+    = \(xs : Text) -> "'${Text/replace "'" "'\"'\"'" xs}'"++let example0 = assert : shell-escape "foo" === "'foo'"++let example1 = assert : shell-escape "foo'bar" === "'foo'\"'\"'bar'"++in  shell-escape
+ dhall-lang/Prelude/Text/show view
@@ -0,0 +1,3 @@+  missing+    sha256:c9dc5de3e5f32872dbda57166804865e5e80785abe358ff61f1d8ac45f1f4784+? ./show.dhall
+ dhall-lang/Prelude/Text/show.dhall view
@@ -0,0 +1,19 @@+{-+Render a `Text` literal as its own representation as Dhall source code (i.e. a+double-quoted string literal)+-}+let show+    : Text → Text+    = Text/show++let example0 = assert : show "ABC" ≡ "\"ABC\""++let example1 =+        assert+      :   show+            ''+            ${"\u0000"} $ \ +            ${" "}☺''+        ≡ "\"\\u0000 \\u0024 \\\\ \\n ☺\""++in  show
+ dhall-lang/Prelude/Text/spaces view
@@ -0,0 +1,3 @@+  missing+    sha256:fccfd4f26601e006bf6a79ca948dbd37c676cdd0db439554447320293d23b3dc+? ./spaces.dhall
+ dhall-lang/Prelude/Text/spaces.dhall view
@@ -0,0 +1,20 @@+{-|+Return a Text with the number of spaces specified.++This function is particularly helpful when trying to generate Text where+whitespace is significant, i.e. with nested indentation.+-}+let replicate =+        missing+          sha256:1b398b1d464b3a6c7264a690ac3cacb443b5683b43348c859d68e7c2cb925c4f+      ? ./replicate.dhall++let spaces+    : Natural → Text+    = λ(a : Natural) → replicate a " "++let example0 = assert : spaces 1 ≡ " "++let example1 = assert : spaces 0 ≡ ""++in  spaces
+ dhall-lang/Prelude/Text/upperASCII.dhall view
@@ -0,0 +1,56 @@+{-|+Uppercase all ASCII characters++Note that this will also uppercase decomposed Unicode characters that contain+codepoints in the ASCII range+-}+let upperASCII+    : Text → Text+    = List/fold+        (Text → Text)+        [ Text/replace "a" "A"+        , Text/replace "b" "B"+        , Text/replace "c" "C"+        , Text/replace "d" "D"+        , Text/replace "e" "E"+        , Text/replace "f" "F"+        , Text/replace "g" "G"+        , Text/replace "h" "H"+        , Text/replace "i" "I"+        , Text/replace "j" "J"+        , Text/replace "k" "K"+        , Text/replace "l" "L"+        , Text/replace "m" "M"+        , Text/replace "n" "N"+        , Text/replace "o" "O"+        , Text/replace "p" "P"+        , Text/replace "q" "Q"+        , Text/replace "r" "R"+        , Text/replace "s" "S"+        , Text/replace "t" "T"+        , Text/replace "u" "U"+        , Text/replace "v" "V"+        , Text/replace "w" "W"+        , Text/replace "x" "X"+        , Text/replace "y" "Y"+        , Text/replace "z" "Z"+        ]+        Text+        (λ(replacement : Text → Text) → replacement)++let example0 = assert : upperASCII "ABCdef" ≡ "ABCDEF"++let -- This does not uppercase precomposed Unicode characters+    --+    -- • The `á` in the following example is U+00E1+    example1 =+      assert : upperASCII "á" ≡ "á"++let -- … but this does uppercase decomposed Unicode characters+    --+    -- • The `Á` in the following example is U+0041 U+0301+    -- • The `á` in the following example is U+0061 U+0301+    example1 =+      assert : upperASCII "á" ≡ "Á"++in  upperASCII
+ dhall-lang/Prelude/Time/package.dhall view
@@ -0,0 +1,5 @@+{ show =+      missing+        sha256:8cabfe35dd0ee25ca65708105e860cbf4b789e0d73134aa905580799e2a46719+    ? ./show.dhall+}
+ dhall-lang/Prelude/Time/show.dhall view
@@ -0,0 +1,15 @@+{-+Render a `Time` as `Text` using the same representation as Dhall source code+(i.e. `hh:mm:ss`)+-}+let show+    : Time → Text+    = Time/show++let example0 = assert : show 03:15:47.90 ≡ "03:15:47.90"++let example1 = assert : show 00:00:00 ≡ "00:00:00"++let example2 = assert : show 11:59:59 ≡ "11:59:59"++in  show
+ dhall-lang/Prelude/TimeZone/package.dhall view
@@ -0,0 +1,5 @@+{ show =+      missing+        sha256:d183361f1c4c656bad3b170ec8b8d6705f564faebf94e4ef10c76061104ff061+    ? ./show.dhall+}
+ dhall-lang/Prelude/TimeZone/show.dhall view
@@ -0,0 +1,15 @@+{-+Render a `TimeZone` as `Text` using the same representation as Dhall source code+(i.e. `±HH:MM`)+-}+let show+    : TimeZone → Text+    = TimeZone/show++let example0 = assert : show +07:00 ≡ "+07:00"++let example1 = assert : show +00:00 ≡ "+00:00"++let example2 = assert : show -05:00 ≡ "-05:00"++in  show
+ dhall-lang/Prelude/XML/Type view
@@ -0,0 +1,3 @@+  missing+    sha256:ab91a0edaf0513e0083b1dfae5efa160adc99b0e589775a4a699ab77cce528a9+? ./Type.dhall
+ dhall-lang/Prelude/XML/Type.dhall view
@@ -0,0 +1,65 @@+{-|+Dhall encoding of an arbitrary XML element++For example, the following XML element:++```+<foo n="1"><bar>baz</bar></foo>+```++... corresponds to the following Dhall expression:+++```+λ(XML : Type)+ → λ ( xml+     : { text :+           Text → XML+       , rawText :+           Text → XML+       , element :+             { attributes :+                 List { mapKey : Text, mapValue : Text }+             , content :+                 List XML+             , name :+                 Text+             }+           → XML+       }+     )+ → xml.element+   { attributes =+       [ { mapKey = "n", mapValue = "1" } ]+   , content =+       [ xml.element+         { attributes =+             [] : List { mapKey : Text, mapValue : Text }+         , content =+             [ xml.text "baz" ]+         , name =+             "bar"+         }+       ]+   , name =+       "foo"+   }+```+-}+let XML/Type+    : Type+    = ∀(XML : Type) →+      ∀ ( xml+        : { text : Text → XML+          , rawText : Text → XML+          , element :+              { attributes : List { mapKey : Text, mapValue : Text }+              , content : List XML+              , name : Text+              } →+                XML+          }+        ) →+        XML++in  XML/Type
+ dhall-lang/Prelude/XML/attribute view
@@ -0,0 +1,3 @@+  missing+    sha256:f7b6c802ca5764d03d5e9a6e48d9cb167c01392f775d9c2c87b83cdaa60ea0cc+? ./attribute.dhall
+ dhall-lang/Prelude/XML/attribute.dhall view

file too large to diff

+ dhall-lang/Prelude/XML/element view

file too large to diff

+ dhall-lang/Prelude/XML/element.dhall view

file too large to diff

+ dhall-lang/Prelude/XML/emptyAttributes view

file too large to diff

+ dhall-lang/Prelude/XML/emptyAttributes.dhall view

file too large to diff

+ dhall-lang/Prelude/XML/leaf view

file too large to diff

+ dhall-lang/Prelude/XML/leaf.dhall view

file too large to diff

+ dhall-lang/Prelude/XML/package.dhall view

file too large to diff

+ dhall-lang/Prelude/XML/rawText.dhall view

file too large to diff

+ dhall-lang/Prelude/XML/render view

file too large to diff

+ dhall-lang/Prelude/XML/render.dhall view

file too large to diff

+ dhall-lang/Prelude/XML/text view

file too large to diff

+ dhall-lang/Prelude/XML/text.dhall view

file too large to diff

+ dhall-lang/Prelude/package.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/regression/preludeBoolFoldA.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/regression/preludeBoolFoldB.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionBindingUnderscoreA.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionBindingUnderscoreB.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionBindingXA.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionBindingXB.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionNestedBindingXA.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionNestedBindingXB.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionNestedBindingXXA.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionNestedBindingXXB.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionNestedBindingXXFreeA.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionNestedBindingXXFreeB.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionNestedBindingXYA.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionNestedBindingXYB.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionTypeBindingUnderscoreA.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionTypeBindingUnderscoreB.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionTypeBindingXA.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionTypeBindingXB.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionTypeNestedBindingXA.dhall view

file too large to diff

+ dhall-lang/tests/alpha-normalization/success/unit/FunctionTypeNestedBindingXB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/failure/unit/ApplyNoArgs.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/failure/unit/LambdaExplicitlyNamedUnderscore.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/failure/unit/ListOneWithAnnotation.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/failure/unit/NaturalNegativeOne.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/failure/unit/OperatorOrTooFewArgs.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/failure/unit/OperatorOrTooManyArgs.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/failure/unit/OperatorUnknownOpcode.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/failure/unit/PiExplicitlyNamedUnderscore.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/failure/unit/VariableExplicitlyNamedUnderscore.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/AnnotationA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/AnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ApplicationA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ApplicationB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ApplicationMultipleA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ApplicationMultipleB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/AssertA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/AssertB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BoolFalseA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BoolFalseB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BoolIfA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BoolIfB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BoolTrueA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BoolTrueB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BuiltinNaturalShowA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BuiltinNaturalShowB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BuiltinNaturalSubtractA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BuiltinNaturalSubtractB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BytesA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/BytesB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/CompletionA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/CompletionB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DateA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DateB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DoubleDoubleA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DoubleDoubleB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DoubleHalfA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DoubleHalfB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DoubleInfinityA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DoubleInfinityB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DoubleNegativeInfinityA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DoubleNegativeInfinityB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DoubleSingleA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/DoubleSingleB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/IntegerBigNegativeA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/IntegerBigNegativeB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/IntegerBigPositiveA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/IntegerBigPositiveB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/IntegerNegativeOneA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/IntegerNegativeOneB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/IntegerZeroA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/IntegerZeroB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/LambdaNamedXA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/LambdaNamedXB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/LambdaUnderscoreA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/LambdaUnderscoreB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/LetMultipleA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/LetMultipleB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/LetOneTypedA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/LetOneTypedB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/LetOneUntypedA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/LetOneUntypedB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ListEmpty0A.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ListEmpty0B.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ListEmpty1A.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ListEmpty1B.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ListOneA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ListOneB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/MergeAnnotatedA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/MergeAnnotatedB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/MergeUnannotatedA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/MergeUnannotatedB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/NaturalBigA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/NaturalBigB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/NaturalTwentyFourA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/NaturalTwentyFourB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/NaturalZeroA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/NaturalZeroB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorAndA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorAndB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorCombineA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorCombineB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorCombineTypesA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorCombineTypesB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorEqA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorEqB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorEquivA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorEquivB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorImportAltA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorImportAltB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorListAppendA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorListAppendB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorNeqA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorNeqB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorOrA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorOrB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorPlusA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorPlusB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorPreferA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorPreferB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorTextAppendA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorTextAppendB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorTimesA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/OperatorTimesB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/PiNamedXA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/PiNamedXB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/PiUnderscoreA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/PiUnderscoreB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/RecordFieldAccessA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/RecordFieldAccessB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/RecordLiteralA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/RecordLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/RecordProjectFieldsA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/RecordProjectFieldsB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/RecordTypeA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/RecordTypeB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/SelfDescribeCBORX2A.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/SelfDescribeCBORX2B.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/SelfDescribeCBORX3A.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/SelfDescribeCBORX3B.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/SelfDescribeCBORXA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/SelfDescribeCBORXB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/SomeA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/SomeB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/TextInterpolatedA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/TextInterpolatedB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/TextSimpleA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/TextSimpleB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/TimeA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/TimeB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/TimeZoneA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/TimeZoneB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ToMapA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ToMapAnnotatedA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ToMapAnnotatedB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/ToMapB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/UnionTypeA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/UnionTypeB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/VariableNamedA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/VariableNamedB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/VariableNamedOversizedIntA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/VariableNamedOversizedIntB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/VariableUnderscoreA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/VariableUnderscoreB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/VariableUnderscoreOversizedIntA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/VariableUnderscoreOversizedIntB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/EnvironmentVariableA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/EnvironmentVariableB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpImportWithQueryA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpImportWithQueryB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpImportWithoutQueryA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpImportWithoutQueryB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpsImportWithEmptyQueryA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpsImportWithEmptyQueryB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpsImportWithQueryA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpsImportWithQueryB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpsImportWithTrickyPathCharsA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpsImportWithTrickyPathCharsB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpsImportWithTrickyQueryCharsA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpsImportWithTrickyQueryCharsB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpsImportWithoutQueryA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/HttpsImportWithoutQueryB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/LocalHereImportA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/LocalHereImportB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/LocalHomeImportA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/LocalHomeImportB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/LocalParentImportA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/LocalParentImportB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/LocalRootImportA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/LocalRootImportB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/MissingA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/imports/MissingB.dhall view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/recordProjectionByExpressionA.dhallb view

file too large to diff

+ dhall-lang/tests/binary-decode/success/unit/recordProjectionByExpressionB.dhall view

file too large to diff

+ dhall-lang/tests/import/cache/dhall/12203871180b87ecaba8b53fffb2a8b52d3fce98098fab09a6f759358b9e8042eedc view

file too large to diff

+ dhall-lang/tests/import/cache/dhall/1220618f785ce8f3930a9144398f576f0a992544b51212bc9108c31b4e670dc6ed21 view

file too large to diff

+ dhall-lang/tests/import/data/cors/AllowedAll.dhall view

file too large to diff

+ dhall-lang/tests/import/data/cors/Empty.dhall view

file too large to diff

+ dhall-lang/tests/import/data/cors/NoCORS.dhall view

file too large to diff

+ dhall-lang/tests/import/data/cors/Null.dhall view

file too large to diff

+ dhall-lang/tests/import/data/cors/OnlyGithub.dhall view

file too large to diff

+ dhall-lang/tests/import/data/cors/OnlyOther.dhall view

file too large to diff

+ dhall-lang/tests/import/data/cors/OnlySelf.dhall view

file too large to diff

+ dhall-lang/tests/import/data/cors/Prelude.dhall view

file too large to diff

+ dhall-lang/tests/import/data/cors/SelfImportAbsolute.dhall view

file too large to diff

+ dhall-lang/tests/import/data/cors/SelfImportRelative.dhall view

file too large to diff

+ dhall-lang/tests/import/data/cycle.dhall view

file too large to diff

+ dhall-lang/tests/import/data/doesNotParse.dhall view

file too large to diff

+ dhall-lang/tests/import/data/doesNotTypecheck.dhall view

file too large to diff

+ dhall-lang/tests/import/data/example.bin view

file too large to diff

+ dhall-lang/tests/import/data/example.txt view

file too large to diff

+ dhall-lang/tests/import/data/file with spaces.txt view

file too large to diff

+ dhall-lang/tests/import/data/importBoundary.dhall view

file too large to diff

+ dhall-lang/tests/import/data/nested.dhall view

file too large to diff

+ dhall-lang/tests/import/data/poisonedCache.dhall view

file too large to diff

+ dhall-lang/tests/import/data/referentiallyOpaque.dhall view

file too large to diff

+ dhall-lang/tests/import/data/simple.dhall view

file too large to diff

+ dhall-lang/tests/import/data/simpleLocation.dhall view

file too large to diff

+ dhall-lang/tests/import/data/userAgent.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/alternativeEnv.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/alternativeEnvMissing.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/customHeadersUsingBoundVariable.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/originHeadersFromRemote.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/originHeadersFromRemoteENV.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/404.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/Cycle.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/DontRecoverCycle.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/DontRecoverHashMismatch.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/DontRecoverParseError.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/DontRecoverTypeError.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/EnvFromRemote.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/EnvUnset.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/EnvUnsetAsText.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/FileMissing.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/HashMismatch.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/HashMismatch2.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/Missing.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/VarAcrossImportBoundary.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/cors/Empty.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/cors/NoCORS.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/cors/Null.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/cors/OnlyOther.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/cors/OnlySelf.dhall view

file too large to diff

+ dhall-lang/tests/import/failure/unit/cors/TwoHops.dhall view

file too large to diff

+ dhall-lang/tests/import/home/hello.dhall view

file too large to diff

+ dhall-lang/tests/import/success/customHeadersA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/customHeadersB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/hashFromCacheA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/hashFromCacheB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/headerForwardingA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/headerForwardingB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/nestedHashA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/nestedHashB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/noHeaderForwardingA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/noHeaderForwardingB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersENV.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersImportA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersImportB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersImportENV.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersImportFromEnvA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersImportFromEnvB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersImportFromEnvENV.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersOverrideA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersOverrideB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/originHeadersOverrideENV.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeChain1A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeChain1B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeChain2A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeChain2B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeEnvA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeEnvB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeImportErrorA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeImportErrorB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeNestedImportErrorA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeNestedImportErrorB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeNoError1A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeNoError1B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeNoError2A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeNoError2B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeNoError3A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeNoError3B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeSubExprA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeSubExprB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeWithVariableA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeWithVariableB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeWithWrongVariable1A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeWithWrongVariable1B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeWithWrongVariable2A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AlternativeWithWrongVariable2B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AsBytesA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AsBytesB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AsTextA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/AsTextB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/DontCacheIfHashA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/DontCacheIfHashB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/EnvSetA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/EnvSetAsTextA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/EnvSetAsTextB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/EnvSetB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/FilenameWithSpacesA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/FilenameWithSpacesB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/IgnorePoisonedCacheA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/IgnorePoisonedCacheB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/ImportRelativeToHomeA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/ImportRelativeToHomeB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/MixImportModesA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/MixImportModesB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/NormalizeA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/NormalizeB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/QuotedPathA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/QuotedPathB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/RecoverTransitiveFailureA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/RecoverTransitiveFailureB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/RemoteAsTextA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/RemoteAsTextB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/SimpleA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/SimpleB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/SimpleHashA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/SimpleHashB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/SimpleRemoteA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/SimpleRemoteB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/AbsoluteA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/AbsoluteB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Canonicalize1A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Canonicalize1B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Canonicalize2A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Canonicalize2B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Canonicalize3A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Canonicalize3B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Canonicalize4A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Canonicalize4B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Canonicalize5A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Canonicalize5B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Chain1A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Chain1B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Chain2A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Chain2B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Chain3A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Chain3B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/DontTryResolvingA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/DontTryResolvingB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/EnvA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/EnvB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/HashA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/HashB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/HomeA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/HomeB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/MissingA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/MissingB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Relative1A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Relative1B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Relative2A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/Relative2B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteCanonicalize1A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteCanonicalize1B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteCanonicalize2A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteCanonicalize2B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteCanonicalize3A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteCanonicalize3B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteCanonicalize4A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteCanonicalize4B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteChain1A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteChain1B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteChain2A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteChain2B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteChain3A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteChain3B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteChainEnvA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteChainEnvB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteChainMissingA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/asLocation/RemoteChainMissingB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/AllowedAllA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/AllowedAllB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/NoCORSFromLocalA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/NoCORSFromLocalB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/OnlyGithubA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/OnlyGithubB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/PreludeA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/PreludeB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/SelfImportAbsolute2A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/SelfImportAbsolute2B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/SelfImportAbsoluteA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/SelfImportAbsoluteB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/SelfImportRelative2A.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/SelfImportRelative2B.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/SelfImportRelativeA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/SelfImportRelativeB.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/TwoHopsA.dhall view

file too large to diff

+ dhall-lang/tests/import/success/unit/cors/TwoHopsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/WithRecordValueA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/WithRecordValueB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/access/0A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/access/0B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/access/1A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/access/1B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/0A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/0B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/1A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/1B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/prefer/0A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/prefer/0B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/projection/0A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/haskell-tutorial/projection/0B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/regression/ComplexRecordSimplificationA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/regression/ComplexRecordSimplificationB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/regression/NaturalFoldExtraArgA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/regression/NaturalFoldExtraArgB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/regression/ToMapQuotedFieldsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/regression/ToMapQuotedFieldsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/regression/TrickyBinderIdentityA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/regression/TrickyBinderIdentityB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/regression/UnsaturatedBuiltinsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/regression/UnsaturatedBuiltinsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/remoteSystemsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/remoteSystemsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/completionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/completionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/doubleShowA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/doubleShowB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/enumA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/enumB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/equalNoCommuteA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/equalNoCommuteB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/integerShowA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/integerShowB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/integerToDoubleA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/integerToDoubleB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/letAvoidCaptureA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/letAvoidCaptureB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/letenumA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/letenumB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/letletA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/letletB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/listBuildA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/listBuildB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/multiLineA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/multiLineB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/naturalBuildA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/naturalBuildB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/notEqualNoCommuteA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/notEqualNoCommuteB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/plusNoCommuteA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/plusNoCommuteB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/simpleAdditionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/simpleAdditionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/sortOperatorA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/sortOperatorB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/timesNoCommuteA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simple/timesNoCommuteB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/andA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/andB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/eqA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/eqB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/ifThenElseA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/ifThenElseB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/issue661A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/issue661B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/neA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/neB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/orA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/orB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/rightBiasedMergeWithinRecordProjectionWithinFieldSelection0A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/rightBiasedMergeWithinRecordProjectionWithinFieldSelection0B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/rightBiasedMergeWithinRecordProjectionWithinFieldSelection1A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/rightBiasedMergeWithinRecordProjectionWithinFieldSelection1B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/rightBiasedMergeWithinRecursiveRecordMergeWithinFieldselectionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/simplifications/rightBiasedMergeWithinRecursiveRecordMergeWithinFieldselectionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/AssertNormalizeArgumentA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/AssertNormalizeArgumentB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/BareInterpolationA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/BareInterpolationB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/BoolA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/BoolB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/BytesA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/BytesB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/BytesLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/BytesLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/CompletionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/CompletionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/DoubleA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/DoubleB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/DoubleLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/DoubleLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/DoubleShowA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/DoubleShowB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/DoubleShowValueA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/DoubleShowValueB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/EmptyAlternativeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/EmptyAlternativeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/EmptyToMapA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/EmptyToMapB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/EquivalenceNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/EquivalenceNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionApplicationCaptureA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionApplicationCaptureB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionApplicationNoSubstituteA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionApplicationNoSubstituteB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionApplicationNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionApplicationNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionApplicationSubstituteA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionApplicationSubstituteB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionTypeNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/FunctionTypeNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IfAlternativesIdenticalA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IfAlternativesIdenticalB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IfFalseA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IfFalseB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IfNormalizePredicateAndBranchesA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IfNormalizePredicateAndBranchesB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IfTrivialA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IfTrivialB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IfTrueA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IfTrueB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerClampA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerClampB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerClampNegativeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerClampNegativeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerClampPositiveA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerClampPositiveB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerClampZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerClampZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerNegateA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerNegateB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerNegateNegativeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerNegateNegativeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerNegatePositiveA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerNegatePositiveB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerNegateZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerNegateZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerNegativeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerNegativeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerPositiveA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerPositiveB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerShow-12A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerShow-12B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerShow12A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerShow12B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerShowA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerShowB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerToDouble-12A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerToDouble-12B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerToDouble12A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerToDouble12B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerToDoubleA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/IntegerToDoubleB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/KindA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/KindB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/LetA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/LetB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/LetWithTypeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/LetWithTypeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListBuildA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListBuildB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListBuildFoldFusionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListBuildFoldFusionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListBuildImplementationA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListBuildImplementationB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListFoldA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListFoldB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListFoldEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListFoldEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListFoldOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListFoldOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListHeadA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListHeadB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListHeadEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListHeadEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListHeadTwoA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListHeadTwoB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListIndexedA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListIndexedB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListIndexedEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListIndexedEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListIndexedOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListIndexedOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLastA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLastB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLastEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLastEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLastTwoA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLastTwoB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLengthA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLengthB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLengthEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLengthEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLengthOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListLengthOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListNormalizeElementsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListNormalizeElementsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListNormalizeTypeAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListNormalizeTypeAnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListReverseA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListReverseB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListReverseEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListReverseEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListReverseTwoA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ListReverseTwoB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeEmptyAlternativeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeEmptyAlternativeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeNoneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeNoneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeSomeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeSomeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeWithTypeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeWithTypeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeWithTypeNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/MergeWithTypeNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalBuildA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalBuildB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalBuildFoldFusionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalBuildFoldFusionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalBuildImplementationA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalBuildImplementationB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalEvenA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalEvenB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalEvenOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalEvenOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalEvenZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalEvenZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalFoldA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalFoldB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalFoldOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalFoldOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalFoldZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalFoldZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalIsZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalIsZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalIsZeroOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalIsZeroOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalIsZeroZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalIsZeroZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalOddA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalOddB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalOddOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalOddOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalOddZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalOddZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalShowA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalShowB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalShowOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalShowOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractEquivalentA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractEquivalentB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractFromZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractFromZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractGreaterA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractGreaterB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractLessA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractLessB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractNormalizeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractNormalizeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractZero0A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractZero0B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractZero1A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalSubtractZero1B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalToIntegerA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalToIntegerB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalToIntegerOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NaturalToIntegerOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NestedRecordProjectionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NestedRecordProjectionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NestedRecordProjectionByTypeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NestedRecordProjectionByTypeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NoneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/NoneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndEquivalentArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndEquivalentArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndLhsFalseA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndLhsFalseB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndLhsTrueA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndLhsTrueB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndRhsFalseA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndRhsFalseB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndRhsTrueA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorAndRhsTrueB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorEqualEquivalentArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorEqualEquivalentArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorEqualLhsTrueA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorEqualLhsTrueB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorEqualNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorEqualNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorEqualRhsTrueA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorEqualRhsTrueB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorListConcatenateLhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorListConcatenateLhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorListConcatenateListListA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorListConcatenateListListB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorListConcatenateNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorListConcatenateNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorListConcatenateRhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorListConcatenateRhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorNotEqualEquivalentArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorNotEqualEquivalentArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorNotEqualLhsFalseA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorNotEqualLhsFalseB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorNotEqualNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorNotEqualNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorNotEqualRhsFalseA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorNotEqualRhsFalseB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrEquivalentArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrEquivalentArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrLhsFalseA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrLhsFalseB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrLhsTrueA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrLhsTrueB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrRhsFalseA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrRhsFalseB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrRhsTrueA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorOrRhsTrueB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorPlusLhsZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorPlusLhsZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorPlusNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorPlusNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorPlusOneAndOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorPlusOneAndOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorPlusRhsZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorPlusRhsZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTextConcatenateLhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTextConcatenateLhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTextConcatenateLhsNonEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTextConcatenateLhsNonEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTextConcatenateRhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTextConcatenateRhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTextConcatenateRhsNonEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTextConcatenateRhsNonEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTextConcatenateTextTextA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTextConcatenateTextTextB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesLhsOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesLhsOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesLhsZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesLhsZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesRhsOneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesRhsOneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesRhsZeroA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesRhsZeroB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesTwoAndTwoA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OperatorTimesTwoAndTwoB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OptionalA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/OptionalB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitAllSugarsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitAllSugarsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitDottedFieldsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitDottedFieldsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitDuplicateFieldsNoCollisionsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitDuplicateFieldsNoCollisionsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitNixLikeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitNixLikeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitPun1A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitPun1B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitPun2A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitPun2B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitTriplicateFieldsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordLitTriplicateFieldsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeNonEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeNonEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeNormalizeProjectionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeNormalizeProjectionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeWithinFieldSelectionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeWithinFieldSelectionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionNormalizeFieldsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionNormalizeFieldsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionWithinFieldSelectionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordProjectionWithinFieldSelectionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordSelectionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordSelectionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordSelectionNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordSelectionNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordSortFieldsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordSortFieldsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordTypeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordTypeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordTypeEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordTypeSortFieldsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecordTypeSortFieldsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeCollisionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeCollisionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeLhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeLhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeNoCollisionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeNoCollisionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeRhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeRhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeWithinFieldSelection0A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeWithinFieldSelection0B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeWithinFieldSelection1A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeWithinFieldSelection1B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeWithinFieldSelection2A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeWithinFieldSelection2B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeWithinFieldSelection3A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordMergeWithinFieldSelection3B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeCollisionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeCollisionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeDeepA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeDeepB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeLhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeLhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeNoCollisionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeNoCollisionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeRhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeRhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeSortsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RecursiveRecordTypeMergeSortsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedMergeEquivalentArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedMergeEquivalentArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedMergeWithinFieldSelection0A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedMergeWithinFieldSelection0B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedMergeWithinFieldSelection1A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedMergeWithinFieldSelection1B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedMergeWithinFieldSelection2A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedMergeWithinFieldSelection2B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedMergeWithinFieldSelection3A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedMergeWithinFieldSelection3B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeCollisionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeCollisionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeLhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeLhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeNoCollisionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeNoCollisionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeRhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeRhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeWithinRecordProjectionA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/RightBiasedRecordMergeWithinRecordProjectionB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ShowConstructorEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ShowConstructorEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ShowConstructorNonEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ShowConstructorNonEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/SomeNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/SomeNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/SortA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/SortB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextInterpolateA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextInterpolateB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextLitNested1A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextLitNested1B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextLitNested2A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextLitNested2B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextLitNested3A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextLitNested3B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextNormalizeInterpolationsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextNormalizeInterpolationsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceAbstractA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceAbstractB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceAbstractHaystackA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceAbstractHaystackB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceEmpty1A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceEmpty1B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceEmpty2A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceEmpty2B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceEmpty3A.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceEmpty3B.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceMultipleA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceMultipleB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceNFCUnicodeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceNFCUnicodeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceNormalizationA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceNormalizationB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceOverlappingA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceOverlappingB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceSimpleA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceSimpleB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceUnicodeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceUnicodeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceVarA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextReplaceVarB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextShowA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextShowAllEscapesA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextShowAllEscapesB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextShowB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextShowEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextShowEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextShowInterpolatedA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TextShowInterpolatedB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TimeAsRecordA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TimeAsRecordB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ToMapA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ToMapB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ToMapWithTypeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/ToMapWithTypeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TrueA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TrueB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TypeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TypeAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TypeAnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/TypeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/UnionProjectConstructorA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/UnionProjectConstructorB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/UnionTypeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/UnionTypeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/UnionTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/UnionTypeEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/UnionTypeNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/UnionTypeNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/VariableA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/VariableB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithChainedA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithChainedB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithCreateIntermediateRecordsA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithCreateIntermediateRecordsB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithDesugarA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithDesugarB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithNestedA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithNestedB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithOnOptionalNoneA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithOnOptionalNoneB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithOnOptionalSomeA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithOnOptionalSomeB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithOptionalDeeplyNestedA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithOptionalDeeplyNestedB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithOptionalNestedA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithOptionalNestedB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithPartiallyAbstractA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithPartiallyAbstractB.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithPriorityA.dhall view

file too large to diff

+ dhall-lang/tests/normalization/success/unit/WithPriorityB.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/ImportHeadersExteriorHash.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/ProjectionByTypeNeedsParens.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/annotation.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/assertBinding.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/boundBuiltins.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/builtinWithIndex.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/bytesInvalid.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/bytesOddLength.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/doubleBoundsNeg.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/doubleBoundsPos.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/fSomeX.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/importAccess.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/incompleteIf.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/mandatoryNewline.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/nonBase16Hash.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/nonCharacter.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/nonCharacterUnbraced.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/nonUtf8.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/AnnotationNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/ApplicationNoSpace1.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/ApplicationNoSpace2.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/AssertNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/ForallNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/HeadersNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/IfNoSpace1.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/IfNoSpace2.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/IfNoSpace3.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/ImportAltNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/ImportHashedNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/LambdaNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/LetAnnotNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/LetNoSpace1.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/LetNoSpace2.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/LetNoSpace3.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/LetNoSpace4.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/ListLitEmptyNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/MergeAnnotationNoSpace3.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/MergeNoSpace1.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/MergeNoSpace2.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/NaturalPlusNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/RecordTypeNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/SomeNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/ToMapAnnotNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/ToMapNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/spacing/UnionTypeNoSpace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/surrogatePairUnbraced.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/time/DateTimeZone.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/time/InvalidDayOfMonth.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/time/InvalidHour.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/time/InvalidLeapSecond.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/time/InvalidMinute.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/time/InvalidMonth.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/time/InvalidSecond.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/time/NegativeYear.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/time/YearTooLarge.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/AssertNoAnnotation.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/BoolLitTrueWithIndex.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/BuiltinBoolWithIndex.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/BuiltinTypeWithIndex.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/ImportEnvWrongEscape.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/ListLitEmptyAnnotation.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/ListLitEmptyMissingAnnotation.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/ListLitTwoCommas.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/MergeAlone.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/MergeOneArgument.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/NaturalLitLeadingZero.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/OldUnionLitSyntax.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/ProjectionTwoCommas.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword00.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword01.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword02.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword03.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword04.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword05.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword06.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword07.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword08.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword09.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword10.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword11.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword12.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword13.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordFieldMustNotBeKeyword14.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordLitPunDotted.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/RecordTwoCommas.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/SomeAlone.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/UnionTypeTwoDelims.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/UrlWithQuotedPath.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/UsingToMap.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/WithPrecedence1.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/WithPrecedence2.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/WithPrecedence3.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/WithWhitespace.dhall view

file too large to diff

+ dhall-lang/tests/parser/failure/unit/showConstructorAlone.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/annotationsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/annotationsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/binaryA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/binaryB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/blockCommentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/blockCommentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/builtinNameAsFieldA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/builtinNameAsFieldB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/builtinsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/builtinsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/bytesA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/bytesB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/collectionImportTypeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/collectionImportTypeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/fieldsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/fieldsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/forallA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/forallB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/functionTypeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/functionTypeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/hexadecimalA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/hexadecimalB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/identifierA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/identifierB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/labelA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/labelB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/lambdaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/lambdaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/largeExpressionA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/largeExpressionB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/leadingSeparatorsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/leadingSeparatorsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/leadingTabsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/leadingTabsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/lineCommentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/lineCommentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/lineCommentCRLFA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/lineCommentCRLFB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/listA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/listB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/listWithCommentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/listWithCommentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/mergeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/mergeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/missingFooA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/missingFooB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/missingInParenthesesA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/missingInParenthesesB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/missingSlashA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/missingSlashB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/mixedBlockLineCommentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/mixedBlockLineCommentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/naturalA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/naturalB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/nestedBlockCommentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/nestedBlockCommentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/operatorsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/operatorsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/preferMissingNoSpacesA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/preferMissingNoSpacesB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/quotedBoundVariableA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/quotedBoundVariableB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/quotedLabelA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/quotedLabelB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/quotedRecordLabelA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/quotedRecordLabelB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/quotedUnionLabelA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/quotedUnionLabelB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/recordA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/recordB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/recordProjectionByExpressionA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/recordProjectionByExpressionB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/reservedPrefixA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/reservedPrefixB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/dollarSignA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/dollarSignB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/doubleQuotedStringA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/doubleQuotedStringB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/escapeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/escapeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/escapedDoubleQuotedStringA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/escapedDoubleQuotedStringB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/escapedSingleQuotedStringA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/escapedSingleQuotedStringB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/interestingA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/interestingB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/interiorIndentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/interiorIndentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/interpolatedDoubleQuotedStringA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/interpolatedDoubleQuotedStringB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/interpolatedSingleQuotedStringA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/interpolatedSingleQuotedStringB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/interpolationA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/interpolationB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineBlankLineA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineBlankLineB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineBlankLineCrlfA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineBlankLineCrlfB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineCorruptedLeadingWhitespaceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineCorruptedLeadingWhitespaceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineIndentedAndAlignedA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineIndentedAndAlignedB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineMismatchedLeadingWhitespaceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineMismatchedLeadingWhitespaceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilinePreserveCommentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilinePreserveCommentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineTabsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/multilineTabsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/nonAssignedUnicodeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/nonAssignedUnicodeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/preserveCommentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/preserveCommentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/singleLineA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/singleLineB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/singleQuoteConcatA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/singleQuoteConcatB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/singleQuotedStringA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/singleQuotedStringB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/templateA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/templateB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/twoLinesA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/twoLinesB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/unicodeBracedA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/unicodeBracedB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/unicodeDoubleQuotedStringA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/unicodeDoubleQuotedStringB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/unicodeEscapedA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/unicodeEscapedB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/text/unicodePlane16A.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/text/unicodePlane16B.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/time/DateTimeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/time/DateTimeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/time/DateTimeTimeZoneA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/time/DateTimeTimeZoneB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/time/LowercaseTA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/time/LowercaseTB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/time/TimeTimeZoneA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/time/TimeTimeZoneB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/time/TimeTimeZoneZA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/time/TimeTimeZoneZB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/toMapA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/toMapB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unicodeCommentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unicodeCommentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/AnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/AnnotationB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/AssertA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/AssertB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/AssertEquivalenceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/AssertEquivalenceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/AssertEquivalenceUnicodeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/AssertEquivalenceUnicodeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/AssertPrecedenceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/AssertPrecedenceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/BoolA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/BoolB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/BoolLitTrueA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/BoolLitTrueB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/BuiltinListBuildA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/BuiltinListBuildB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/CompletionA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/CompletionB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DateA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DateB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DateLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DateLiteralB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DeBruijnIndexA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DeBruijnIndexB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLit16bitA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLit16bitB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLit32bitA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLit32bitB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLit64bitA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLit64bitB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitExponentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitExponentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitExponentNegativeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitExponentNegativeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitExponentNoDotA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitExponentNoDotB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitInfinityA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitInfinityB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitNaNA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitNaNB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitNegInfinityA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitNegInfinityB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitNegZeroA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitNegZeroB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitNegativeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitNegativeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitPositiveA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitPositiveB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitSecretlyIntA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitSecretlyIntB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitZeroA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/DoubleLitZeroB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/EmptyRecordLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/EmptyRecordLiteralB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FieldA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FieldB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FieldBuiltinNameA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FieldBuiltinNameB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FieldQuotedA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FieldQuotedB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ForallA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ForallB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ForallNestedA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ForallNestedB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ForallUnderscoreA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ForallUnderscoreB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ForallUnicodeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ForallUnicodeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionApplicationMultipleArgsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionApplicationMultipleArgsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionApplicationOneArgA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionApplicationOneArgB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionTypeArrowA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionTypeArrowB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionTypePiA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionTypePiB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionTypePiNestedA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionTypePiNestedB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionTypePiUnderscoreA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionTypePiUnderscoreB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionTypePiUnicodeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/FunctionTypePiUnicodeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/IntegerLitNegativeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/IntegerLitNegativeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/IntegerLitPositiveA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/IntegerLitPositiveB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/KindA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/KindB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LambdaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LambdaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LambdaNestedA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LambdaNestedB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LambdaUnderscoreA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LambdaUnderscoreB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LambdaUnicodeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LambdaUnicodeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LetA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LetAnnotA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LetAnnotB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LetB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LetMultiA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LetMultiB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LetNestedA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LetNestedB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LetNoAnnotA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/LetNoAnnotB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitEmpty1A.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitEmpty1B.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitEmpty2A.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitEmpty2B.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitEmptyCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitEmptyCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitEmptyPrecedenceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitEmptyPrecedenceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitLeadingCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitLeadingCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitNonEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitNonEmptyAnnotatedA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitNonEmptyAnnotatedB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitNonEmptyB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitTrailingAndLeadingCommasA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitTrailingAndLeadingCommasB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitTrailingCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListLitTrailingCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListWithNewlineA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ListWithNewlineB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/MergeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/MergeAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/MergeAnnotationB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/MergeAnnotationPrecedenceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/MergeAnnotationPrecedenceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/MergeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/MergeParenAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/MergeParenAnnotationB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/MergeXYZA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/MergeXYZB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/NaturalLitA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/NaturalLitB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ProjectionA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ProjectionB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ProjectionLeadingCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ProjectionLeadingCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ProjectionTrailingAndLeadingCommasA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ProjectionTrailingAndLeadingCommasB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ProjectionTrailingCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ProjectionTrailingCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/QuotedBoolA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/QuotedBoolB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/QuotedTrueA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/QuotedTrueB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/QuotedTypeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/QuotedTypeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/QuotedVariableA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/QuotedVariableB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitDottedA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitDottedB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitDottedEscapeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitDottedEscapeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitDuplicatesA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitDuplicatesB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitEmptyBothCommasA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitEmptyBothCommasB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitEmptyLeadingCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitEmptyLeadingCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitEmptyTrailingCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitEmptyTrailingCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitLeadingCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitLeadingCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitNixLikeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitNixLikeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitPunA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitPunB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitPunDuplicateA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitPunDuplicateB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitPunMixedA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitPunMixedB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitPunSomeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitPunSomeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitSomeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitSomeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitTrailingAndLeadingCommasA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitTrailingAndLeadingCommasB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitTrailingCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordLitTrailingCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordProjectionByTypeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordProjectionByTypeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordProjectionByTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordProjectionByTypeEmptyB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeEmptyB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeEmptyCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeEmptyCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeLeadingCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeLeadingCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeTrailingAndLeadingCommasA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeTrailingAndLeadingCommasB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeTrailingCommaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/RecordTypeTrailingCommaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/SelectionSomeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/SelectionSomeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ShebangA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ShebangB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ShebangNixA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ShebangNixB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ShowConstructorA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ShowConstructorB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ShowConstructorWithValueA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ShowConstructorWithValueB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/SomeXA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/SomeXB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/SomeXYZA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/SomeXYZB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/SortA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/SortB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TimeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TimeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TimeLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TimeLiteralB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TimeZoneA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TimeZoneB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TimeZoneLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TimeZoneLiteralB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ToMapA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ToMapAnnotA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ToMapAnnotB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ToMapB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TrailingLineCommentWithoutNewlineA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TrailingLineCommentWithoutNewlineB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TypeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/TypeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeEmptyB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeEmptyDelimA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeEmptyDelimB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeLeadingDelimA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeLeadingDelimB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeSomeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeSomeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeTrailingAndLeadingDelimsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeTrailingAndLeadingDelimsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeTrailingDelimA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeTrailingDelimB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeXA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeXB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeXTYA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeXTYB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeXTYUA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeXTYUB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeXYA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeXYB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeXYTA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/UnionTypeXYTB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/VariableA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/VariableB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/VariableQuotedWithSpaceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/VariableQuotedWithSpaceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/VariableUnderscoreA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/VariableUnderscoreB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithMultipleA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithMultipleB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithPrecedence1A.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithPrecedence1B.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithPrecedence2A.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithPrecedence2B.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithPrecedence3A.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithPrecedence3B.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithSomeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/WithSomeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ifThenElseA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/ifThenElseB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationAbsoluteA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationAbsoluteB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationEnvA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationEnvB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationHashA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationHashB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationLocalA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationLocalB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationMissingA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationMissingB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationRemoteA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/AsLocationRemoteB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/HeadersA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/HeadersB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/HeadersDoubleHashA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/HeadersDoubleHashB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/HeadersDoubleHashPrecedenceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/HeadersDoubleHashPrecedenceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/HeadersHashPrecedenceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/HeadersHashPrecedenceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/HeadersInteriorHashA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/HeadersInteriorHashB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/ImportAsNoSpaceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/ImportAsNoSpaceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/MissingA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/MissingB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/asTextA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/asTextB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/environmentVariableBashA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/environmentVariableBashB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/environmentVariablePosixA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/environmentVariablePosixB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/hashA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/hashB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/importAltA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/importAltB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/inlineUsingA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/inlineUsingB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathAbsoluteA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathAbsoluteB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathHereA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathHereB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathHomeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathHomeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathParentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathParentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathTerminationLambdaA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathTerminationLambdaB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathTerminationListA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathTerminationListB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathTerminationRecordA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathTerminationRecordB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathTerminationUnionA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/pathTerminationUnionB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/quotedPathsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/quotedPathsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/unicodePathsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/unicodePathsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/basicHttpA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/basicHttpB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/basicHttpsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/basicHttpsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/emptyPath0A.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/emptyPath0B.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/emptyPath1A.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/emptyPath1B.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/emptyPathSegmentA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/emptyPathSegmentB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/emptyQueryA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/emptyQueryB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/escapedPathA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/escapedPathB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/escapedQueryA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/escapedQueryB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/fragmentParsesAsListAppendA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/fragmentParsesAsListAppendB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv4A.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv4B.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv4upperoctetsA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv4upperoctetsB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6longA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6longB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6mediumA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6mediumB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6shortA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6shortB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6verylongA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6verylongB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6withipv4A.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6withipv4B.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/portA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/portB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/potPourriA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/potPourriB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/userinfoA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/import/urls/userinfoB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolAndA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolAndAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolAndAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolAndB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolEQA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolEQAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolEQAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolEQB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolNEA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolNEAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolNEAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolNEB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolOrA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolOrAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolOrAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/BoolOrB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/EquivalenceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/EquivalenceAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/EquivalenceAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/EquivalenceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/ImportAltA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/ImportAltAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/ImportAltAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/ImportAltB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/ListAppendA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/ListAppendAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/ListAppendAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/ListAppendB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/NaturalPlusA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/NaturalPlusAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/NaturalPlusAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/NaturalPlusB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/NaturalTimesA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/NaturalTimesAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/NaturalTimesAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/NaturalTimesB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/PrecedenceBoolA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/PrecedenceBoolB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/PrecedenceEquivalenceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/PrecedenceEquivalenceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/PrecedenceNatA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/PrecedenceNatB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/PrecedenceRecordA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/PrecedenceRecordB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordMergeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordMergeAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordMergeAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordMergeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordMergeUnicodeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordMergeUnicodeAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordMergeUnicodeAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordMergeUnicodeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordTypeMergeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordTypeMergeAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordTypeMergeAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordTypeMergeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordTypeMergeUnicodeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordTypeMergeUnicodeAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordTypeMergeUnicodeAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RecursiveRecordTypeMergeUnicodeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RightBiasedRecordMergeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RightBiasedRecordMergeAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RightBiasedRecordMergeAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RightBiasedRecordMergeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RightBiasedRecordMergeUnicodeA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RightBiasedRecordMergeUnicodeAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RightBiasedRecordMergeUnicodeAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/RightBiasedRecordMergeUnicodeB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/TextAppendA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/TextAppendAssocA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/TextAppendAssocB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/unit/operators/TextAppendB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/usingToMapA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/usingToMapB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/whitespaceA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/whitespaceB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/whitespaceBuffetA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/whitespaceBuffetB.dhallb view

file too large to diff

+ dhall-lang/tests/parser/success/withQuestionMarkA.dhall view

file too large to diff

+ dhall-lang/tests/parser/success/withQuestionMarkB.dhallb view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/access/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/access/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/access/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/access/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/combineTypes/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/combineTypes/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/combineTypes/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/combineTypes/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/prefer/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/prefer/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/projection/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/projection/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/and/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/and/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/and/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/and/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/build/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/build/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/build/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/build/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/2A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/2B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/3A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/3B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/fold/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/fold/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/fold/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/fold/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/not/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/not/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/not/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/not/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/2A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/2B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/3A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/3B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/or/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/or/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/or/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/or/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/show/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/show/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/show/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Bool/show/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Double/show/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Double/show/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Double/show/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Double/show/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Integer/show/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Integer/show/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Integer/show/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Integer/show/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Integer/toDouble/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Integer/toDouble/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Integer/toDouble/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Integer/toDouble/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/all/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/all/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/all/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/all/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/any/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/any/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/any/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/any/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/build/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/build/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/build/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/build/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/concat/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/concat/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/concat/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/concat/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/concatMap/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/concatMap/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/concatMap/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/concatMap/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/filter/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/filter/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/filter/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/filter/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/fold/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/fold/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/fold/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/fold/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/fold/2A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/fold/2B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/generate/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/generate/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/generate/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/generate/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/head/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/head/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/head/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/head/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/indexed/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/indexed/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/indexed/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/indexed/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/iterate/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/iterate/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/iterate/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/iterate/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/last/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/last/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/last/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/last/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/length/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/length/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/length/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/length/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/map/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/map/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/map/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/map/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/null/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/null/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/null/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/null/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/replicate/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/replicate/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/replicate/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/replicate/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/reverse/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/reverse/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/reverse/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/reverse/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/shifted/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/shifted/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/shifted/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/shifted/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/unzip/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/unzip/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/unzip/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/List/unzip/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/build/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/build/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/build/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/build/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/enumerate/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/enumerate/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/enumerate/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/enumerate/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/even/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/even/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/even/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/even/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/fold/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/fold/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/fold/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/fold/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/fold/2A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/fold/2B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/isZero/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/isZero/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/isZero/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/isZero/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/odd/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/odd/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/odd/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/odd/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/product/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/product/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/product/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/product/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/show/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/show/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/show/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/show/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/sum/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/sum/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/sum/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/sum/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toDouble/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toDouble/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toDouble/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toDouble/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toInteger/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toInteger/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toInteger/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toInteger/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/all/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/all/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/all/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/all/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/any/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/any/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/any/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/any/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/build/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/build/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/build/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/build/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/2A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/2B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/filter/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/filter/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/filter/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/filter/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/fold/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/fold/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/fold/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/fold/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/2A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/2B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/2A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/2B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/length/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/length/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/length/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/length/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/map/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/map/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/map/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/map/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/null/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/null/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/null/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/null/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/toList/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/toList/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/toList/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/toList/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/unzip/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/unzip/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/unzip/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/unzip/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concat/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concat/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concat/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concat/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMap/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMap/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMap/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMap/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMapSep/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMapSep/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMapSep/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMapSep/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatSep/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatSep/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatSep/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatSep/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/show/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/show/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/show/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/show/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/remoteSystemsA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/remoteSystemsB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/doubleShowA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/doubleShowB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/enumA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/enumB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/integerShowA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/integerShowB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/integerToDoubleA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/integerToDoubleB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/letletA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/letletB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/listBuildA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/listBuildB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/multiLineA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/multiLineB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalBuildA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalBuildB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalPlusA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalPlusB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalShowA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalShowB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalToIntegerA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalToIntegerB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/sortOperatorA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/sortOperatorB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/andA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/andB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/eqA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/eqB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/ifThenElseA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/ifThenElseB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/neA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/neB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/orA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/orB.hash view

file too large to diff

+ dhall-lang/tests/type-inference/failure/DateApplyTime.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/SortInLet.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/hurkensParadox.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/recordOfKind.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/AnnotationRecordWrongFieldName.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/AnnotationRecordWrongFieldType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/AssertAlphaTrap.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/AssertAlphaTrap2.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/AssertDoubleZeros.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/AssertNotEquivalence.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/AssertTriviallyFalse.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/CompletionMissingRequiredField.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/CompletionWithWrongDefaultType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/CompletionWithWrongFieldName.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/CompletionWithWrongOverridenType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/EmptyToMap.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/EquivalenceNotSameType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/EquivalenceNotTerms.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/FunctionApplicationArgumentNotMatch.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/FunctionApplicationIsNotFunction.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/FunctionArgumentTypeNotAType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/FunctionTypeArgumentTypeNotAType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/FunctionTypeKindSort.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/FunctionTypeOutputTypeNotAType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/FunctionTypeTypeSort.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/HeterogenousToMap.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/IfBranchesNotMatch.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/IfBranchesNotTermTypeOrKind.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/IfNotBool.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/LetInSort.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/LetWithNonterminatingAnnotation.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/LetWithWrongAnnotation.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/ListLiteralEmptyNotType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/ListLiteralNotType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/ListLiteralTypesNotMatch.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeAlternativeHasNoHandler.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeAnnotationMismatch.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeAnnotationNotType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeBool.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeEmptyNeedsDirectAnnotation1.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeEmptyNeedsDirectAnnotation2.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeEmptyWithoutAnnotation.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeHandlerFreeVar.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeHandlerNotFunction.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeHandlerNotInUnion.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeHandlerNotMatchAlternativeType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeHandlersWithDifferentType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeLhsNotRecord.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeMissingHandler1.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeMissingHandler2.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeRhsNotUnion.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MergeUnusedHandler.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MistypedToMap1.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MistypedToMap2.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MistypedToMap3.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/MistypedToMap4.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/NaturalSubtractNotNatural.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/NestedAnnotInnerWrong.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/NestedAnnotOuterWrong.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/NonRecordToMap.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorAndNotBool.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorEqualNotBool.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorListConcatenateLhsNotList.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorListConcatenateListsNotMatch.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorListConcatenateNotListsButMatch.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorListConcatenateRhsNotList.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorNotEqualNotBool.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorOrNotBool.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorPlusNotNatural.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorTextConcatenateLhsNotText.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorTextConcatenateRhsNotText.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OperatorTimesNotNatural.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OptionalDeprecatedSyntaxAbsent.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/OptionalDeprecatedSyntaxPresent.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordLitDuplicateFieldsAbstract.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordLitDuplicateFieldsCollidingRecords.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordLitDuplicateFieldsNotRecords.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordProjectionByTypeFieldTypeMismatch.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordProjectionByTypeNotPresent.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordProjectionDuplicateFields.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordProjectionEmpty.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordProjectionNotPresent.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordProjectionNotRecord.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordSelectionEmpty.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordSelectionNotPresent.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordSelectionNotRecord.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordSelectionTypeNotUnionType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordTypeDuplicateFields.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecordTypeValueMember.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecursiveRecordMergeLhsNotRecord.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecursiveRecordMergeOverlapping.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecursiveRecordMergeRhsNotRecord.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecursiveRecordTypeMergeLhsNotRecordType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecursiveRecordTypeMergeOverlapping.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RecursiveRecordTypeMergeRhsNotRecordType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RemovedBuiltinOptionalBuild.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RemovedBuiltinOptionalFold.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RightBiasedRecordMergeLhsNotRecord.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/RightBiasedRecordMergeRhsNotRecord.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/ShowConstructorNotFullyApplied.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/ShowConstructorNotFullyAppliedOptional.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/ShowConstructorWrongArgument.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/SomeNotType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/Sort.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/TextLiteralInterpolateNotText.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/ToMapEmptyInvalidAnnotation.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/ToMapWrongKind.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/TypeAnnotationWrong.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/UnionConstructorFieldNotPresent.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/UnionDeprecatedConstructorsKeyword.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/UnionTypeDuplicateVariants1.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/UnionTypeDuplicateVariants2.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/UnionTypeNotType.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/VariableFree.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/WithInfersKind.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/WithInvalidOverrideA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/WithNotOptional.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/WithNotRecord.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/WithOptionalRecordTypeChanged.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/WithOptionalTypeChanged.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/failure/unit/Z.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/CacheImportsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/CacheImportsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/CacheImportsCanonicalizeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/CacheImportsCanonicalizeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/accessEncodedTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/accessEncodedTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/accessTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/accessTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/preferMixedRecordsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/preferMixedRecordsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/preferMixedRecordsSameFieldA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/preferMixedRecordsSameFieldB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/and/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/and/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/and/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/and/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/build/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/build/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/build/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/build/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/even/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/even/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/even/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/even/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/even/2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/even/2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/even/3A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/even/3B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/fold/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/fold/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/fold/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/fold/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/not/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/not/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/not/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/not/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/odd/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/odd/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/odd/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/odd/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/odd/2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/odd/2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/odd/3A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/odd/3B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/or/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/or/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/or/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/or/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/show/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/show/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/show/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Bool/show/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Double/show/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Double/show/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Double/show/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Double/show/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Integer/show/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Integer/show/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Integer/show/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Integer/show/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Integer/toDouble/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Integer/toDouble/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Integer/toDouble/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Integer/toDouble/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/all/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/all/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/all/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/all/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/any/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/any/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/any/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/any/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/build/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/build/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/build/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/build/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/concat/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/concat/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/concat/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/concat/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/concatMap/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/concatMap/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/concatMap/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/concatMap/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/filter/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/filter/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/filter/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/filter/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/fold/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/fold/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/fold/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/fold/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/fold/2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/fold/2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/generate/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/generate/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/generate/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/generate/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/head/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/head/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/head/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/head/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/indexed/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/indexed/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/indexed/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/indexed/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/iterate/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/iterate/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/iterate/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/iterate/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/last/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/last/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/last/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/last/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/length/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/length/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/length/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/length/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/map/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/map/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/map/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/map/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/null/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/null/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/null/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/null/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/replicate/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/replicate/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/replicate/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/replicate/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/reverse/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/reverse/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/reverse/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/reverse/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/shifted/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/shifted/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/shifted/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/shifted/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/unzip/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/unzip/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/unzip/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/List/unzip/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/00A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/00B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/01A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/01B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/02A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/02B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/03A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/03B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/04A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/04B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/05A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/05B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/06A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/06B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/07A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/07B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/08A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/08B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/09A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/09B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/10A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Monoid/10B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/build/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/build/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/build/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/build/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/enumerate/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/enumerate/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/enumerate/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/enumerate/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/even/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/even/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/even/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/even/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/fold/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/fold/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/fold/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/fold/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/fold/2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/fold/2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/isZero/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/isZero/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/isZero/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/isZero/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/odd/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/odd/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/odd/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/odd/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/product/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/product/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/product/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/product/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/show/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/show/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/show/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/show/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/sum/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/sum/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/sum/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/sum/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/toDouble/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/toDouble/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/toDouble/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/toDouble/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/toInteger/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/toInteger/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/toInteger/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Natural/toInteger/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/all/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/all/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/all/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/all/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/any/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/any/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/any/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/any/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/build/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/build/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/build/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/build/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/concat/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/concat/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/concat/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/concat/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/concat/2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/concat/2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/filter/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/filter/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/filter/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/filter/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/fold/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/fold/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/fold/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/fold/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/head/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/head/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/head/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/head/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/head/2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/head/2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/last/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/last/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/last/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/last/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/last/2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/last/2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/length/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/length/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/length/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/length/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/map/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/map/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/map/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/map/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/null/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/null/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/null/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/null/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/toList/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/toList/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/toList/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/toList/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/unzip/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/unzip/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/unzip/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Optional/unzip/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concat/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concat/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concat/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concat/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatMap/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatMap/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatMap/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatMap/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatMapSep/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatMapSep/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatMapSep/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatMapSep/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatSep/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatSep/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatSep/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/prelude/Text/concatSep/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/preludeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/preludeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/recordOfRecordOfTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/recordOfRecordOfTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/recordOfTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/recordOfTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/regression/LambdaInLetScoping1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/regression/LambdaInLetScoping1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/regression/LambdaInLetScoping2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/regression/LambdaInLetScoping2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/regression/RecursiveRecordTypeMergeTripleCollisionA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/regression/RecursiveRecordTypeMergeTripleCollisionB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/regression/TodoA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/regression/TodoB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/access/0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/access/0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/access/1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/access/1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/anonymousFunctionsInTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/anonymousFunctionsInTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/combineMixedRecordsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/combineMixedRecordsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/completionA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/completionB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/complexShadowingA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/complexShadowingB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/fieldsAreTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/fieldsAreTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/kindParameterA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/kindParameterB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/mergeEquivalenceA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/mergeEquivalenceB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/mixedFieldAccessA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/mixedFieldAccessB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/orderInsensitivityA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/orderInsensitivityB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/toMapEmptyNormalizeAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/toMapEmptyNormalizeAnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/unionsOfTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/unionsOfTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/AssertAlphaA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/AssertAlphaB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/AssertNaNA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/AssertNaNB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/AssertSimpleA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/AssertSimpleB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/AssertTrivialA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/AssertTrivialB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/BoolA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/BoolB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/BytesLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/BytesLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/CompletionA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/CompletionB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ConstructorShiftA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ConstructorShiftB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleShowA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleShowB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/EquivalenceA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/EquivalenceB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FalseA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FalseB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionApplicationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionApplicationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionApplicationNormalizeArgumentA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionApplicationNormalizeArgumentB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionApplicationNormalizeResultA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionApplicationNormalizeResultB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionDependentType1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionDependentType1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionDependentType2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionDependentType2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionNamedArgA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionNamedArgB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionNormalizeTypeAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionNormalizeTypeAnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindTermA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindTermB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTermTermA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTermTermB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTypeKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTypeKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTypeTermA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTypeTermB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTypeTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTypeTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeUsingArgumentA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeUsingArgumentB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfBranchesKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfBranchesKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfBranchesTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfBranchesTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerClampA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerClampB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerNegateA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerNegateB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerShowA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerShowB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerToDoubleA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerToDoubleB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/KindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/KindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetNestedTypeSynonymA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetNestedTypeSynonymB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetTypeSynonymA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetTypeSynonymB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetWithAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetWithAnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListBuildA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListBuildB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListFoldA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListFoldB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListHeadA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListHeadB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListIndexedA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListIndexedB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLastA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLastB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLengthA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLengthB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralEmptyNormalizeAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralEmptyNormalizeAnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralOneA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralOneB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListReverseA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListReverseB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeEmptyAlternativeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeEmptyAlternativeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeEmptyUnionA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeEmptyUnionB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeNoneA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeNoneB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneWithAnnotation0A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneWithAnnotation0B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneWithAnnotation1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneWithAnnotation1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOptionalA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOptionalB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeSomeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeSomeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeTrickyShadowingA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeTrickyShadowingB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalBuildA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalBuildB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalEvenA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalEvenB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalFoldA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalFoldB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalIsZeroA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalIsZeroB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalOddA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalOddB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalShowA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalShowB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalSubtractA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalSubtractB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalToIntegerA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalToIntegerB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NoneA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NoneB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorAndA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorAndB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorAndNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorAndNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorEqualA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorEqualB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorEqualNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorEqualNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorListConcatenateA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorListConcatenateB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorListConcatenateNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorListConcatenateNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorNotEqualA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorNotEqualB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorNotEqualNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorNotEqualNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorOrA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorOrB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorOrNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorOrNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorPlusA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorPlusB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorPlusNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorPlusNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTextConcatenateA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTextConcatenateB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTextConcatenateNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTextConcatenateNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTimesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTimesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTimesNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTimesNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OptionalA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OptionalB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitDottedFieldsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitDottedFieldsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitDottedFieldsMergeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitDottedFieldsMergeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitDuplicateFieldsAbstractA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitDuplicateFieldsAbstractB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitDuplicateFieldsNoCollisionsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitDuplicateFieldsNoCollisionsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitNormalizeFieldTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitNormalizeFieldTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitPunA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitPunB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitPunCaptureA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitPunCaptureB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitPunSomeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitPunSomeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitSortFieldsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordLitSortFieldsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordMixedKinds2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordMixedKinds2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordMixedKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordMixedKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedKindLikeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedKindLikeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedTypeLikeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedTypeLikeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneValueA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneValueB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeJudgmentalEqualityA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeJudgmentalEqualityB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionEmptyKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionEmptyKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionValueA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionValueB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionValueA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionValueB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeKindLikeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeKindLikeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeMixedKinds2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeMixedKinds2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeMixedKinds3A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeMixedKinds3B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeMixedKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeMixedKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeNestedKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeNestedKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeNestedKindLikeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeNestedKindLikeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeBoolTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeBoolTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeLhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeLhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeMixedKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeMixedKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeDeepA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeDeepB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeMixedKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeMixedKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeRhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeRhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoDifferentA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoDifferentB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ShowConstructorEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ShowConstructorEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ShowConstructorNonEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ShowConstructorNonEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ShowConstructorOptionalA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ShowConstructorOptionalB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/SomeTrueA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/SomeTrueB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralWithInterpolationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralWithInterpolationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextReplaceA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextReplaceB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextShowA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextShowB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ToMapA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ToMapAnnotatedA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ToMapAnnotatedB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ToMapB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ToMapInferTypeFromRecordA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ToMapInferTypeFromRecordB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TrueA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TrueB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationFunctionA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationFunctionB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationNormalizeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationNormalizeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationSortA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationSortB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionConstructorEmptyFieldA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionConstructorEmptyFieldB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionConstructorFieldA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionConstructorFieldB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeMixedKinds1A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeMixedKinds1B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeMixedKinds2A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeMixedKinds2B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeMixedKinds3A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeMixedKinds3B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeMixedKinds4A.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeMixedKinds4B.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeOneA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeOneB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithCreateIntermediateRecordsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithCreateIntermediateRecordsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithInfersKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithInfersKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithNestedA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithNestedB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithNewFieldA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithNewFieldB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithNewTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithNewTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithOptionalTypeUnchangedA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/WithOptionalTypeUnchangedB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/DateA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/DateB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/DateLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/DateLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/DateTimeLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/DateTimeLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/DateTimeTimeZoneLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/DateTimeTimeZoneLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/TimeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/TimeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/TimeLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/TimeLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/TimeTimeZoneLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/TimeTimeZoneLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/TimeZoneA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/TimeZoneB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/TimeZoneLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/time/TimeZoneLiteralB.dhall view

file too large to diff

dhall.cabal view

file too large to diff

+ dhall/Main.hs view

file too large to diff

+ doctest/Main.hs view

file too large to diff

− exec/Main.hs

file too large to diff

+ ghc-src/Dhall/Crypto.hs view

file too large to diff

+ ghc-src/Dhall/Import/HTTP.hs view

file too large to diff

+ ghc-src/Dhall/Import/Manager.hs view

file too large to diff

+ ghcjs-src/Dhall/Crypto.hs view

file too large to diff

+ ghcjs-src/Dhall/Import/HTTP.hs view

file too large to diff

+ ghcjs-src/Dhall/Import/Manager.hs view

file too large to diff

+ man/dhall.1 view

file too large to diff

src/Dhall.hs view

file too large to diff

+ src/Dhall/Binary.hs view

file too large to diff

src/Dhall/Context.hs view

file too large to diff

src/Dhall/Core.hs view

file too large to diff

+ src/Dhall/Deriving.hs view

file too large to diff

+ src/Dhall/Diff.hs view

file too large to diff

+ src/Dhall/DirectoryTree.hs view

file too large to diff

+ src/Dhall/DirectoryTree/Types.hs view

file too large to diff

+ src/Dhall/Eval.hs view

file too large to diff

+ src/Dhall/Format.hs view

file too large to diff

+ src/Dhall/Freeze.hs view

file too large to diff

src/Dhall/Import.hs view

file too large to diff

+ src/Dhall/Import/Headers.hs view

file too large to diff

+ src/Dhall/Import/Types.hs view

file too large to diff

+ src/Dhall/Lint.hs view

file too large to diff

+ src/Dhall/Main.hs view

file too large to diff

+ src/Dhall/Map.hs view

file too large to diff

+ src/Dhall/Marshal/Decode.hs view

file too large to diff

+ src/Dhall/Marshal/Encode.hs view

file too large to diff

+ src/Dhall/Marshal/Internal.hs view

file too large to diff

+ src/Dhall/Normalize.hs view

file too large to diff

+ src/Dhall/Optics.hs view

file too large to diff

+ src/Dhall/Package.hs view

file too large to diff

src/Dhall/Parser.hs view

file too large to diff

+ src/Dhall/Parser/Combinators.hs view

file too large to diff

+ src/Dhall/Parser/Expression.hs view

file too large to diff

+ src/Dhall/Parser/Token.hs view

file too large to diff

+ src/Dhall/Pretty.hs view

file too large to diff

+ src/Dhall/Pretty/Internal.hs view

file too large to diff

+ src/Dhall/Pretty/Internal.hs-boot view

file too large to diff

+ src/Dhall/Repl.hs view

file too large to diff

+ src/Dhall/Schemas.hs view

file too large to diff

+ src/Dhall/Set.hs view

file too large to diff

+ src/Dhall/Src.hs view

file too large to diff

+ src/Dhall/Substitution.hs view

file too large to diff

+ src/Dhall/Syntax.hs view

file too large to diff

+ src/Dhall/Syntax/Binding.hs view

file too large to diff

+ src/Dhall/Syntax/Chunks.hs view

file too large to diff

+ src/Dhall/Syntax/Chunks.hs-boot view

file too large to diff

+ src/Dhall/Syntax/Const.hs view

file too large to diff

+ src/Dhall/Syntax/Expr.hs view

file too large to diff

+ src/Dhall/Syntax/Expr.hs-boot view

file too large to diff

+ src/Dhall/Syntax/FunctionBinding.hs view

file too large to diff

+ src/Dhall/Syntax/Import.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Applicative.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Bifunctor.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Data.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Eq.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Foldable.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Functor.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Lift.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Monad.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/NFData.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Ord.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Pretty.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Pretty.hs-boot view

file too large to diff

+ src/Dhall/Syntax/Instances/Show.hs view

file too large to diff

+ src/Dhall/Syntax/Instances/Traversable.hs view

file too large to diff

+ src/Dhall/Syntax/MultiLet.hs view

file too large to diff

+ src/Dhall/Syntax/Operations.hs view

file too large to diff

+ src/Dhall/Syntax/Operations.hs-boot view

file too large to diff

+ src/Dhall/Syntax/RecordField.hs view

file too large to diff

+ src/Dhall/Syntax/Types.hs view

file too large to diff

+ src/Dhall/Syntax/Types.hs-boot view

file too large to diff

+ src/Dhall/Syntax/Var.hs view

file too large to diff

+ src/Dhall/TH.hs view

file too large to diff

+ src/Dhall/Tags.hs view

file too large to diff

src/Dhall/Tutorial.hs view

file too large to diff

src/Dhall/TypeCheck.hs view

file too large to diff

+ src/Dhall/URL.hs view

file too large to diff

+ src/Dhall/Util.hs view

file too large to diff

+ src/Dhall/Util.hs-boot view

file too large to diff

+ src/Dhall/Version.hs view

file too large to diff

+ tests/Dhall/Test/Dhall.hs view

file too large to diff

+ tests/Dhall/Test/Diff.hs view

file too large to diff

+ tests/Dhall/Test/DirectoryTree.hs view

file too large to diff

+ tests/Dhall/Test/Format.hs view

file too large to diff

+ tests/Dhall/Test/Freeze.hs view

file too large to diff

+ tests/Dhall/Test/Import.hs view

file too large to diff

+ tests/Dhall/Test/Lint.hs view

file too large to diff

+ tests/Dhall/Test/Main.hs view

file too large to diff

+ tests/Dhall/Test/Normalization.hs view

file too large to diff

+ tests/Dhall/Test/Package.hs view

file too large to diff

+ tests/Dhall/Test/Parser.hs view

file too large to diff

+ tests/Dhall/Test/QuickCheck.hs view

file too large to diff

+ tests/Dhall/Test/Regression.hs view

file too large to diff

+ tests/Dhall/Test/Schemas.hs view

file too large to diff

+ tests/Dhall/Test/SemanticHash.hs view

file too large to diff

+ tests/Dhall/Test/Substitution.hs view

file too large to diff

+ tests/Dhall/Test/TH.hs view

file too large to diff

+ tests/Dhall/Test/Tags.hs view

file too large to diff

+ tests/Dhall/Test/Tutorial.hs view

file too large to diff

+ tests/Dhall/Test/TypeInference.hs view

file too large to diff

+ tests/Dhall/Test/Util.hs view

file too large to diff

+ tests/diff/appList.txt view

file too large to diff

+ tests/diff/appListA.dhall view

file too large to diff

+ tests/diff/appListB.dhall view

file too large to diff

+ tests/diff/emptyList.txt view

file too large to diff

+ tests/diff/emptyListA.dhall view

file too large to diff

+ tests/diff/emptyListB.dhall view

file too large to diff

+ tests/diff/function.txt view

file too large to diff

+ tests/diff/functionA.dhall view

file too large to diff

+ tests/diff/functionB.dhall view

file too large to diff

+ tests/diff/insideList.txt view

file too large to diff

+ tests/diff/insideListA.dhall view

file too large to diff

+ tests/diff/insideListB.dhall view

file too large to diff

+ tests/diff/nonEmptyList.txt view

file too large to diff

+ tests/diff/nonEmptyListA.dhall view

file too large to diff

+ tests/diff/nonEmptyListB.dhall view

file too large to diff

+ tests/diff/with.txt view

file too large to diff

+ tests/diff/withA.dhall view

file too large to diff

+ tests/diff/withB.dhall view

file too large to diff

+ tests/format/applicationMultilineA.dhall view

file too large to diff

+ tests/format/applicationMultilineB.dhall view

file too large to diff

+ tests/format/asciiA.dhall view

file too large to diff

+ tests/format/asciiB.dhall view

file too large to diff

+ tests/format/concatSepA.dhall view

file too large to diff

+ tests/format/concatSepB.dhall view

file too large to diff

+ tests/format/dottedFieldsA.dhall view

file too large to diff

+ tests/format/dottedFieldsB.dhall view

file too large to diff

+ tests/format/dottedFieldsCommentsA.dhall view

file too large to diff

+ tests/format/dottedFieldsCommentsB.dhall view

file too large to diff

+ tests/format/doubleRoundA.dhall view

file too large to diff

+ tests/format/doubleRoundB.dhall view

file too large to diff

+ tests/format/duplicatesA.dhall view

file too large to diff

+ tests/format/duplicatesB.dhall view

file too large to diff

+ tests/format/emptyRecordA.dhall view

file too large to diff

+ tests/format/emptyRecordB.dhall view

file too large to diff

+ tests/format/envVarsA.dhall view

file too large to diff

+ tests/format/envVarsB.dhall view

file too large to diff

+ tests/format/escapeNumericLabelA.dhall view

file too large to diff

+ tests/format/escapeNumericLabelB.dhall view

file too large to diff

+ tests/format/escapeSingleQuotedOpenInterpolationA.dhall view

file too large to diff

+ tests/format/escapeSingleQuotedOpenInterpolationB.dhall view

file too large to diff

+ tests/format/fieldOrderA.dhall view

file too large to diff

+ tests/format/fieldOrderB.dhall view

file too large to diff

+ tests/format/functionLikeA.dhall view

file too large to diff

+ tests/format/functionLikeB.dhall view

file too large to diff

+ tests/format/headerA.dhall view

file too large to diff

+ tests/format/headerB.dhall view

file too large to diff

+ tests/format/headerNoNewlineA.dhall view

file too large to diff

+ tests/format/headerNoNewlineB.dhall view

file too large to diff

+ tests/format/ifThenElseA.dhall view

file too large to diff

+ tests/format/ifThenElseB.dhall view

file too large to diff

+ tests/format/importAccessA.dhall view

file too large to diff

+ tests/format/importAccessB.dhall view

file too large to diff

+ tests/format/importAltPrecedenceA.dhall view

file too large to diff

+ tests/format/importAltPrecedenceB.dhall view

file too large to diff

+ tests/format/importLines2A.dhall view

file too large to diff

+ tests/format/importLines2B.dhall view

file too large to diff

+ tests/format/importLinesA.dhall view

file too large to diff

+ tests/format/importLinesB.dhall view

file too large to diff

+ tests/format/importSuffixA.dhall view

file too large to diff

+ tests/format/importSuffixB.dhall view

file too large to diff

+ tests/format/innerMultilineA.dhall view

file too large to diff

+ tests/format/innerMultilineB.dhall view

file too large to diff

+ tests/format/interpolation0A.dhall view

file too large to diff

+ tests/format/interpolation0B.dhall view

file too large to diff

+ tests/format/ipfsA.dhall view

file too large to diff

+ tests/format/ipfsB.dhall view

file too large to diff

+ tests/format/issue1301A.dhall view

file too large to diff

+ tests/format/issue1301B.dhall view

file too large to diff

+ tests/format/issue1400-1A.dhall view

file too large to diff

+ tests/format/issue1400-1B.dhall view

file too large to diff

+ tests/format/issue1400-2A.dhall view

file too large to diff

+ tests/format/issue1400-2B.dhall view

file too large to diff

+ tests/format/issue1413A.dhall view

file too large to diff

+ tests/format/issue1413B.dhall view

file too large to diff

+ tests/format/issue1545-1A.dhall view

file too large to diff

+ tests/format/issue1545-1B.dhall view

file too large to diff

+ tests/format/issue1545-2A.dhall view

file too large to diff

+ tests/format/issue1545-2B.dhall view

file too large to diff

+ tests/format/issue1687A.dhall view

file too large to diff

+ tests/format/issue1687B.dhall view

file too large to diff

+ tests/format/issue1805KeywordRecordFieldShouldBeQuotedA.dhall view

file too large to diff

+ tests/format/issue1805KeywordRecordFieldShouldBeQuotedB.dhall view

file too large to diff

+ tests/format/issue1805SomeQuotedInLetButNotInRecordA.dhall view

file too large to diff

+ tests/format/issue1805SomeQuotedInLetButNotInRecordB.dhall view

file too large to diff

+ tests/format/issue183A.dhall view

file too large to diff

+ tests/format/issue183B.dhall view

file too large to diff

+ tests/format/issue2047A.dhall view

file too large to diff

+ tests/format/issue2047B.dhall view

file too large to diff

+ tests/format/issue2078A.dhall view

file too large to diff

+ tests/format/issue2078B.dhall view

file too large to diff

+ tests/format/issue2601A.dhall view

file too large to diff

+ tests/format/issue2601B.dhall view

file too large to diff

+ tests/format/largeExponentA.dhall view

file too large to diff

+ tests/format/largeExponentB.dhall view

file too large to diff

+ tests/format/largeRecordA.dhall view

file too large to diff

+ tests/format/largeRecordB.dhall view

file too large to diff

+ tests/format/letA.dhall view

file too large to diff

+ tests/format/letAnnotatedShortA.dhall view

file too large to diff

+ tests/format/letAnnotatedShortB.dhall view

file too large to diff

+ tests/format/letB.dhall view

file too large to diff

+ tests/format/letCommentsA.dhall view

file too large to diff

+ tests/format/letCommentsB.dhall view

file too large to diff

+ tests/format/letLineCommentsAfterVariableA.dhall view

file too large to diff

+ tests/format/letLineCommentsAfterVariableB.dhall view

file too large to diff

+ tests/format/letLongCommentsA.dhall view

file too large to diff

+ tests/format/letLongCommentsB.dhall view

file too large to diff

+ tests/format/letNewlineCommentsA.dhall view

file too large to diff

+ tests/format/letNewlineCommentsB.dhall view

file too large to diff

+ tests/format/letShortCommentsA.dhall view

file too large to diff

+ tests/format/letShortCommentsB.dhall view

file too large to diff

+ tests/format/multilineA.dhall view

file too large to diff

+ tests/format/multilineArgumentA.dhall view

file too large to diff

+ tests/format/multilineArgumentB.dhall view

file too large to diff

+ tests/format/multilineB.dhall view

file too large to diff

+ tests/format/multilineTrailingSingleQuoteA.dhall view

file too large to diff

+ tests/format/multilineTrailingSingleQuoteB.dhall view

file too large to diff

+ tests/format/multilineTrailingWhitespaceA.dhall view

file too large to diff

+ tests/format/multilineTrailingWhitespaceB.dhall view

file too large to diff

+ tests/format/negativeTimeZoneA.dhall view

file too large to diff

+ tests/format/negativeTimeZoneB.dhall view

file too large to diff

+ tests/format/nestedAnnotationA.dhall view

file too large to diff

+ tests/format/nestedAnnotationB.dhall view

file too large to diff

+ tests/format/numericLiteralsA.dhall view

file too large to diff

+ tests/format/numericLiteralsB.dhall view

file too large to diff

+ tests/format/parentA.dhall view

file too large to diff

+ tests/format/parentB.dhall view

file too large to diff

+ tests/format/parenthesizeUsingA.dhall view

file too large to diff

+ tests/format/parenthesizeUsingB.dhall view

file too large to diff

+ tests/format/preserveShebangA.dhall view

file too large to diff

+ tests/format/preserveShebangB.dhall view

file too large to diff

+ tests/format/projectionOrderA.dhall view

file too large to diff

+ tests/format/projectionOrderB.dhall view

file too large to diff

+ tests/format/punA.dhall view

file too large to diff

+ tests/format/punB.dhall view

file too large to diff

+ tests/format/punCommentsA.dhall view

file too large to diff

+ tests/format/punCommentsB.dhall view

file too large to diff

+ tests/format/recordCompletionA.dhall view

file too large to diff

+ tests/format/recordCompletionB.dhall view

file too large to diff

+ tests/format/recordLitComments0A.dhall view

file too large to diff

+ tests/format/recordLitComments0B.dhall view

file too large to diff

+ tests/format/recordLitComments1A.dhall view

file too large to diff

+ tests/format/recordLitComments1B.dhall view

file too large to diff

+ tests/format/recordLitMultilineBlockCommentsA.dhall view

file too large to diff

+ tests/format/recordLitMultilineBlockCommentsB.dhall view

file too large to diff

+ tests/format/recordTypeCommentsA.dhall view

file too large to diff

+ tests/format/recordTypeCommentsB.dhall view

file too large to diff

+ tests/format/sha256PrintingA.dhall view

file too large to diff

+ tests/format/sha256PrintingB.dhall view

file too large to diff

+ tests/format/significantLeadingSpacesA.dhall view

file too large to diff

+ tests/format/significantLeadingSpacesB.dhall view

file too large to diff

+ tests/format/stringWithNullA.dhall view

file too large to diff

+ tests/format/stringWithNullB.dhall view

file too large to diff

+ tests/format/textLitNewlinesOnlyA.dhall view

file too large to diff

+ tests/format/textLitNewlinesOnlyB.dhall view

file too large to diff

+ tests/format/timePrecisionA.dhall view

file too large to diff

+ tests/format/timePrecisionB.dhall view

file too large to diff

+ tests/format/unicodeA.dhall view

file too large to diff

+ tests/format/unicodeB.dhall view

file too large to diff

+ tests/format/urlsA.dhall view

file too large to diff

+ tests/format/urlsB.dhall view

file too large to diff

+ tests/format/usingToMapA.dhall view

file too large to diff

+ tests/format/usingToMapB.dhall view

file too large to diff

+ tests/format/withA.dhall view

file too large to diff

+ tests/format/withB.dhall view

file too large to diff

+ tests/format/withPrecedenceA.dhall view

file too large to diff

+ tests/format/withPrecedenceB.dhall view

file too large to diff

+ tests/format/withQuestionA.dhall view

file too large to diff

+ tests/format/withQuestionB.dhall view

file too large to diff

+ tests/freeze/cached/True.dhall view

file too large to diff

+ tests/freeze/cached/cachedA.dhall view

file too large to diff

+ tests/freeze/cached/cachedB.dhall view

file too large to diff

+ tests/freeze/cached/idempotentA.dhall view

file too large to diff

+ tests/freeze/cached/idempotentB.dhall view

file too large to diff

+ tests/freeze/cached/incorrectHashA.dhall view

file too large to diff

+ tests/freeze/cached/incorrectHashB.dhall view

file too large to diff

+ tests/freeze/cached/protectedA.dhall view

file too large to diff

+ tests/freeze/cached/protectedB.dhall view

file too large to diff

+ tests/freeze/cached/unprotectedA.dhall view

file too large to diff

+ tests/freeze/cached/unprotectedB.dhall view

file too large to diff

+ tests/freeze/secure/True.dhall view

file too large to diff

+ tests/freeze/secure/cachedA.dhall view

file too large to diff

+ tests/freeze/secure/cachedB.dhall view

file too large to diff

+ tests/freeze/secure/incorrectHashA.dhall view

file too large to diff

+ tests/freeze/secure/incorrectHashB.dhall view

file too large to diff

+ tests/freeze/secure/protectedA.dhall view

file too large to diff

+ tests/freeze/secure/protectedB.dhall view

file too large to diff

+ tests/freeze/secure/unprotectedA.dhall view

file too large to diff

+ tests/freeze/secure/unprotectedB.dhall view

file too large to diff

+ tests/lint/success/PreludeExtensionA.dhall view

file too large to diff

+ tests/lint/success/PreludeExtensionB.dhall view

file too large to diff

+ tests/lint/success/assertA.dhall view

file too large to diff

+ tests/lint/success/assertB.dhall view

file too large to diff

+ tests/lint/success/fixAssertA.dhall view

file too large to diff

+ tests/lint/success/fixAssertB.dhall view

file too large to diff

+ tests/lint/success/issue1586A.dhall view

file too large to diff

+ tests/lint/success/issue1586B.dhall view

file too large to diff

+ tests/lint/success/multiletA.dhall view

file too large to diff

+ tests/lint/success/multiletB.dhall view

file too large to diff

+ tests/lint/success/regression0A.dhall view

file too large to diff

+ tests/lint/success/regression0B.dhall view

file too large to diff

+ tests/package/dir/package.dhall view

file too large to diff

+ tests/package/dir/subdirectory1/test.dhall view

file too large to diff

+ tests/package/dir/subdirectory2/wrong-extension.txt view

file too large to diff

+ tests/package/dir/test.dhall view

file too large to diff

+ tests/package/dir/wrong-extension.txt view

file too large to diff

+ tests/package/empty/wrong-extension.txt view

file too large to diff

+ tests/package/other/package.dhall view

file too large to diff

+ tests/package/package.dhall view

file too large to diff

+ tests/package/test.dhall view

file too large to diff

+ tests/package/test/test.dhall view

file too large to diff

+ tests/recursive/expr0.dhall view

file too large to diff

+ tests/recursive/expr1.dhall view

file too large to diff

+ tests/regression/issue151a.dhall view

file too large to diff

+ tests/regression/issue151b.dhall view

file too large to diff

+ tests/regression/issue1584.dhall view

file too large to diff

+ tests/regression/issue164.dhall view

file too large to diff

+ tests/regression/issue1646.dhall view

file too large to diff

+ tests/regression/issue1732.dhall view

file too large to diff

+ tests/regression/issue1884.dhall view

file too large to diff

+ tests/regression/issue201.dhall view

file too large to diff

+ tests/regression/issue2088.dhall view

file too large to diff

+ tests/regression/issue216a.dhall view

file too large to diff

+ tests/regression/issue216b.dhall view

file too large to diff

+ tests/schemas/multipleA.dhall view

file too large to diff

+ tests/schemas/multipleB.dhall view

file too large to diff

+ tests/schemas/multipleSchema.dhall view

file too large to diff

+ tests/schemas/personA.dhall view

file too large to diff

+ tests/schemas/personB.dhall view

file too large to diff

+ tests/schemas/personSchema.dhall view

file too large to diff

+ tests/tags/all.tags view

file too large to diff

+ tests/tags/let.dhall view

file too large to diff

+ tests/tags/let.tags view

file too large to diff

+ tests/tags/nonunicode.dhall view

file too large to diff

+ tests/tags/nonunicode.tags view

file too large to diff

+ tests/tags/record.dhall view

file too large to diff

+ tests/tags/record.tags view

file too large to diff

+ tests/tags/recordlit.dhall view

file too large to diff

+ tests/tags/recordlit.tags view

file too large to diff

+ tests/tags/simple.dhall view

file too large to diff

+ tests/tags/simple.tags view

file too large to diff

+ tests/tags/unicode.dhall view

file too large to diff

+ tests/tags/unicode.tags view

file too large to diff

+ tests/tags/union.dhall view

file too large to diff

+ tests/tags/union.tags view

file too large to diff

+ tests/th/Department.dhall view

file too large to diff

+ tests/th/Employee.dhall view

file too large to diff

+ tests/th/HigherKindSingle.dhall view

file too large to diff

+ tests/th/HigherKindUnion.dhall view

file too large to diff

+ tests/th/Time.dhall view

file too large to diff

+ tests/th/example.dhall view

file too large to diff

+ tests/th/issue2066.dhall view

file too large to diff

+ tests/to-directory-tree/fixpoint-allow-path-separators.dhall view

file too large to diff

+ tests/to-directory-tree/fixpoint-empty.dhall view

file too large to diff

+ tests/to-directory-tree/fixpoint-helper.dhall view

file too large to diff

+ tests/to-directory-tree/fixpoint-permissions.dhall view

file too large to diff

+ tests/to-directory-tree/fixpoint-simple.dhall view

file too large to diff

+ tests/to-directory-tree/fixpoint-usergroup.dhall view

file too large to diff

+ tests/to-directory-tree/type.dhall view

file too large to diff

+ tests/tutorial/Union.dhall view

file too large to diff

+ tests/tutorial/process.dhall view

file too large to diff

+ tests/tutorial/substitution1.dhall view

file too large to diff

+ tests/tutorial/substitution2.dhall view

file too large to diff

+ tests/tutorial/substitution3.dhall view

file too large to diff

+ tests/tutorial/unions0A.dhall view

file too large to diff

+ tests/tutorial/unions0B.dhall view

file too large to diff

+ tests/tutorial/unions1A.dhall view

file too large to diff

+ tests/tutorial/unions1B.dhall view

file too large to diff

+ tests/tutorial/unions3A.dhall view

file too large to diff

+ tests/tutorial/unions3B.dhall view

file too large to diff

+ tests/tutorial/unions4A.dhall view

file too large to diff

+ tests/tutorial/unions4B.dhall view

file too large to diff