diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,46 @@ +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 +* 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: diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,24 +1,27 @@ -Copyright (c) 2017 Gabriel Gonzalez +Copyright (c) 2018 Gabriel 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. diff --git a/Prelude/Monoid b/Prelude/Monoid --- a/Prelude/Monoid +++ b/Prelude/Monoid @@ -1,1 +1,1 @@ -https://raw.githubusercontent.com/dhall-lang/Prelude/a22da69657b9316a3c51ba0bf80c9d4024db3fce/Monoid sha256:7c753f458fb433ef50e2fc517c0eaffbf21afd07186cefa92ea77173fe83304e +https://raw.githubusercontent.com/dhall-lang/Prelude/a22da69657b9316a3c51ba0bf80c9d4024db3fce/Monoid sha256:c4ff4f04ce9d3b7b579ff2ac7fe00258d665c701f895493b73082b750b28553d diff --git a/Prelude/package.dhall b/Prelude/package.dhall --- a/Prelude/package.dhall +++ b/Prelude/package.dhall @@ -1,1 +1,1 @@ -https://raw.githubusercontent.com/dhall-lang/Prelude/e9c90396c02f9eb0fe66c00c544615cbfa068f34/package.dhall sha256:9fbb8a6db3360fa30086ea8462dc36087f0e4f87af2a1f802a8befdc5a08f809 +https://raw.githubusercontent.com/dhall-lang/Prelude/e9c90396c02f9eb0fe66c00c544615cbfa068f34/package.dhall sha256:534e4a9e687ba74bfac71b30fc27aa269c0465087ef79bf483e876781602a454 diff --git a/benchmark/deep-nested-large-record/Main.hs b/benchmark/deep-nested-large-record/Main.hs --- a/benchmark/deep-nested-large-record/Main.hs +++ b/benchmark/deep-nested-large-record/Main.hs @@ -25,7 +25,7 @@ issue412 prelude = Criterion.whnf TypeCheck.typeOf expr where expr - = Core.Let "prelude" Nothing prelude + = Core.Let (pure (Core.Binding "prelude" Nothing prelude)) $ Core.ListLit Nothing $ Seq.replicate 5 $ Core.Var (Core.V "prelude" 0) `Core.Field` "types" `Core.Field` "Little" `Core.Field` "Foo" @@ -33,12 +33,15 @@ unionPerformance :: Core.Expr s TypeCheck.X -> Criterion.Benchmarkable unionPerformance prelude = Criterion.whnf TypeCheck.typeOf expr where - expr = - Core.Let "x" Nothing - (Core.Let "big" Nothing (prelude `Core.Field` "types" `Core.Field` "Big") - (Core.Prefer "big" "big") - ) - "x" + innerBinding = + Core.Binding "big" Nothing + (prelude `Core.Field` "types" `Core.Field` "Big") + + outerBinding = + Core.Binding "x" Nothing + (Core.Let (pure innerBinding) (Core.Prefer "big" "big")) + + expr = Core.Let (pure outerBinding) "x" main :: IO () main = do diff --git a/dhall.cabal b/dhall.cabal --- a/dhall.cabal +++ b/dhall.cabal @@ -1,5 +1,5 @@ Name: dhall -Version: 1.18.0 +Version: 1.19.0 Cabal-Version: >=1.10 Build-Type: Simple Tested-With: GHC == 8.0.1 @@ -23,87 +23,268 @@ Read "Dhall.Tutorial" to learn how to use this library Category: Compiler Extra-Source-Files: + benchmark/deep-nested-large-record/*.dhall + benchmark/examples/*.dhall CHANGELOG.md - Prelude/package.dhall Prelude/Monoid + Prelude/package.dhall tests/format/*.dhall - tests/normalization/tutorial/combineTypes/*.dhall - tests/normalization/tutorial/projection/*.dhall - tests/normalization/*.dhall - tests/normalization/examples/Bool/and/*.dhall - tests/normalization/examples/Bool/build/*.dhall - tests/normalization/examples/Bool/even/*.dhall - tests/normalization/examples/Bool/fold/*.dhall - tests/normalization/examples/Bool/not/*.dhall - tests/normalization/examples/Bool/odd/*.dhall - tests/normalization/examples/Bool/or/*.dhall - tests/normalization/examples/Bool/show/*.dhall - tests/normalization/examples/Double/show/*.dhall - tests/normalization/examples/Integer/show/*.dhall - tests/normalization/examples/Integer/toDouble/*.dhall - tests/normalization/examples/List/all/*.dhall - tests/normalization/examples/List/any/*.dhall - tests/normalization/examples/List/build/*.dhall - tests/normalization/examples/List/concat/*.dhall - tests/normalization/examples/List/concatMap/*.dhall - tests/normalization/examples/List/filter/*.dhall - tests/normalization/examples/List/fold/*.dhall - tests/normalization/examples/List/generate/*.dhall - tests/normalization/examples/List/head/*.dhall - tests/normalization/examples/List/indexed/*.dhall - tests/normalization/examples/List/iterate/*.dhall - tests/normalization/examples/List/last/*.dhall - tests/normalization/examples/List/length/*.dhall - tests/normalization/examples/List/map/*.dhall - tests/normalization/examples/List/null/*.dhall - tests/normalization/examples/List/replicate/*.dhall - tests/normalization/examples/List/reverse/*.dhall - tests/normalization/examples/List/shifted/*.dhall - tests/normalization/examples/List/unzip/*.dhall - tests/normalization/examples/Natural/build/*.dhall - tests/normalization/examples/Natural/enumerate/*.dhall - tests/normalization/examples/Natural/even/*.dhall - tests/normalization/examples/Natural/fold/*.dhall - tests/normalization/examples/Natural/isZero/*.dhall - tests/normalization/examples/Natural/odd/*.dhall - tests/normalization/examples/Natural/product/*.dhall - tests/normalization/examples/Natural/show/*.dhall - tests/normalization/examples/Natural/sum/*.dhall - tests/normalization/examples/Natural/toDouble/*.dhall - tests/normalization/examples/Natural/toInteger/*.dhall - tests/normalization/examples/Optional/all/*.dhall - tests/normalization/examples/Optional/any/*.dhall - tests/normalization/examples/Optional/build/*.dhall - tests/normalization/examples/Optional/concat/*.dhall - tests/normalization/examples/Optional/filter/*.dhall - tests/normalization/examples/Optional/fold/*.dhall - tests/normalization/examples/Optional/head/*.dhall - tests/normalization/examples/Optional/last/*.dhall - tests/normalization/examples/Optional/length/*.dhall - tests/normalization/examples/Optional/map/*.dhall - tests/normalization/examples/Optional/null/*.dhall - tests/normalization/examples/Optional/toList/*.dhall - tests/normalization/examples/Optional/unzip/*.dhall - tests/normalization/examples/Text/concat/*.dhall - tests/normalization/examples/Text/concatMap/*.dhall - tests/normalization/examples/Text/concatMapSep/*.dhall - tests/normalization/examples/Text/concatSep/*.dhall - tests/normalization/simplifications/*.dhall - tests/parser/*.dhall + tests/import/data/fieldOrder/*.dhall + tests/import/data/foo/bar/*.dhall + tests/import/failure/*.dhall + tests/import/success/*.dhall + tests/normalization/success/*.dhall + tests/normalization/success/haskell-tutorial/access/*.dhall + tests/normalization/success/haskell-tutorial/combineTypes/*.dhall + tests/normalization/success/haskell-tutorial/prefer/*.dhall + tests/normalization/success/haskell-tutorial/projection/*.dhall + tests/normalization/success/prelude/Bool/and/*.dhall + tests/normalization/success/prelude/Bool/and/*.dhall + tests/normalization/success/prelude/Bool/build/*.dhall + tests/normalization/success/prelude/Bool/build/*.dhall + tests/normalization/success/prelude/Bool/even/*.dhall + tests/normalization/success/prelude/Bool/even/*.dhall + tests/normalization/success/prelude/Bool/fold/*.dhall + tests/normalization/success/prelude/Bool/fold/*.dhall + tests/normalization/success/prelude/Bool/not/*.dhall + tests/normalization/success/prelude/Bool/not/*.dhall + tests/normalization/success/prelude/Bool/odd/*.dhall + tests/normalization/success/prelude/Bool/odd/*.dhall + tests/normalization/success/prelude/Bool/or/*.dhall + tests/normalization/success/prelude/Bool/or/*.dhall + tests/normalization/success/prelude/Bool/show/*.dhall + tests/normalization/success/prelude/Bool/show/*.dhall + tests/normalization/success/prelude/Double/show/*.dhall + tests/normalization/success/prelude/Double/show/*.dhall + tests/normalization/success/prelude/Integer/show/*.dhall + tests/normalization/success/prelude/Integer/show/*.dhall + tests/normalization/success/prelude/Integer/toDouble/*.dhall + tests/normalization/success/prelude/Integer/toDouble/*.dhall + tests/normalization/success/prelude/List/all/*.dhall + tests/normalization/success/prelude/List/all/*.dhall + tests/normalization/success/prelude/List/any/*.dhall + tests/normalization/success/prelude/List/any/*.dhall + tests/normalization/success/prelude/List/build/*.dhall + tests/normalization/success/prelude/List/build/*.dhall + tests/normalization/success/prelude/List/concat/*.dhall + tests/normalization/success/prelude/List/concat/*.dhall + tests/normalization/success/prelude/List/concatMap/*.dhall + tests/normalization/success/prelude/List/concatMap/*.dhall + tests/normalization/success/prelude/List/filter/*.dhall + tests/normalization/success/prelude/List/filter/*.dhall + tests/normalization/success/prelude/List/fold/*.dhall + tests/normalization/success/prelude/List/fold/*.dhall + tests/normalization/success/prelude/List/generate/*.dhall + tests/normalization/success/prelude/List/generate/*.dhall + tests/normalization/success/prelude/List/head/*.dhall + tests/normalization/success/prelude/List/head/*.dhall + tests/normalization/success/prelude/List/indexed/*.dhall + tests/normalization/success/prelude/List/indexed/*.dhall + tests/normalization/success/prelude/List/iterate/*.dhall + tests/normalization/success/prelude/List/iterate/*.dhall + tests/normalization/success/prelude/List/last/*.dhall + tests/normalization/success/prelude/List/last/*.dhall + tests/normalization/success/prelude/List/length/*.dhall + tests/normalization/success/prelude/List/length/*.dhall + tests/normalization/success/prelude/List/map/*.dhall + tests/normalization/success/prelude/List/map/*.dhall + tests/normalization/success/prelude/List/null/*.dhall + tests/normalization/success/prelude/List/null/*.dhall + tests/normalization/success/prelude/List/replicate/*.dhall + tests/normalization/success/prelude/List/replicate/*.dhall + tests/normalization/success/prelude/List/reverse/*.dhall + tests/normalization/success/prelude/List/reverse/*.dhall + tests/normalization/success/prelude/List/shifted/*.dhall + tests/normalization/success/prelude/List/shifted/*.dhall + tests/normalization/success/prelude/List/unzip/*.dhall + tests/normalization/success/prelude/List/unzip/*.dhall + tests/normalization/success/prelude/Natural/build/*.dhall + tests/normalization/success/prelude/Natural/build/*.dhall + tests/normalization/success/prelude/Natural/enumerate/*.dhall + tests/normalization/success/prelude/Natural/enumerate/*.dhall + tests/normalization/success/prelude/Natural/even/*.dhall + tests/normalization/success/prelude/Natural/even/*.dhall + tests/normalization/success/prelude/Natural/fold/*.dhall + tests/normalization/success/prelude/Natural/fold/*.dhall + tests/normalization/success/prelude/Natural/isZero/*.dhall + tests/normalization/success/prelude/Natural/isZero/*.dhall + tests/normalization/success/prelude/Natural/odd/*.dhall + tests/normalization/success/prelude/Natural/odd/*.dhall + tests/normalization/success/prelude/Natural/product/*.dhall + tests/normalization/success/prelude/Natural/product/*.dhall + tests/normalization/success/prelude/Natural/show/*.dhall + tests/normalization/success/prelude/Natural/show/*.dhall + tests/normalization/success/prelude/Natural/sum/*.dhall + tests/normalization/success/prelude/Natural/sum/*.dhall + tests/normalization/success/prelude/Natural/toDouble/*.dhall + tests/normalization/success/prelude/Natural/toDouble/*.dhall + tests/normalization/success/prelude/Natural/toInteger/*.dhall + tests/normalization/success/prelude/Natural/toInteger/*.dhall + tests/normalization/success/prelude/Optional/all/*.dhall + tests/normalization/success/prelude/Optional/all/*.dhall + tests/normalization/success/prelude/Optional/any/*.dhall + tests/normalization/success/prelude/Optional/any/*.dhall + tests/normalization/success/prelude/Optional/build/*.dhall + tests/normalization/success/prelude/Optional/build/*.dhall + tests/normalization/success/prelude/Optional/concat/*.dhall + tests/normalization/success/prelude/Optional/concat/*.dhall + tests/normalization/success/prelude/Optional/filter/*.dhall + tests/normalization/success/prelude/Optional/filter/*.dhall + tests/normalization/success/prelude/Optional/fold/*.dhall + tests/normalization/success/prelude/Optional/fold/*.dhall + tests/normalization/success/prelude/Optional/head/*.dhall + tests/normalization/success/prelude/Optional/head/*.dhall + tests/normalization/success/prelude/Optional/last/*.dhall + tests/normalization/success/prelude/Optional/last/*.dhall + tests/normalization/success/prelude/Optional/length/*.dhall + tests/normalization/success/prelude/Optional/length/*.dhall + tests/normalization/success/prelude/Optional/map/*.dhall + tests/normalization/success/prelude/Optional/map/*.dhall + tests/normalization/success/prelude/Optional/null/*.dhall + tests/normalization/success/prelude/Optional/null/*.dhall + tests/normalization/success/prelude/Optional/toList/*.dhall + tests/normalization/success/prelude/Optional/toList/*.dhall + tests/normalization/success/prelude/Optional/unzip/*.dhall + tests/normalization/success/prelude/Optional/unzip/*.dhall + tests/normalization/success/prelude/Text/concat/*.dhall + tests/normalization/success/prelude/Text/concat/*.dhall + tests/normalization/success/prelude/Text/concatMap/*.dhall + tests/normalization/success/prelude/Text/concatMap/*.dhall + tests/normalization/success/prelude/Text/concatMapSep/*.dhall + tests/normalization/success/prelude/Text/concatMapSep/*.dhall + tests/normalization/success/prelude/Text/concatSep/*.dhall + tests/normalization/success/prelude/Text/concatSep/*.dhall + tests/normalization/success/simple/*.dhall + tests/normalization/success/simplifications/*.dhall tests/parser/failure/*.dhall + tests/parser/success/*.dhall tests/regression/*.dhall tests/tutorial/*.dhall - tests/typecheck/*.dhall tests/typecheck/failure/*.dhall - tests/typecheck/examples/Monoid/*.dhall - tests/import/*.dhall - tests/import/data/foo/bar/a.dhall - benchmark/examples/*.dhall - benchmark/deep-nested-large-record/*.dhall + tests/typecheck/success/*.dhall + tests/typecheck/success/prelude/Bool/and/*.dhall + tests/typecheck/success/prelude/Bool/and/*.dhall + tests/typecheck/success/prelude/Bool/build/*.dhall + tests/typecheck/success/prelude/Bool/build/*.dhall + tests/typecheck/success/prelude/Bool/even/*.dhall + tests/typecheck/success/prelude/Bool/even/*.dhall + tests/typecheck/success/prelude/Bool/fold/*.dhall + tests/typecheck/success/prelude/Bool/fold/*.dhall + tests/typecheck/success/prelude/Bool/not/*.dhall + tests/typecheck/success/prelude/Bool/not/*.dhall + tests/typecheck/success/prelude/Bool/odd/*.dhall + tests/typecheck/success/prelude/Bool/odd/*.dhall + tests/typecheck/success/prelude/Bool/or/*.dhall + tests/typecheck/success/prelude/Bool/or/*.dhall + tests/typecheck/success/prelude/Bool/show/*.dhall + tests/typecheck/success/prelude/Bool/show/*.dhall + tests/typecheck/success/prelude/Double/show/*.dhall + tests/typecheck/success/prelude/Double/show/*.dhall + tests/typecheck/success/prelude/Integer/show/*.dhall + tests/typecheck/success/prelude/Integer/show/*.dhall + tests/typecheck/success/prelude/Integer/toDouble/*.dhall + tests/typecheck/success/prelude/Integer/toDouble/*.dhall + tests/typecheck/success/prelude/List/all/*.dhall + tests/typecheck/success/prelude/List/all/*.dhall + tests/typecheck/success/prelude/List/any/*.dhall + tests/typecheck/success/prelude/List/any/*.dhall + tests/typecheck/success/prelude/List/build/*.dhall + tests/typecheck/success/prelude/List/build/*.dhall + tests/typecheck/success/prelude/List/concat/*.dhall + tests/typecheck/success/prelude/List/concat/*.dhall + tests/typecheck/success/prelude/List/concatMap/*.dhall + tests/typecheck/success/prelude/List/concatMap/*.dhall + tests/typecheck/success/prelude/List/filter/*.dhall + tests/typecheck/success/prelude/List/filter/*.dhall + tests/typecheck/success/prelude/List/fold/*.dhall + tests/typecheck/success/prelude/List/fold/*.dhall + tests/typecheck/success/prelude/List/generate/*.dhall + tests/typecheck/success/prelude/List/generate/*.dhall + tests/typecheck/success/prelude/List/head/*.dhall + tests/typecheck/success/prelude/List/head/*.dhall + tests/typecheck/success/prelude/List/indexed/*.dhall + tests/typecheck/success/prelude/List/indexed/*.dhall + tests/typecheck/success/prelude/List/iterate/*.dhall + tests/typecheck/success/prelude/List/iterate/*.dhall + tests/typecheck/success/prelude/List/last/*.dhall + tests/typecheck/success/prelude/List/last/*.dhall + tests/typecheck/success/prelude/List/length/*.dhall + tests/typecheck/success/prelude/List/length/*.dhall + tests/typecheck/success/prelude/List/map/*.dhall + tests/typecheck/success/prelude/List/map/*.dhall + tests/typecheck/success/prelude/List/null/*.dhall + tests/typecheck/success/prelude/List/null/*.dhall + tests/typecheck/success/prelude/List/replicate/*.dhall + tests/typecheck/success/prelude/List/replicate/*.dhall + tests/typecheck/success/prelude/List/reverse/*.dhall + tests/typecheck/success/prelude/List/reverse/*.dhall + tests/typecheck/success/prelude/List/shifted/*.dhall + tests/typecheck/success/prelude/List/shifted/*.dhall + tests/typecheck/success/prelude/List/unzip/*.dhall + tests/typecheck/success/prelude/List/unzip/*.dhall + tests/typecheck/success/prelude/Monoid/*.dhall + tests/typecheck/success/prelude/Natural/build/*.dhall + tests/typecheck/success/prelude/Natural/build/*.dhall + tests/typecheck/success/prelude/Natural/enumerate/*.dhall + tests/typecheck/success/prelude/Natural/enumerate/*.dhall + tests/typecheck/success/prelude/Natural/even/*.dhall + tests/typecheck/success/prelude/Natural/even/*.dhall + tests/typecheck/success/prelude/Natural/fold/*.dhall + tests/typecheck/success/prelude/Natural/fold/*.dhall + tests/typecheck/success/prelude/Natural/isZero/*.dhall + tests/typecheck/success/prelude/Natural/isZero/*.dhall + tests/typecheck/success/prelude/Natural/odd/*.dhall + tests/typecheck/success/prelude/Natural/odd/*.dhall + tests/typecheck/success/prelude/Natural/product/*.dhall + tests/typecheck/success/prelude/Natural/product/*.dhall + tests/typecheck/success/prelude/Natural/show/*.dhall + tests/typecheck/success/prelude/Natural/show/*.dhall + tests/typecheck/success/prelude/Natural/sum/*.dhall + tests/typecheck/success/prelude/Natural/sum/*.dhall + tests/typecheck/success/prelude/Natural/toDouble/*.dhall + tests/typecheck/success/prelude/Natural/toDouble/*.dhall + tests/typecheck/success/prelude/Natural/toInteger/*.dhall + tests/typecheck/success/prelude/Natural/toInteger/*.dhall + tests/typecheck/success/prelude/Optional/all/*.dhall + tests/typecheck/success/prelude/Optional/all/*.dhall + tests/typecheck/success/prelude/Optional/any/*.dhall + tests/typecheck/success/prelude/Optional/any/*.dhall + tests/typecheck/success/prelude/Optional/build/*.dhall + tests/typecheck/success/prelude/Optional/build/*.dhall + tests/typecheck/success/prelude/Optional/concat/*.dhall + tests/typecheck/success/prelude/Optional/concat/*.dhall + tests/typecheck/success/prelude/Optional/filter/*.dhall + tests/typecheck/success/prelude/Optional/filter/*.dhall + tests/typecheck/success/prelude/Optional/fold/*.dhall + tests/typecheck/success/prelude/Optional/fold/*.dhall + tests/typecheck/success/prelude/Optional/head/*.dhall + tests/typecheck/success/prelude/Optional/head/*.dhall + tests/typecheck/success/prelude/Optional/last/*.dhall + tests/typecheck/success/prelude/Optional/last/*.dhall + tests/typecheck/success/prelude/Optional/length/*.dhall + tests/typecheck/success/prelude/Optional/length/*.dhall + tests/typecheck/success/prelude/Optional/map/*.dhall + tests/typecheck/success/prelude/Optional/map/*.dhall + tests/typecheck/success/prelude/Optional/null/*.dhall + tests/typecheck/success/prelude/Optional/null/*.dhall + tests/typecheck/success/prelude/Optional/toList/*.dhall + tests/typecheck/success/prelude/Optional/toList/*.dhall + tests/typecheck/success/prelude/Optional/unzip/*.dhall + tests/typecheck/success/prelude/Optional/unzip/*.dhall + tests/typecheck/success/prelude/Text/concat/*.dhall + tests/typecheck/success/prelude/Text/concat/*.dhall + tests/typecheck/success/prelude/Text/concatMap/*.dhall + tests/typecheck/success/prelude/Text/concatMap/*.dhall + tests/typecheck/success/prelude/Text/concatMapSep/*.dhall + tests/typecheck/success/prelude/Text/concatMapSep/*.dhall + tests/typecheck/success/prelude/Text/concatSep/*.dhall + tests/typecheck/success/prelude/Text/concatSep/*.dhall + tests/typecheck/success/simple/access/*.dhall + tests/typecheck/success/simple/*.dhall Source-Repository head Type: git - Location: https://github.com/dhall-lang/dhall-haskell + Location: https://github.com/dhall-lang/dhall-haskell/tree/master/dhall Flag with-http Description: Include support for importing dhall modules from HTTP URLs @@ -130,7 +311,7 @@ megaparsec >= 7.0.0 && < 7.1 , memory >= 0.14 && < 0.15, mtl >= 2.2.1 && < 2.3 , - optparse-applicative < 0.15, + optparse-applicative >= 0.14.0.0 && < 0.15, parsers >= 0.12.4 && < 0.13, prettyprinter >= 1.2.0.1 && < 1.3 , prettyprinter-ansi-terminal >= 1.1.1 && < 1.2 , @@ -141,6 +322,7 @@ text >= 0.11.1.0 && < 1.3 , transformers >= 0.2.0.0 && < 0.6 , unordered-containers >= 0.1.3.0 && < 0.3 , + uri-encode < 1.6 , vector >= 0.11.0.0 && < 0.13 if flag(with-http) Build-Depends: @@ -164,6 +346,7 @@ Dhall.Lint, Dhall.Main, Dhall.Map, + Dhall.Set, Dhall.Parser, Dhall.Pretty, Dhall.Repl, diff --git a/src/Dhall.hs b/src/Dhall.hs --- a/src/Dhall.hs +++ b/src/Dhall.hs @@ -211,7 +211,7 @@ defaultEvaluateSettings :: EvaluateSettings defaultEvaluateSettings = EvaluateSettings { _startingContext = Dhall.Context.empty - , _normalizer = Dhall.Core.ReifiedNormalizer (const Nothing) + , _normalizer = Dhall.Core.ReifiedNormalizer (const (pure Nothing)) , _standardVersion = Dhall.Binary.defaultStandardVersion } @@ -616,16 +616,11 @@ {-| Decode a `Scientific` ->>> input scientific "1e1000000000" -1.0e1000000000 +>>> input scientific "1e100" +1.0e100 -} scientific :: Type Scientific -scientific = Type {..} - where - extract (DoubleLit n) = pure n - extract _ = empty - - expected = Double +scientific = fmap Data.Scientific.fromFloatDigits double {-| Decode a `Double` @@ -633,8 +628,13 @@ 42.0 -} double :: Type Double -double = fmap Data.Scientific.toRealFloat scientific +double = Type {..} + where + extract (DoubleLit n) = pure n + extract _ = empty + expected = Double + {-| Decode lazy `Text` >>> input lazyText "\"Test\"" @@ -1103,16 +1103,12 @@ declared = Integer -instance Inject Scientific where +instance Inject Double where injectWith _ = InputType {..} where embed = DoubleLit declared = Double - -instance Inject Double where - injectWith = - fmap (contramap (Data.Scientific.fromFloatDigits :: Double -> Scientific)) injectWith instance Inject () where injectWith _ = InputType {..} diff --git a/src/Dhall/Binary.hs b/src/Dhall/Binary.hs --- a/src/Dhall/Binary.hs +++ b/src/Dhall/Binary.hs @@ -24,7 +24,8 @@ import Control.Applicative (empty) import Control.Exception (Exception) import Dhall.Core - ( Chunks(..) + ( Binding(..) + , Chunks(..) , Const(..) , Directory(..) , Expr(..) @@ -38,26 +39,28 @@ , URL(..) , Var(..) ) +import Data.Foldable (toList) +import Data.List.NonEmpty (NonEmpty(..)) import Data.Monoid ((<>)) import Data.Text (Text) import Options.Applicative (Parser) import Prelude hiding (exponent) +import GHC.Float (double2Float, float2Double) +import Codec.CBOR.Magic (floatToWord16, wordToFloat16) -import qualified Data.Foldable -import qualified Data.Scientific import qualified Data.Sequence -import qualified Data.Set import qualified Data.Text import qualified Dhall.Map +import qualified Dhall.Set import qualified Options.Applicative -- | Supported version strings data StandardVersion - = V_3_0_0 - -- ^ Version "3.0.0" + = V_4_0_0 + -- ^ Version "4.0.0" defaultStandardVersion :: StandardVersion -defaultStandardVersion = V_3_0_0 +defaultStandardVersion = V_4_0_0 parseStandardVersion :: Parser StandardVersion parseStandardVersion = @@ -71,7 +74,7 @@ readVersion = do string <- Options.Applicative.str case string :: Text of - "3.0.0" -> return V_3_0_0 + "4.0.0" -> return V_4_0_0 _ -> fail "Unsupported version" {-| Convert a function applied to multiple arguments to the base function and @@ -297,7 +300,7 @@ TList ([ TInt 10, t₁ ] ++ xs₁) where t₁ = encode t₀ - xs₁ = map TString (Data.Foldable.toList xs₀) + xs₁ = map TString (Dhall.Set.toList xs₀) encode (Union xTs₀) = TList [ TInt 11, TMap xTs₁ ] where @@ -332,14 +335,17 @@ TList [ TInt 15, TInteger (fromIntegral n) ] encode (IntegerLit n) = TList [ TInt 16, TInteger n ] -encode (DoubleLit n) = - TList [ TInt 17, TTagged 4 (TList [ TInt exponent, TInteger mantissa ]) ] +encode (DoubleLit n64) + -- cborg always encodes NaN as "7e00" + | isNaN n64 = THalf n32 + | useHalf = THalf n32 + | useFloat = TFloat n32 + | otherwise = TDouble n64 where - normalized = Data.Scientific.normalize n - - exponent = Data.Scientific.base10Exponent normalized - - mantissa = Data.Scientific.coefficient normalized + n32 = double2Float n64 + n16 = floatToWord16 n32 + useFloat = n64 == float2Double n32 + useHalf = n64 == (float2Double . wordToFloat16 . fromIntegral) n16 encode (TextLit (Chunks xys₀ z₀)) = TList ([ TInt 18 ] ++ xys₁ ++ [ z₁ ]) where @@ -352,17 +358,21 @@ z₁ = TString z₀ encode (Embed x) = importToTerm x -encode (Let x Nothing a₀ b₀) = - TList [ TInt 25, TString x, a₁, b₁ ] +encode (Let as₀ b₀) = + TList ([ TInt 25 ] ++ as₁ ++ [ b₁ ]) where - a₁ = encode a₀ + as₁ = do + Binding x mA₀ a₀ <- toList as₀ + + let mA₁ = case mA₀ of + Nothing -> TNull + Just _A₀ -> encode _A₀ + + let a₁ = encode a₀ + + [ TString x, mA₁, a₁ ] + b₁ = encode b₀ -encode (Let x (Just _A₀) a₀ b₀) = - TList [ TInt 25, TString x, _A₁, a₁, b₁ ] - where - a₁ = encode a₀ - _A₁ = encode _A₀ - b₁ = encode b₀ encode (Annot t₀ _T₀) = TList [ TInt 26, t₁, _T₁ ] where @@ -585,7 +595,7 @@ xs₀ <- traverse process xs₁ - return (Project t₀ (Data.Set.fromList xs₀)) + return (Project t₀ (Dhall.Set.fromList xs₀)) decode (TList [ TInt 11, TMap xTs₁ ]) = do let process (TString x, _T₁) = do _T₀ <- decode _T₁ @@ -630,10 +640,12 @@ return (IntegerLit (fromIntegral n)) decode (TList [ TInt 16, TInteger n ]) = do return (IntegerLit n) -decode (TList [ TInt 17, TTagged 4 (TList [ TInt exponent, TInteger mantissa ]) ]) = do - return (DoubleLit (Data.Scientific.scientific mantissa exponent)) -decode (TList [ TInt 17, TTagged 4 (TList [ TInt exponent, TInt mantissa ]) ]) = do - return (DoubleLit (Data.Scientific.scientific (fromIntegral mantissa) exponent)) +decode (THalf n) = do + return (DoubleLit (float2Double n)) +decode (TFloat n) = do + return (DoubleLit (float2Double n)) +decode (TDouble n) = do + return (DoubleLit n) decode (TList (TInt 18 : xs)) = do let process (TString x : y₁ : zs) = do y₀ <- decode y₁ @@ -722,15 +734,29 @@ let importHashed = ImportHashed {..} let importMode = Code return (Embed (Import {..})) -decode (TList [ TInt 25, TString x, a₁, b₁ ]) = do - a₀ <- decode a₁ - b₀ <- decode b₁ - return (Let x Nothing a₀ b₀) -decode (TList [ TInt 25, TString x, _A₁, a₁, b₁ ]) = do - _A₀ <- decode _A₁ - a₀ <- decode a₁ - b₀ <- decode b₁ - return (Let x (Just _A₀) a₀ b₀) +decode (TList (TInt 25 : xs)) = do + let process (TString x : _A₁ : a₁ : ls₁) = do + mA₀ <- case _A₁ of + TNull -> return Nothing + _ -> fmap Just (decode _A₁) + + a₀ <- decode a₁ + + let binding = Binding x mA₀ a₀ + + case ls₁ of + [ b₁ ] -> do + b₀ <- decode b₁ + + return (Let (binding :| []) b₀) + _ -> do + Let (l₀ :| ls₀) b₀ <- process ls₁ + + return (Let (binding :| (l₀ : ls₀)) b₀) + process _ = do + empty + + process xs decode (TList [ TInt 26, t₁, _T₁ ]) = do t₀ <- decode t₁ _T₀ <- decode _T₁ @@ -752,7 +778,7 @@ fail ("Cannot decode the version from this decoded CBOR expression: " <> show term) case version of - "3.0.0" -> do + "4.0.0" -> do return () _ -> do fail ("This decoded version is not supported: " <> Data.Text.unpack version) @@ -765,8 +791,8 @@ -- | Encode a Dhall expression using the specified `Version` encodeWithVersion :: StandardVersion -> Expr s Import -> Term -encodeWithVersion V_3_0_0 expression = - TList [ TString "3.0.0", encode expression ] +encodeWithVersion V_4_0_0 expression = + TList [ TString "4.0.0", encode expression ] data DecodingFailure = CannotDecodeVersionString Term diff --git a/src/Dhall/Core.hs b/src/Dhall/Core.hs --- a/src/Dhall/Core.hs +++ b/src/Dhall/Core.hs @@ -29,6 +29,7 @@ , Path , Scheme(..) , Var(..) + , Binding(..) , Chunks(..) , Expr(..) @@ -36,7 +37,9 @@ , alphaNormalize , normalize , normalizeWith + , normalizeWithM , Normalizer + , NormalizerM , ReifiedNormalizer (..) , judgmentallyEqual , subst @@ -53,6 +56,8 @@ , internalError , reservedIdentifiers , escapeText + , subExpressions + , pathCharacter ) where #if MIN_VERSION_base(4,8,0) @@ -64,16 +69,17 @@ import Data.Bifunctor (Bifunctor(..)) import Data.Data (Data) import Data.Foldable +import Data.Functor.Identity (Identity(..)) import Data.HashSet (HashSet) +import Data.List.NonEmpty (NonEmpty(..)) import Data.String (IsString(..)) -import Data.Scientific (Scientific) import Data.Semigroup (Semigroup(..)) import Data.Sequence (Seq, ViewL(..), ViewR(..)) -import Data.Set (Set) import Data.Text (Text) -import Data.Text.Prettyprint.Doc (Pretty) +import Data.Text.Prettyprint.Doc (Doc, Pretty) import Data.Traversable import Dhall.Map (Map) +import Dhall.Set (Set) import {-# SOURCE #-} Dhall.Pretty.Internal import GHC.Generics (Generic) import Numeric.Natural (Natural) @@ -83,10 +89,10 @@ import qualified Crypto.Hash import qualified Data.HashSet import qualified Data.Sequence -import qualified Data.Set import qualified Data.Text import qualified Data.Text.Prettyprint.Doc as Pretty import qualified Dhall.Map +import qualified Dhall.Set {-| Constants for a pure type system @@ -98,13 +104,11 @@ ... and the valid rule pairs are: > ⊦ Type ↝ Type : Type -- Functions from terms to terms (ordinary functions) -> ⊦ Kind ↝ Type : Type -- Functions from types to terms (polymorphic functions) -> ⊦ Kind ↝ Kind : Kind -- Functions from types to types (type constructors) -> ⊦ Sort ↝ Type : Type -- Functions from kinds to terms (kind-polymorphic functions) -> ⊦ Sort ↝ Kind : Kind -- Functions from kinds to types (polymorphic type constructors) -> ⊦ Sort ↝ Sort : Sort -- Functions from kinds to kinds (kind constructors) - - These are the same rule pairs as System Fω +> ⊦ Kind ↝ Type : Type -- Functions from types to terms (type-polymorphic functions) +> ⊦ Sort ↝ Type : Type -- Functions from kinds to terms +> ⊦ Kind ↝ Kind : Kind -- Functions from types to types (type-level functions) +> ⊦ Sort ↝ Kind : Sort -- Functions from kinds to types (kind-polymorphic functions) +> ⊦ Sort ↝ Sort : Sort -- Functions from kinds to kinds (kind-level functions) Note that Dhall does not support functions from terms to types and therefore Dhall is not a dependently typed language @@ -128,10 +132,7 @@ Directory (components₁ <> components₀) instance Pretty Directory where - pretty (Directory {..}) = - foldMap prettyComponent (reverse components) - where - prettyComponent text = "/" <> Pretty.pretty text + pretty (Directory {..}) = foldMap prettyPathComponent (reverse components) {-| A `File` is a `directory` followed by one additional path component representing the `file` name @@ -142,7 +143,9 @@ } deriving (Eq, Generic, Ord, Show) instance Pretty File where - pretty (File {..}) = Pretty.pretty directory <> "/" <> Pretty.pretty file + pretty (File {..}) = + Pretty.pretty directory + <> prettyPathComponent file instance Semigroup File where File directory₀ _ <> File directory₁ file = @@ -329,9 +332,9 @@ | Pi Text (Expr s a) (Expr s a) -- | > App f a ~ f a | App (Expr s a) (Expr s a) - -- | > Let x Nothing r e ~ let x = r in e - -- > Let x (Just t) r e ~ let x : t = r in e - | Let Text (Maybe (Expr s a)) (Expr s a) (Expr s a) + -- | > Let [Binding x Nothing r] e ~ let x = r in e + -- > Let [Binding x (Just t) r] e ~ let x : t = r in e + | Let (NonEmpty (Binding s a)) (Expr s a) -- | > Annot x t ~ x : t | Annot (Expr s a) (Expr s a) -- | > Bool ~ Bool @@ -381,7 +384,7 @@ -- | > Double ~ Double | Double -- | > DoubleLit n ~ n - | DoubleLit Scientific + | DoubleLit Double -- | > DoubleShow ~ Double/show | DoubleShow -- | > Text ~ Text @@ -436,7 +439,7 @@ | Combine (Expr s a) (Expr s a) -- | > CombineTypes x y ~ x ⩓ y | CombineTypes (Expr s a) (Expr s a) - -- | > CombineRight x y ~ x ⫽ y + -- | > Prefer x y ~ x ⫽ y | Prefer (Expr s a) (Expr s a) -- | > Merge x y (Just t ) ~ merge x y : t -- > Merge x y Nothing ~ merge x y @@ -465,7 +468,7 @@ fmap f (Lam v e1 e2) = Lam v (fmap f e1) (fmap f e2) fmap f (Pi v e1 e2) = Pi v (fmap f e1) (fmap f e2) fmap f (App e1 e2) = App (fmap f e1) (fmap f e2) - fmap f (Let v maybeE e1 e2) = Let v (fmap (fmap f) maybeE) (fmap f e1) (fmap f e2) + fmap f (Let as b) = Let (fmap (fmap f) as) (fmap f b) fmap f (Annot e1 e2) = Annot (fmap f e1) (fmap f e2) fmap _ Bool = Bool fmap _ (BoolLit b) = BoolLit b @@ -540,7 +543,9 @@ Lam a b c >>= k = Lam a (b >>= k) (c >>= k) Pi a b c >>= k = Pi a (b >>= k) (c >>= k) App a b >>= k = App (a >>= k) (b >>= k) - Let a b c d >>= k = Let a (fmap (>>= k) b) (c >>= k) (d >>= k) + Let as b >>= k = Let (fmap f as) (b >>= k) + where + f (Binding c d e) = Binding c (fmap (>>= k) d) (e >>= k) Annot a b >>= k = Annot (a >>= k) (b >>= k) Bool >>= _ = Bool BoolLit a >>= _ = BoolLit a @@ -607,7 +612,7 @@ first k (Lam a b c ) = Lam a (first k b) (first k c) first k (Pi a b c ) = Pi a (first k b) (first k c) first k (App a b ) = App (first k a) (first k b) - first k (Let a b c d ) = Let a (fmap (first k) b) (first k c) (first k d) + first k (Let as b ) = Let (fmap (first k) as) (first k b) first k (Annot a b ) = Annot (first k a) (first k b) first _ Bool = Bool first _ (BoolLit a ) = BoolLit a @@ -673,6 +678,17 @@ instance IsString (Expr s a) where fromString str = Var (fromString str) +data Binding s a = Binding + { variable :: Text + , annotation :: Maybe (Expr s a) + , value :: Expr s a + } deriving (Functor, Foldable, Generic, Traversable, Show, Eq, Data) + +instance Bifunctor Binding where + first k (Binding a b c) = Binding a (fmap (first k) b) (first k c) + + second = fmap + -- | The body of an interpolated @Text@ literal data Chunks s a = Chunks [(Text, Expr s a)] Text deriving (Functor, Foldable, Generic, Traversable, Show, Eq, Data) @@ -790,14 +806,24 @@ where f' = shift d v f a' = shift d v a -shift d (V x n) (Let f mt r e) = Let f mt' r' e' +shift d (V x₀ n₀) (Let (Binding x₁ mA₀ a₀ :| []) b₀) = + Let (Binding x₁ mA₁ a₁ :| []) b₁ where - e' = shift d (V x n') e - where - n' = if x == f then n + 1 else n + n₁ = if x₀ == x₁ then n₀ + 1 else n₀ - mt' = fmap (shift d (V x n)) mt - r' = shift d (V x n) r + mA₁ = fmap (shift d (V x₀ n₀)) mA₀ + a₁ = shift d (V x₀ n₀) a₀ + + b₁ = shift d (V x₀ n₁) b₀ +shift d (V x₀ n₀) (Let (Binding x₁ mA₀ a₀ :| (l₀ : ls₀)) b₀) = + Let (Binding x₁ mA₁ a₁ :| (l₁ : ls₁)) b₁ + where + n₁ = if x₀ == x₁ then n₀ + 1 else n₀ + + mA₁ = fmap (shift d (V x₀ n₀)) mA₀ + a₁ = shift d (V x₀ n₀) a₀ + + Let (l₁ :| ls₁) b₁ = shift d (V x₀ n₁) (Let (l₀ :| ls₀) b₀) shift d v (Annot a b) = Annot a' b' where a' = shift d v a @@ -955,14 +981,28 @@ f' = subst v e f a' = subst v e a subst v e (Var v') = if v == v' then e else Var v' -subst (V x n) e (Let f mt r b) = Let f mt' r' b' +subst (V x₀ n₀) e₀ (Let (Binding x₁ mA₀ a₀ :| []) b₀) = + Let (Binding x₁ mA₁ a₁ :| []) b₁ where - b' = subst (V x n') (shift 1 (V f 0) e) b - where - n' = if x == f then n + 1 else n + n₁ = if x₀ == x₁ then n₀ + 1 else n₀ - mt' = fmap (subst (V x n) e) mt - r' = subst (V x n) e r + e₁ = shift 1 (V x₁ 0) e₀ + + mA₁ = fmap (subst (V x₀ n₀) e₀) mA₀ + a₁ = subst (V x₀ n₀) e₀ a₀ + + b₁ = subst (V x₀ n₁) e₁ b₀ +subst (V x₀ n₀) e₀ (Let (Binding x₁ mA₀ a₀ :| (l₀ : ls₀)) b₀) = + Let (Binding x₁ mA₁ a₁ :| (l₁ : ls₁)) b₁ + where + n₁ = if x₀ == x₁ then n₀ + 1 else n₀ + + e₁ = shift 1 (V x₁ 0) e₀ + + mA₁ = fmap (subst (V x₀ n₀) e₀) mA₀ + a₁ = subst (V x₀ n₀) e₀ a₀ + + Let (l₁ :| ls₁) b₁ = subst (V x₀ n₁) e₁ (Let (l₀ :| ls₀) b₀) subst x e (Annot a b) = Annot a' b' where a' = subst x e a @@ -1141,22 +1181,41 @@ f₁ = alphaNormalize f₀ a₁ = alphaNormalize a₀ -alphaNormalize (Let "_" mA₀ a₀ b₀) = - Let "_" mA₁ a₁ b₁ +alphaNormalize (Let (Binding "_" mA₀ a₀ :| []) b₀) = + Let (Binding "_" mA₁ a₁ :| []) b₁ where mA₁ = fmap alphaNormalize mA₀ a₁ = alphaNormalize a₀ + b₁ = alphaNormalize b₀ -alphaNormalize (Let x mA₀ a₀ b₀) = - Let "_" mA₁ a₁ b₄ +alphaNormalize (Let (Binding "_" mA₀ a₀ :| (l₀ : ls₀)) b₀) = + Let (Binding "_" mA₁ a₁ :| (l₁ : ls₁)) b₁ where mA₁ = fmap alphaNormalize mA₀ + a₁ = alphaNormalize a₀ + + Let (l₁ :| ls₁) b₁ = alphaNormalize (Let (l₀ :| ls₀) b₀) +alphaNormalize (Let (Binding x mA₀ a₀ :| []) b₀) = + Let (Binding "_" mA₁ a₁ :| []) b₄ + where + mA₁ = fmap alphaNormalize mA₀ a₁ = alphaNormalize a₀ b₁ = shift 1 (V "_" 0) b₀ b₂ = subst (V x 0) (Var (V "_" 0)) b₁ b₃ = shift (-1) (V x 0) b₂ b₄ = alphaNormalize b₃ +alphaNormalize (Let (Binding x mA₀ a₀ :| (l₀ : ls₀)) b₀) = + Let (Binding "_" mA₁ a₁ :| (l₁ : ls₁)) b₄ + where + mA₁ = fmap alphaNormalize mA₀ + a₁ = alphaNormalize a₀ + + b₁ = shift 1 (V "_" 0) b₀ + b₂ = subst (V x 0) (Var (V "_" 0)) b₁ + b₃ = shift (-1) (V x 0) b₂ + + Let (l₁ :| ls₁) b₄ = alphaNormalize (Let (l₀ :| ls₀) b₃) alphaNormalize (Annot t₀ _T₀) = Annot t₁ _T₁ where @@ -1384,7 +1443,7 @@ leave ill-typed sub-expressions unevaluated. -} normalize :: Eq a => Expr s a -> Expr t a -normalize = normalizeWith (const Nothing) +normalize = normalizeWith (const (pure Nothing)) {-| This function is used to determine whether folds like @Natural/fold@ or @List/fold@ should be lazy or strict in their accumulator based on the type @@ -1416,7 +1475,9 @@ denote (Lam a b c ) = Lam a (denote b) (denote c) denote (Pi a b c ) = Pi a (denote b) (denote c) denote (App a b ) = App (denote a) (denote b) -denote (Let a b c d ) = Let a (fmap denote b) (denote c) (denote d) +denote (Let as b ) = Let (fmap f as) (denote b) + where + f (Binding c d e) = Binding c (fmap denote d) (denote e) denote (Annot a b ) = Annot (denote a) (denote b) denote Bool = Bool denote (BoolLit a ) = BoolLit a @@ -1492,149 +1553,168 @@ -} normalizeWith :: Eq a => Normalizer a -> Expr s a -> Expr t a -normalizeWith ctx e0 = loop (denote e0) +normalizeWith ctx = runIdentity . normalizeWithM ctx + +normalizeWithM :: (Eq a, Monad m) => NormalizerM m a -> Expr s a -> m (Expr t a) +normalizeWithM ctx e0 = loop (denote e0) where loop e = case e of - Const k -> Const k - Var v -> Var v - Lam x _A b -> Lam x _A' b' + Const k -> pure (Const k) + Var v -> pure (Var v) + Lam x _A b -> Lam x <$> _A' <*> b' where _A' = loop _A b' = loop b - Pi x _A _B -> Pi x _A' _B' + Pi x _A _B -> Pi x <$> _A' <*> _B' where _A' = loop _A _B' = loop _B - App f a -> case loop f of - Lam x _A b -> loop b'' -- Beta reduce - where - a' = shift 1 (V x 0) a - b' = subst (V x 0) a' b - b'' = shift (-1) (V x 0) b' - f' -> case App f' a' of - -- build/fold fusion for `List` - App (App ListBuild _) (App (App ListFold _) e') -> loop e' + App f a -> do + res <- ctx (App f a) + case res of + Just e1 -> loop e1 + Nothing -> do + f' <- loop f + case f' of + Lam x _A b -> loop b'' + where + a' = shift 1 (V x 0) a + b' = subst (V x 0) a' b + b'' = shift (-1) (V x 0) b' + _ -> do + a' <- loop a + case App f' a' of + -- build/fold fusion for `List` + App (App ListBuild _) (App (App ListFold _) e') -> loop e' - -- build/fold fusion for `Natural` - App NaturalBuild (App NaturalFold e') -> loop e' + -- build/fold fusion for `Natural` + App NaturalBuild (App NaturalFold e') -> loop e' - -- build/fold fusion for `Optional` - App (App OptionalBuild _) (App (App OptionalFold _) e') -> loop e' + -- build/fold fusion for `Optional` + App (App OptionalBuild _) (App (App OptionalFold _) e') -> loop e' - App (App (App (App NaturalFold (NaturalLit n0)) t) succ') zero -> - if boundedType (loop t) then strict else lazy - where - strict = strictLoop n0 - lazy = loop ( lazyLoop n0) + App (App (App (App NaturalFold (NaturalLit n0)) t) succ') zero -> do + t' <- loop t + if boundedType t' then strict else lazy + where + strict = strictLoop n0 + lazy = loop ( lazyLoop n0) - strictLoop !0 = loop zero - strictLoop !n = loop (App succ' (strictLoop (n - 1))) + strictLoop !0 = loop zero + strictLoop !n = App succ' <$> strictLoop (n - 1) >>= loop - lazyLoop !0 = zero - lazyLoop !n = App succ' (lazyLoop (n - 1)) - App NaturalBuild g -> loop (App (App (App g Natural) succ) zero) - where - succ = Lam "x" Natural (NaturalPlus "x" (NaturalLit 1)) + lazyLoop !0 = zero + lazyLoop !n = App succ' (lazyLoop (n - 1)) + App NaturalBuild g -> loop (App (App (App g Natural) succ) zero) + where + succ = Lam "x" Natural (NaturalPlus "x" (NaturalLit 1)) - zero = NaturalLit 0 - App NaturalIsZero (NaturalLit n) -> BoolLit (n == 0) - App NaturalEven (NaturalLit n) -> BoolLit (even n) - App NaturalOdd (NaturalLit n) -> BoolLit (odd n) - App NaturalToInteger (NaturalLit n) -> IntegerLit (toInteger n) - App NaturalShow (NaturalLit n) -> - TextLit (Chunks [] (Data.Text.pack (show n))) - App IntegerShow (IntegerLit n) - | 0 <= n -> TextLit (Chunks [] ("+" <> Data.Text.pack (show n))) - | otherwise -> TextLit (Chunks [] (Data.Text.pack (show n))) - App IntegerToDouble (IntegerLit n) -> DoubleLit (fromInteger n) - App DoubleShow (DoubleLit n) -> - TextLit (Chunks [] (Data.Text.pack (show n))) - App (App OptionalBuild _A₀) g -> - loop (App (App (App g optional) just) nothing) - where - optional = App Optional _A₀ + zero = NaturalLit 0 + App NaturalIsZero (NaturalLit n) -> pure (BoolLit (n == 0)) + App NaturalEven (NaturalLit n) -> pure (BoolLit (even n)) + App NaturalOdd (NaturalLit n) -> pure (BoolLit (odd n)) + App NaturalToInteger (NaturalLit n) -> pure (IntegerLit (toInteger n)) + App NaturalShow (NaturalLit n) -> + pure (TextLit (Chunks [] (Data.Text.pack (show n)))) + App IntegerShow (IntegerLit n) + | 0 <= n -> pure (TextLit (Chunks [] ("+" <> Data.Text.pack (show n)))) + | otherwise -> pure (TextLit (Chunks [] (Data.Text.pack (show n)))) + -- `(read . show)` is used instead of `fromInteger` because `read` uses the correct rounding rule + App IntegerToDouble (IntegerLit n) -> pure (DoubleLit ((read . show) n)) + App DoubleShow (DoubleLit n) -> + pure (TextLit (Chunks [] (Data.Text.pack (show n)))) + App (App OptionalBuild _A₀) g -> + loop (App (App (App g optional) just) nothing) + where + optional = App Optional _A₀ - just = Lam "a" _A₀ (Some "a") + just = Lam "a" _A₀ (Some "a") - nothing = App None _A₀ - App (App ListBuild _A₀) g -> loop (App (App (App g list) cons) nil) - where - _A₁ = shift 1 "a" _A₀ + nothing = App None _A₀ + App (App ListBuild _A₀) g -> loop (App (App (App g list) cons) nil) + where + _A₁ = shift 1 "a" _A₀ - list = App List _A₀ + list = App List _A₀ - cons = - Lam "a" _A₀ - (Lam "as" - (App List _A₁) - (ListAppend (ListLit Nothing (pure "a")) "as") - ) + cons = + Lam "a" _A₀ + (Lam "as" + (App List _A₁) + (ListAppend (ListLit Nothing (pure "a")) "as") + ) - nil = ListLit (Just _A₀) empty - App (App (App (App (App ListFold _) (ListLit _ xs)) t) cons) nil -> - if boundedType (loop t) then strict else lazy - where - strict = foldr strictCons strictNil xs - lazy = loop (foldr lazyCons lazyNil xs) + nil = ListLit (Just _A₀) empty + App (App (App (App (App ListFold _) (ListLit _ xs)) t) cons) nil -> do + t' <- loop t + if boundedType t' then strict else lazy + where + strict = foldr strictCons strictNil xs + lazy = loop (foldr lazyCons lazyNil xs) - strictNil = loop nil - lazyNil = nil + strictNil = loop nil + lazyNil = nil - strictCons y ys = loop (App (App cons y) ys) - lazyCons y ys = App (App cons y) ys - App (App ListLength _) (ListLit _ ys) -> - NaturalLit (fromIntegral (Data.Sequence.length ys)) - App (App ListHead t) (ListLit _ ys) -> loop o - where - o = case Data.Sequence.viewl ys of - y :< _ -> Some y - _ -> App None t - App (App ListLast t) (ListLit _ ys) -> loop o - where - o = case Data.Sequence.viewr ys of - _ :> y -> Some y - _ -> App None t - App (App ListIndexed _A₀) (ListLit _A₁ as₀) -> loop (ListLit t as₁) - where - as₁ = Data.Sequence.mapWithIndex adapt as₀ + strictCons y ys = do + App (App cons y) <$> ys >>= loop + lazyCons y ys = App (App cons y) ys + App (App ListLength _) (ListLit _ ys) -> + pure (NaturalLit (fromIntegral (Data.Sequence.length ys))) + App (App ListHead t) (ListLit _ ys) -> loop o + where + o = case Data.Sequence.viewl ys of + y :< _ -> Some y + _ -> App None t + App (App ListLast t) (ListLit _ ys) -> loop o + where + o = case Data.Sequence.viewr ys of + _ :> y -> Some y + _ -> App None t + App (App ListIndexed _A₀) (ListLit _A₁ as₀) -> loop (ListLit t as₁) + where + as₁ = Data.Sequence.mapWithIndex adapt as₀ - _A₂ = Record (Dhall.Map.fromList kts) - where - kts = [ ("index", Natural) - , ("value", _A₀) - ] + _A₂ = Record (Dhall.Map.fromList kts) + where + kts = [ ("index", Natural) + , ("value", _A₀) + ] - t | null as₀ = Just _A₂ - | otherwise = Nothing + t | null as₀ = Just _A₂ + | otherwise = Nothing - adapt n a_ = - RecordLit (Dhall.Map.fromList kvs) - where - kvs = [ ("index", NaturalLit (fromIntegral n)) - , ("value", a_) - ] - App (App ListReverse t) (ListLit _ xs) -> - loop (ListLit m (Data.Sequence.reverse xs)) - where - m = if Data.Sequence.null xs then Just t else Nothing - App (App (App (App (App OptionalFold _) (App None _)) _) _) nothing -> - loop nothing - App (App (App (App (App OptionalFold _) (Some x)) _) just) _ -> - loop (App just x) - _ -> case ctx (App f' a') of - Nothing -> App f' a' - Just app' -> loop app' - where - a' = loop a - Let f _ r b -> loop b'' + adapt n a_ = + RecordLit (Dhall.Map.fromList kvs) + where + kvs = [ ("index", NaturalLit (fromIntegral n)) + , ("value", a_) + ] + App (App ListReverse t) (ListLit _ xs) -> + loop (ListLit m (Data.Sequence.reverse xs)) + where + m = if Data.Sequence.null xs then Just t else Nothing + App (App (App (App (App OptionalFold _) (App None _)) _) _) nothing -> + loop nothing + App (App (App (App (App OptionalFold _) (Some x)) _) just) _ -> + loop (App just x) + _ -> do + res2 <- ctx (App f' a') + case res2 of + Nothing -> pure (App f' a') + Just app' -> loop app' + Let (Binding x _ a₀ :| ls₀) b₀ -> loop b₂ where - r' = shift 1 (V f 0) r - b' = subst (V f 0) r' b - b'' = shift (-1) (V f 0) b' + rest = case ls₀ of + [] -> b₀ + l₁ : ls₁ -> Let (l₁ :| ls₁) b₀ + + a₁ = shift 1 (V x 0) a₀ + b₁ = subst (V x 0) a₁ rest + b₂ = shift (-1) (V x 0) b₁ Annot x _ -> loop x - Bool -> Bool - BoolLit b -> BoolLit b - BoolAnd x y -> decide (loop x) (loop y) + Bool -> pure Bool + BoolLit b -> pure (BoolLit b) + BoolAnd x y -> decide <$> loop x <*> loop y where decide (BoolLit True ) r = r decide (BoolLit False) _ = BoolLit False @@ -1643,7 +1723,7 @@ decide l r | judgmentallyEqual l r = l | otherwise = BoolAnd l r - BoolOr x y -> decide (loop x) (loop y) + BoolOr x y -> decide <$> loop x <*> loop y where decide (BoolLit False) r = r decide (BoolLit True ) _ = BoolLit True @@ -1652,21 +1732,21 @@ decide l r | judgmentallyEqual l r = l | otherwise = BoolOr l r - BoolEQ x y -> decide (loop x) (loop y) + BoolEQ x y -> decide <$> loop x <*> loop y where decide (BoolLit True ) r = r decide l (BoolLit True ) = l decide l r | judgmentallyEqual l r = BoolLit True | otherwise = BoolEQ l r - BoolNE x y -> decide (loop x) (loop y) + BoolNE x y -> decide <$> loop x <*> loop y where decide (BoolLit False) r = r decide l (BoolLit False) = l decide l r | judgmentallyEqual l r = BoolLit False | otherwise = BoolNE l r - BoolIf bool true false -> decide (loop bool) (loop true) (loop false) + BoolIf bool true false -> decide <$> loop bool <*> loop true <*> loop false where decide (BoolLit True ) l _ = l decide (BoolLit False) _ r = r @@ -1674,22 +1754,22 @@ decide b l r | judgmentallyEqual l r = l | otherwise = BoolIf b l r - Natural -> Natural - NaturalLit n -> NaturalLit n - NaturalFold -> NaturalFold - NaturalBuild -> NaturalBuild - NaturalIsZero -> NaturalIsZero - NaturalEven -> NaturalEven - NaturalOdd -> NaturalOdd - NaturalToInteger -> NaturalToInteger - NaturalShow -> NaturalShow - NaturalPlus x y -> decide (loop x) (loop y) + Natural -> pure Natural + NaturalLit n -> pure (NaturalLit n) + NaturalFold -> pure NaturalFold + NaturalBuild -> pure NaturalBuild + NaturalIsZero -> pure NaturalIsZero + NaturalEven -> pure NaturalEven + NaturalOdd -> pure NaturalOdd + NaturalToInteger -> pure NaturalToInteger + NaturalShow -> pure NaturalShow + NaturalPlus x y -> decide <$> loop x <*> loop y where decide (NaturalLit 0) r = r decide l (NaturalLit 0) = l decide (NaturalLit m) (NaturalLit n) = NaturalLit (m + n) decide l r = NaturalPlus l r - NaturalTimes x y -> decide (loop x) (loop y) + NaturalTimes x y -> decide <$> loop x <*> loop y where decide (NaturalLit 1) r = r decide l (NaturalLit 1) = l @@ -1697,25 +1777,29 @@ decide _ (NaturalLit 0) = NaturalLit 0 decide (NaturalLit m) (NaturalLit n) = NaturalLit (m * n) decide l r = NaturalTimes l r - Integer -> Integer - IntegerLit n -> IntegerLit n - IntegerShow -> IntegerShow - IntegerToDouble -> IntegerToDouble - Double -> Double - DoubleLit n -> DoubleLit n - DoubleShow -> DoubleShow - Text -> Text - TextLit (Chunks xys z) -> - case mconcat chunks of - Chunks [("", x)] "" -> x - c -> TextLit c + Integer -> pure Integer + IntegerLit n -> pure (IntegerLit n) + IntegerShow -> pure IntegerShow + IntegerToDouble -> pure IntegerToDouble + Double -> pure Double + DoubleLit n -> pure (DoubleLit n) + DoubleShow -> pure DoubleShow + Text -> pure Text + TextLit (Chunks xys z) -> do + chunks' <- mconcat <$> chunks + case chunks' of + Chunks [("", x)] "" -> pure x + c -> pure (TextLit c) where - chunks = concatMap process xys ++ [Chunks [] z] + chunks = + ((++ [Chunks [] z]) . concat) <$> traverse process xys - process (x, y) = case loop y of - TextLit c -> [Chunks [] x, c] - y' -> [Chunks [(x, y')] mempty] - TextAppend x y -> decide (loop x) (loop y) + process (x, y) = do + y' <- loop y + case y' of + TextLit c -> pure [Chunks [] x, c] + _ -> pure [Chunks [(x, y')] mempty] + TextAppend x y -> decide <$> loop x <*> loop y where isEmpty (Chunks [] "") = True isEmpty _ = False @@ -1724,49 +1808,49 @@ decide l (TextLit n) | isEmpty n = l decide (TextLit m) (TextLit n) = TextLit (m <> n) decide l r = TextAppend l r - List -> List + List -> pure List ListLit t es - | Data.Sequence.null es -> ListLit t' es' - | otherwise -> ListLit Nothing es' + | Data.Sequence.null es -> ListLit <$> t' <*> es' + | otherwise -> ListLit Nothing <$> es' where - t' = fmap loop t - es' = fmap loop es - ListAppend x y -> decide (loop x) (loop y) + t' = traverse loop t + es' = traverse loop es + ListAppend x y -> decide <$> loop x <*> loop y where decide (ListLit _ m) r | Data.Sequence.null m = r decide l (ListLit _ n) | Data.Sequence.null n = l decide (ListLit t m) (ListLit _ n) = ListLit t (m <> n) decide l r = ListAppend l r - ListBuild -> ListBuild - ListFold -> ListFold - ListLength -> ListLength - ListHead -> ListHead - ListLast -> ListLast - ListIndexed -> ListIndexed - ListReverse -> ListReverse - Optional -> Optional + ListBuild -> pure ListBuild + ListFold -> pure ListFold + ListLength -> pure ListLength + ListHead -> pure ListHead + ListLast -> pure ListLast + ListIndexed -> pure ListIndexed + ListReverse -> pure ListReverse + Optional -> pure Optional OptionalLit _A Nothing -> loop (App None _A) OptionalLit _ (Just a) -> loop (Some a) - Some a -> Some a' + Some a -> Some <$> a' where a' = loop a - None -> None - OptionalFold -> OptionalFold - OptionalBuild -> OptionalBuild - Record kts -> Record (Dhall.Map.sort kts') + None -> pure None + OptionalFold -> pure OptionalFold + OptionalBuild -> pure OptionalBuild + Record kts -> Record . Dhall.Map.sort <$> kts' where - kts' = fmap loop kts - RecordLit kvs -> RecordLit (Dhall.Map.sort kvs') + kts' = traverse loop kts + RecordLit kvs -> RecordLit . Dhall.Map.sort <$> kvs' where - kvs' = fmap loop kvs - Union kts -> Union (Dhall.Map.sort kts') + kvs' = traverse loop kvs + Union kts -> Union . Dhall.Map.sort <$> kts' where - kts' = fmap loop kts - UnionLit k v kvs -> UnionLit k v' (Dhall.Map.sort kvs') + kts' = traverse loop kts + UnionLit k v kvs -> UnionLit k <$> v' <*> (Dhall.Map.sort <$> kvs') where - v' = loop v - kvs' = fmap loop kvs - Combine x y -> decide (loop x) (loop y) + v' = loop v + kvs' = traverse loop kvs + Combine x y -> decide <$> loop x <*> loop y where decide (RecordLit m) r | Data.Foldable.null m = r @@ -1776,7 +1860,7 @@ RecordLit (Dhall.Map.sort (Dhall.Map.unionWith decide m n)) decide l r = Combine l r - CombineTypes x y -> decide (loop x) (loop y) + CombineTypes x y -> decide <$> loop x <*> loop y where decide (Record m) r | Data.Foldable.null m = r @@ -1786,8 +1870,7 @@ Record (Dhall.Map.sort (Dhall.Map.unionWith decide m n)) decide l r = CombineTypes l r - - Prefer x y -> decide (loop x) (loop y) + Prefer x y -> decide <$> loop x <*> loop y where decide (RecordLit m) r | Data.Foldable.null m = r @@ -1797,57 +1880,65 @@ RecordLit (Dhall.Map.sort (Dhall.Map.union n m)) decide l r = Prefer l r - Merge x y t -> + Merge x y t -> do + x' <- loop x + y' <- loop y case x' of RecordLit kvsX -> case y' of UnionLit kY vY _ -> case Dhall.Map.lookup kY kvsX of Just vX -> loop (App vX vY) - Nothing -> Merge x' y' t' - _ -> Merge x' y' t' - _ -> Merge x' y' t' + Nothing -> Merge x' y' <$> t' + _ -> Merge x' y' <$> t' + _ -> Merge x' y' <$> t' where - x' = loop x - y' = loop y - t' = fmap loop t - Constructors t -> + t' = traverse loop t + Constructors t -> do + t' <- loop t case t' of - Union kts -> RecordLit kvs + Union kts -> pure (RecordLit kvs) where kvs = Dhall.Map.mapWithKey adapt kts adapt k t_ = Lam k t_ (UnionLit k (Var (V k 0)) rest) where rest = Dhall.Map.delete k kts - _ -> Constructors t' - where - t' = loop t - Field r x -> - case loop r of + _ -> pure (Constructors t') + Field r x -> do + r' <- loop r + case r' of RecordLit kvs -> case Dhall.Map.lookup x kvs of Just v -> loop v - Nothing -> Field (RecordLit (fmap loop kvs)) x - r' -> Field r' x - Project r xs -> - case loop r of + Nothing -> Field <$> (RecordLit <$> traverse loop kvs) <*> pure x + Union kvs -> + case Dhall.Map.lookup x kvs of + Just t_ -> Lam x <$> t' <*> pure (UnionLit x (Var (V x 0)) rest) + where + t' = loop t_ + rest = Dhall.Map.delete x kvs + Nothing -> Field <$> (Union <$> traverse loop kvs) <*> pure x + _ -> pure (Field r' x) + Project r xs -> do + r' <- loop r + case r' of RecordLit kvs -> - case traverse adapt (Data.Set.toList xs) of + case traverse adapt (Dhall.Set.toList xs) of Just s -> loop (RecordLit kvs') where kvs' = Dhall.Map.fromList s Nothing -> - Project (RecordLit (fmap loop kvs)) xs + Project <$> (RecordLit <$> traverse loop kvs) <*> pure xs where adapt x = do v <- Dhall.Map.lookup x kvs return (x, v) - r' -> Project r' xs + _ -> pure (Project r' xs) Note _ e' -> loop e' ImportAlt l _r -> loop l - Embed a -> Embed a + Embed a -> pure (Embed a) {-| Returns `True` if two expressions are α-equivalent and β-equivalent and `False` otherwise @@ -1860,8 +1951,10 @@ -- | Use this to wrap you embedded functions (see `normalizeWith`) to make them -- polymorphic enough to be used. -type Normalizer a = forall s. Expr s a -> Maybe (Expr s a) +type NormalizerM m a = forall s. Expr s a -> m (Maybe (Expr s a)) +type Normalizer a = NormalizerM Identity a + -- | A reified 'Normalizer', which can be stored in structures without -- running into impredicative polymorphism. data ReifiedNormalizer a = ReifiedNormalizer @@ -1872,8 +1965,7 @@ -- -- It is much more efficient to use `isNormalized`. isNormalizedWith :: (Eq s, Eq a) => Normalizer a -> Expr s a -> Bool -isNormalizedWith ctx e = e == (normalizeWith ctx e) - +isNormalizedWith ctx e = e == normalizeWith ctx e -- | Quickly check if an expression is in normal form isNormalized :: Eq a => Expr s a -> Bool @@ -1920,7 +2012,7 @@ App (App (App (App (App OptionalFold _) (App None _)) _) _) _ -> False _ -> True - Let _ _ _ _ -> False + Let _ _ -> False Annot _ _ -> False Bool -> True BoolLit _ -> True @@ -2060,6 +2152,10 @@ case Dhall.Map.lookup x kvs of Just _ -> False Nothing -> True + Union kvs -> + case Dhall.Map.lookup x kvs of + Just _ -> False + Nothing -> True _ -> True Project r xs -> loop r && case r of @@ -2160,5 +2256,103 @@ , "None" , "Optional/build" , "Optional/fold" + , "NaN" + , "Infinity" ] + +-- | A traversal over the immediate sub-expressions of an expression. +subExpressions :: Applicative f => (Expr s a -> f (Expr s a)) -> Expr s a -> f (Expr s a) +subExpressions _ (Const c) = pure (Const c) +subExpressions _ (Var v) = pure (Var v) +subExpressions f (Lam a b c) = Lam a <$> f b <*> f c +subExpressions f (Pi a b c) = Pi a <$> f b <*> f c +subExpressions f (App a b) = App <$> f a <*> f b +subExpressions f (Let as b) = Let <$> traverse g as <*> f b + where + g (Binding c d e) = Binding c <$> traverse f d <*> f e +subExpressions f (Annot a b) = Annot <$> f a <*> f b +subExpressions _ Bool = pure Bool +subExpressions _ (BoolLit b) = pure (BoolLit b) +subExpressions f (BoolAnd a b) = BoolAnd <$> f a <*> f b +subExpressions f (BoolOr a b) = BoolOr <$> f a <*> f b +subExpressions f (BoolEQ a b) = BoolEQ <$> f a <*> f b +subExpressions f (BoolNE a b) = BoolNE <$> f a <*> f b +subExpressions f (BoolIf a b c) = BoolIf <$> f a <*> f b <*> f c +subExpressions _ Natural = pure Natural +subExpressions _ (NaturalLit n) = pure (NaturalLit n) +subExpressions _ NaturalFold = pure NaturalFold +subExpressions _ NaturalBuild = pure NaturalBuild +subExpressions _ NaturalIsZero = pure NaturalIsZero +subExpressions _ NaturalEven = pure NaturalEven +subExpressions _ NaturalOdd = pure NaturalOdd +subExpressions _ NaturalToInteger = pure NaturalToInteger +subExpressions _ NaturalShow = pure NaturalShow +subExpressions f (NaturalPlus a b) = NaturalPlus <$> f a <*> f b +subExpressions f (NaturalTimes a b) = NaturalTimes <$> f a <*> f b +subExpressions _ Integer = pure Integer +subExpressions _ (IntegerLit n) = pure (IntegerLit n) +subExpressions _ IntegerShow = pure IntegerShow +subExpressions _ IntegerToDouble = pure IntegerToDouble +subExpressions _ Double = pure Double +subExpressions _ (DoubleLit n) = pure (DoubleLit n) +subExpressions _ DoubleShow = pure DoubleShow +subExpressions _ Text = pure Text +subExpressions f (TextLit (Chunks a b)) = + TextLit <$> (Chunks <$> traverse (traverse f) a <*> pure b) +subExpressions f (TextAppend a b) = TextAppend <$> f a <*> f b +subExpressions _ List = pure List +subExpressions f (ListLit a b) = ListLit <$> traverse f a <*> traverse f b +subExpressions f (ListAppend a b) = ListAppend <$> f a <*> f b +subExpressions _ ListBuild = pure ListBuild +subExpressions _ ListFold = pure ListFold +subExpressions _ ListLength = pure ListLength +subExpressions _ ListHead = pure ListHead +subExpressions _ ListLast = pure ListLast +subExpressions _ ListIndexed = pure ListIndexed +subExpressions _ ListReverse = pure ListReverse +subExpressions _ Optional = pure Optional +subExpressions f (OptionalLit a b) = OptionalLit <$> f a <*> traverse f b +subExpressions f (Some a) = Some <$> f a +subExpressions _ None = pure None +subExpressions _ OptionalFold = pure OptionalFold +subExpressions _ OptionalBuild = pure OptionalBuild +subExpressions f (Record a) = Record <$> traverse f a +subExpressions f ( RecordLit a ) = RecordLit <$> traverse f a +subExpressions f (Union a) = Union <$> traverse f a +subExpressions f (UnionLit a b c) = UnionLit a <$> f b <*> traverse f c +subExpressions f (Combine a b) = Combine <$> f a <*> f b +subExpressions f (CombineTypes a b) = CombineTypes <$> f a <*> f b +subExpressions f (Prefer a b) = Prefer <$> f a <*> f b +subExpressions f (Merge a b t) = Merge <$> f a <*> f b <*> traverse f t +subExpressions f (Constructors a) = Constructors <$> f a +subExpressions f (Field a b) = Field <$> f a <*> pure b +subExpressions f (Project a b) = Project <$> f a <*> pure b +subExpressions f (Note a b) = Note a <$> f b +subExpressions f (ImportAlt l r) = ImportAlt <$> f l <*> f r +subExpressions _ (Embed a) = pure (Embed a) + +{-| Returns `True` if the given `Char` is valid within an unquoted path + component + + This is exported for reuse within the @"Dhall.Parser.Token"@ module +-} +pathCharacter :: Char -> Bool +pathCharacter c = + '\x21' == c + || ('\x24' <= c && c <= '\x27') + || ('\x2A' <= c && c <= '\x2B') + || ('\x2D' <= c && c <= '\x2E') + || ('\x30' <= c && c <= '\x3B') + || c == '\x3D' + || ('\x40' <= c && c <= '\x5A') + || ('\x5E' <= c && c <= '\x7A') + || c == '\x7C' + || c == '\x7E' + +prettyPathComponent :: Text -> Doc ann +prettyPathComponent text + | Data.Text.all pathCharacter text = + "/" <> Pretty.pretty text + | otherwise = + "/\"" <> Pretty.pretty text <> "\"" diff --git a/src/Dhall/Diff.hs b/src/Dhall/Diff.hs --- a/src/Dhall/Diff.hs +++ b/src/Dhall/Diff.hs @@ -19,15 +19,14 @@ import Data.Function (on) import Data.List.NonEmpty (NonEmpty(..)) import Data.Monoid (Any(..)) -import Data.Scientific (Scientific) import Data.Semigroup import Data.Sequence (Seq) -import Data.Set (Set) import Data.String (IsString(..)) import Data.Text (Text) import Data.Text.Prettyprint.Doc (Doc, Pretty) -import Dhall.Core (Chunks (..), Const(..), Expr(..), Var(..)) +import Dhall.Core (Binding(..), Chunks (..), Const(..), Expr(..), Var(..)) import Dhall.Map (Map) +import Dhall.Set (Set) import Dhall.Pretty.Internal (Ann) import Numeric.Natural (Natural) @@ -38,6 +37,7 @@ import qualified Data.Text.Prettyprint.Doc as Pretty import qualified Dhall.Core import qualified Dhall.Map +import qualified Dhall.Set import qualified Dhall.Pretty.Internal as Internal data Diff = @@ -175,20 +175,22 @@ diffLabels ksL ksR = braced (diffFieldNames <> (if anyEqual then [ ignore ] else [])) where - extraL = Data.Set.difference ksL ksR - extraR = Data.Set.difference ksR ksL + extraL = Dhall.Set.difference ksL ksR + extraR = Dhall.Set.difference ksR ksL diffFieldNames = foldMap (adapt minus) extraL <> foldMap (adapt plus) extraR where adapt sign key = [ sign (token (Internal.prettyLabel key)) ] - anyEqual = not (Data.Set.null (Data.Set.intersection ksL ksR)) + anyEqual = not (Data.Set.null (Data.Set.intersection + (Dhall.Set.toSet ksL) + (Dhall.Set.toSet ksR))) diffNatural :: Natural -> Natural -> Diff diffNatural = diffPrimitive (token . Internal.prettyNatural) -diffScientific :: Scientific -> Scientific -> Diff -diffScientific = diffPrimitive (token . Internal.prettyScientific) +diffDouble :: Double -> Double -> Diff +diffDouble = diffPrimitive (token . Internal.prettyDouble) diffConst :: Const -> Const -> Diff diffConst = diffPrimitive (token . Internal.prettyConst) @@ -698,20 +700,21 @@ mismatch l r diffExpression l r@(BoolIf {}) = mismatch l r -diffExpression l@(Let {}) r@(Let {}) = - enclosed' " " (keyword "in" <> " ") (docs l r) +diffExpression (Let asL bL ) (Let asR bR) = + enclosed' "" (keyword "in" <> " ") + (Data.List.NonEmpty.zipWith docA asL asR <> pure docB) where - docs (Let aL bL cL dL) (Let aR bR cR dR) = - Data.List.NonEmpty.cons (align doc) (docs dL dR) + docA (Binding cL dL eL) (Binding cR dR eR) = align doc where doc = keyword "let" <> " " - <> format " " (diffLabel aL aR) - <> format " " (diffMaybe (colon <> " ") diffExpression bL bR) + <> format " " (diffLabel cL cR) + <> format " " (diffMaybe (colon <> " ") diffExpression dL dR) <> equals <> " " - <> diffExpression cL cR - docs aL aR = pure (diffExpression aL aR) + <> diffExpression eL eR + + docB = diffExpression bL bR diffExpression l@(Let {}) r = mismatch l r diffExpression l r@(Let {}) = @@ -1243,7 +1246,7 @@ diffPrimitiveExpression l r@(NaturalLit {}) = mismatch l r diffPrimitiveExpression (DoubleLit aL) (DoubleLit aR) = - diffScientific aL aR + diffDouble aL aR diffPrimitiveExpression l@(DoubleLit {}) r = mismatch l r diffPrimitiveExpression l r@(DoubleLit {}) = diff --git a/src/Dhall/Import.hs b/src/Dhall/Import.hs --- a/src/Dhall/Import.hs +++ b/src/Dhall/Import.hs @@ -148,6 +148,7 @@ import Dhall.Binary (StandardVersion(..)) import Dhall.Core ( Expr(..) + , Binding(..) , Chunks(..) , Directory(..) , File(..) @@ -188,6 +189,7 @@ import qualified Dhall.Parser import qualified Dhall.Pretty.Internal import qualified Dhall.TypeCheck +import qualified Network.URI.Encode import qualified System.Environment import qualified System.Directory as Directory import qualified System.FilePath as FilePath @@ -609,14 +611,23 @@ return (path, text) - Remote (URL scheme authority file query fragment maybeHeaders) -> do + Remote (URL scheme authority path query fragment maybeHeaders) -> do let prefix = (case scheme of HTTP -> "http"; HTTPS -> "https") <> "://" <> authority - let fileText = Dhall.Pretty.Internal.prettyToStrictText file + let File {..} = path + let Directory {..} = directory + let pathComponentToText component = + "/" <> Network.URI.Encode.encodeText component + + let fileText = + Text.concat + (map pathComponentToText (reverse components)) + <> pathComponentToText file + let suffix = (case query of Nothing -> ""; Just q -> "?" <> q) <> (case fragment of Nothing -> ""; Just f -> "#" <> f) @@ -801,7 +812,9 @@ Lam a b c -> Lam <$> pure a <*> loadWith b <*> loadWith c Pi a b c -> Pi <$> pure a <*> loadWith b <*> loadWith c App a b -> App <$> loadWith a <*> loadWith b - Let a b c d -> Let <$> pure a <*> mapM loadWith b <*> loadWith c <*> loadWith d + Let as b -> Let <$> traverse f as <*> loadWith b + where + f (Binding c d e) = Binding c <$> traverse loadWith d <*> loadWith e Annot a b -> Annot <$> loadWith a <*> loadWith b Bool -> pure Bool BoolLit a -> pure (BoolLit a) diff --git a/src/Dhall/Import/Types.hs b/src/Dhall/Import/Types.hs --- a/src/Dhall/Import/Types.hs +++ b/src/Dhall/Import/Types.hs @@ -73,7 +73,7 @@ _standardVersion = Dhall.Binary.defaultStandardVersion - _normalizer = ReifiedNormalizer (const Nothing) + _normalizer = ReifiedNormalizer (const (pure Nothing)) _startingContext = Dhall.Context.empty diff --git a/src/Dhall/Lint.hs b/src/Dhall/Lint.hs --- a/src/Dhall/Lint.hs +++ b/src/Dhall/Lint.hs @@ -5,7 +5,9 @@ lint ) where -import Dhall.Core (Chunks(..), Expr(..), Import, Var(..)) +import Dhall.Core (Binding(..), Chunks(..), Expr(..), Import, Var(..)) +import Data.Semigroup ((<>)) +import Data.List.NonEmpty (NonEmpty(..)) import Dhall.TypeCheck (X(..)) import qualified Dhall.Core @@ -15,6 +17,7 @@ Currently this: * removes unused @let@ bindings + * consolidates nested @let@ bindings to use a multiple-@let@ binding * switches legacy @List@-like @Optional@ literals to use @Some@ / @None@ instead -} lint :: Expr s Import -> Expr t Import @@ -36,15 +39,32 @@ where a' = loop a b' = loop b - loop (Let a b c d) + + -- Consolidate nested `let` expresssions + loop (Let a (Let b c)) = loop (Let (a <> b) c) + + -- Remove unused bindings + loop (Let (Binding a b c :| []) d) | not (V a 0 `Dhall.Core.freeIn` d') = d' | otherwise = - Let a b' c' d' + Let (Binding a b' c' :| []) d' where b' = fmap loop b c' = loop c - d' = loop d + + d' = loop d + loop (Let (Binding a b c :| (l : ls)) d) + | not (V a 0 `Dhall.Core.freeIn` d') = + Let (l' :| ls') d' + | otherwise = + Let (Binding a b' c' :| (l' : ls')) d' + where + b' = fmap loop b + c' = loop c + + Let (l' :| ls') d' = loop (Let (l :| ls) d) + loop (Annot a b) = Annot a' b' where diff --git a/src/Dhall/Parser/Combinators.hs b/src/Dhall/Parser/Combinators.hs --- a/src/Dhall/Parser/Combinators.hs +++ b/src/Dhall/Parser/Combinators.hs @@ -10,12 +10,12 @@ import Data.Data (Data) import Data.Semigroup (Semigroup (..)) import Data.Sequence (ViewL (..)) -import Data.Set (Set) import Data.String (IsString (..)) import Data.Text (Text) import Data.Text.Prettyprint.Doc (Pretty (..)) import Data.Void (Void) -import Dhall.Map (Map) +import Dhall.Map (Map) +import Dhall.Set (Set) import Prelude hiding (const, pi) import Text.Parser.Combinators (try, ()) import Text.Parser.Token (TokenParsing (..)) @@ -27,6 +27,7 @@ import qualified Data.Text import qualified Dhall.Map import qualified Dhall.Util +import qualified Dhall.Set import qualified Text.Megaparsec import qualified Text.Megaparsec.Char import qualified Text.Parser.Char @@ -237,13 +238,13 @@ takeWhile1 predicate = Parser (Text.Megaparsec.takeWhile1P Nothing predicate) noDuplicates :: Ord a => [a] -> Parser (Set a) -noDuplicates = go Data.Set.empty +noDuplicates = go Dhall.Set.empty where go found [] = return found go found (x:xs) = - if Data.Set.member x found + if Data.Set.member x (Dhall.Set.toSet found) then fail "Duplicate key" - else go (Data.Set.insert x found) xs + else go (Dhall.Set.append x found) xs toMap :: [(Text, a)] -> Parser (Map Text a) toMap kvs = do diff --git a/src/Dhall/Parser/Expression.hs b/src/Dhall/Parser/Expression.hs --- a/src/Dhall/Parser/Expression.hs +++ b/src/Dhall/Parser/Expression.hs @@ -20,6 +20,7 @@ import qualified Data.ByteArray.Encoding import qualified Data.ByteString import qualified Data.Char +import qualified Data.List.NonEmpty import qualified Data.Sequence import qualified Data.Text import qualified Data.Text.Encoding @@ -82,17 +83,28 @@ return (BoolIf a b c) alternative2 = do - _let - a <- label - b <- optional (do - _colon - expression ) - _equal - c <- expression + let binding = do + _let + + c <- label + d <- optional (do + _colon + expression ) + + _equal + + e <- expression + + return (Binding c d e) + + as <- Data.List.NonEmpty.some1 binding + _in - d <- expression - return (Let a b c d) + b <- expression + + return (Let as b) + alternative3 = do _forall _openParens @@ -158,8 +170,8 @@ <|> Combine <$ _combine precedence2Operator = - Prefer <$ _prefer - <|> CombineTypes <$ _combineTypes + CombineTypes <$ _combineTypes + <|> Prefer <$ _prefer <|> NaturalTimes <$ _times <|> BoolNE <$ _notEqual @@ -218,6 +230,7 @@ , alternative06 , alternative07 , alternative37 + , alternative09 , builtin "built-in expression" ] @@ -225,8 +238,12 @@ <|> alternative38 where alternative00 = do + n <- Text.Megaparsec.getOffset a <- try doubleLiteral - return (DoubleLit a) + b <- if isInfinite a + then Text.Megaparsec.setOffset n *> fail "double out of bounds" + else return a + return (DoubleLit b) alternative01 = do a <- try naturalLiteral @@ -258,6 +275,10 @@ b <- importExpression return (Merge a b Nothing) + alternative09 = do + a <- try doubleInfinity + return (DoubleLit a) + builtin = do let predicate c = c == 'N' @@ -271,6 +292,8 @@ || c == 'F' || c == 'K' + let nan = (0.0/0.0) + c <- Text.Megaparsec.lookAhead (Text.Megaparsec.satisfy predicate) case c of @@ -286,6 +309,7 @@ , NaturalShow <$ _NaturalShow , Natural <$ _Natural , None <$ _None + , DoubleLit nan <$ _NaN ] 'I' -> choice diff --git a/src/Dhall/Parser/Token.hs b/src/Dhall/Parser/Token.hs --- a/src/Dhall/Parser/Token.hs +++ b/src/Dhall/Parser/Token.hs @@ -14,6 +14,7 @@ identifier, hexNumber, doubleLiteral, + doubleInfinity, naturalLiteral, integerLiteral, _Optional, @@ -55,6 +56,7 @@ _List, _True, _False, + _NaN, _Type, _Kind, _Sort, @@ -95,9 +97,9 @@ import Control.Applicative (Alternative(..), optional) import Data.Functor (void) import Data.Semigroup (Semigroup(..)) -import Data.Set (Set) import Data.Text (Text) import Dhall.Core +import Dhall.Set (Set) import Prelude hiding (const, pi) import Text.Parser.Combinators (choice, try, ()) @@ -105,12 +107,12 @@ import qualified Data.Char import qualified Data.HashSet import qualified Data.List.NonEmpty -import qualified Data.Set import qualified Data.Text +import qualified Dhall.Set +import qualified Text.Megaparsec import qualified Text.Parser.Char import qualified Text.Parser.Combinators -import Data.Scientific (Scientific) import Numeric.Natural (Natural) import Prelude hiding (const, pi) @@ -135,18 +137,28 @@ || ('A' <= c && c <= 'F') || ('a' <= c && c <= 'f') -doubleLiteral :: Parser Scientific +signPrefix :: Num a => Parser (a -> a) +signPrefix = (do + let positive = fmap (\_ -> id ) (Text.Parser.Char.char '+') + let negative = fmap (\_ -> negate) (Text.Parser.Char.char '-') + positive <|> negative ) "sign" + +doubleLiteral :: Parser Double doubleLiteral = (do - sign <- fmap (\_ -> negate) (Text.Parser.Char.char '-') - <|> pure id - a <- Text.Parser.Token.scientific + sign <- signPrefix <|> pure id + a <- Text.Parser.Token.double return (sign a) ) "double literal" +doubleInfinity :: Parser Double +doubleInfinity = (do + let negative = fmap (\_ -> negate) (Text.Parser.Char.char '-') + sign <- negative <|> pure id + a <- Text.Parser.Char.text "Infinity" >> whitespace >> return (1.0/0.0) + return (sign a) ) "double infinity" + integerLiteral :: Parser Integer integerLiteral = (do - let positive = fmap (\_ -> id ) (Text.Parser.Char.char '+') - let negative = fmap (\_ -> negate) (Text.Parser.Char.char '-') - sign <- positive <|> negative + sign <- signPrefix a <- Text.Parser.Token.natural return (sign a) ) "integer literal" @@ -278,7 +290,7 @@ _closeBrace return xs where - emptyLabels = pure Data.Set.empty + emptyLabels = pure Dhall.Set.empty nonEmptyLabels = do x <- label @@ -314,26 +326,26 @@ || ('\x3E' <= c && c <= '\x5B') || ('\x5D' <= c && c <= '\x7E') -pathCharacter :: Char -> Bool -pathCharacter c = - ('\x21' <= c && c <= '\x22') - || ('\x24' <= c && c <= '\x27') - || ('\x2A' <= c && c <= '\x2B') - || ('\x2D' <= c && c <= '\x2E') - || ('\x30' <= c && c <= '\x3B') - || c == '\x3D' - || ('\x40' <= c && c <= '\x5A') - || ('\x5E' <= c && c <= '\x7A') - || c == '\x7C' - || c == '\x7E' +quotedPathCharacter :: Char -> Bool +quotedPathCharacter c = + ('\x20' <= c && c <= '\x21') + || ('\x23' <= c && c <= '\x2E') + || ('\x30' <= c && c <= '\x7E') pathComponent :: Parser Text pathComponent = do _ <- "/" :: Parser Text - string <- some (Text.Parser.Char.satisfy pathCharacter) - return (Data.Text.pack string) + let pathData = Text.Megaparsec.takeWhile1P Nothing Dhall.Core.pathCharacter + let quotedPathData = do + _ <- Text.Parser.Char.char '"' + text <- Text.Megaparsec.takeWhile1P Nothing quotedPathCharacter + _ <- Text.Parser.Char.char '"' + return text + + pathData <|> quotedPathData + file_ :: Parser File file_ = do path <- Data.List.NonEmpty.some1 pathComponent @@ -529,7 +541,7 @@ _constructors = keyword "constructors" _Some :: Parser () -_Some = reserved "Some" +_Some = keyword "Some" _None :: Parser () _None = reserved "None" @@ -617,6 +629,9 @@ _False :: Parser () _False = reserved "False" + +_NaN :: Parser () +_NaN = reserved "NaN" _Type :: Parser () _Type = reserved "Type" diff --git a/src/Dhall/Pretty/Internal.hs b/src/Dhall/Pretty/Internal.hs --- a/src/Dhall/Pretty/Internal.hs +++ b/src/Dhall/Pretty/Internal.hs @@ -23,7 +23,7 @@ , prettyLabels , prettyNatural , prettyNumber - , prettyScientific + , prettyDouble , prettyToStrictText , prettyToString @@ -53,7 +53,7 @@ , rparen ) where -import {-# SOURCE #-} Dhall.Core +import Dhall.Core #if MIN_VERSION_base(4,8,0) #else @@ -61,11 +61,10 @@ #endif import Data.Foldable import Data.Monoid ((<>)) -import Data.Scientific (Scientific) -import Data.Set (Set) import Data.Text (Text) import Data.Text.Prettyprint.Doc (Doc, Pretty, space) import Dhall.Map (Map) +import Dhall.Set (Set) import Numeric.Natural (Natural) import Prelude hiding (succ) import qualified Data.Text.Prettyprint.Doc.Render.Terminal as Terminal @@ -79,6 +78,7 @@ import qualified Data.Text.Prettyprint.Doc.Render.Text as Pretty import qualified Data.Text.Prettyprint.Doc.Render.String as Pretty import qualified Dhall.Map +import qualified Dhall.Set {-| Annotation type used to tag elements in a pretty-printed document for syntax highlighting purposes @@ -294,10 +294,10 @@ prettyLabels :: Set Text -> Doc Ann prettyLabels a - | Data.Set.null a = + | Data.Set.null (Dhall.Set.toSet a) = lbrace <> rbrace | otherwise = - braces (map (duplicate . prettyLabel) (Data.Set.toList a)) + braces (map (duplicate . prettyLabel) (Dhall.Set.toList a)) prettyNumber :: Integer -> Doc Ann prettyNumber = literal . Pretty.pretty @@ -305,8 +305,8 @@ prettyNatural :: Natural -> Doc Ann prettyNatural = literal . Pretty.pretty -prettyScientific :: Scientific -> Doc Ann -prettyScientific = literal . Pretty.pretty . show +prettyDouble :: Double -> Doc Ann +prettyDouble = literal . Pretty.pretty prettyConst :: Const -> Doc Ann prettyConst Type = builtin "Type" @@ -386,50 +386,51 @@ ] docsShort (Note _ c) = docsShort c docsShort c = [ prettyExpression c ] - prettyExpression a0@(Let _ _ _ _) = - enclose' "" " " (space <> keyword "in" <> space) (Pretty.hardline <> keyword "in" <> " ") - (fmap duplicate (docs a0)) + prettyExpression (Let as b) = + enclose' "" "" space Pretty.hardline + (fmap duplicate (fmap docA (toList as)) ++ [ docB ]) where - docs (Let a Nothing c d) = - Pretty.group (Pretty.flatAlt long short) : docs d + docA (Binding c Nothing e) = + Pretty.group (Pretty.flatAlt long short) where long = keyword "let" <> space <> Pretty.align - ( prettyLabel a + ( prettyLabel c <> space <> equals <> Pretty.hardline <> " " - <> prettyExpression c + <> prettyExpression e ) short = keyword "let" <> space - <> prettyLabel a + <> prettyLabel c <> (space <> equals <> space) - <> prettyExpression c - docs (Let a (Just b) c d) = - Pretty.group (Pretty.flatAlt long short) : docs d + <> prettyExpression e + docA (Binding c (Just d) e) = + Pretty.group (Pretty.flatAlt long short) where long = keyword "let" <> space <> Pretty.align - ( prettyLabel a + ( prettyLabel c <> Pretty.hardline <> colon <> space - <> prettyExpression b + <> prettyExpression d <> Pretty.hardline <> equals <> space - <> prettyExpression c + <> prettyExpression e ) short = keyword "let" <> space - <> prettyLabel a + <> prettyLabel c <> space <> colon <> space - <> prettyExpression b + <> prettyExpression d <> space <> equals <> space - <> prettyExpression c - docs (Note _ d) = - docs d - docs d = - [ prettyExpression d ] + <> prettyExpression e + + docB = + ( keyword "in" <> " " <> prettyExpression b + , keyword "in" <> " " <> prettyExpression b + ) prettyExpression a0@(Pi _ _ _) = arrows characterSet (fmap duplicate (docs a0)) where @@ -784,7 +785,7 @@ prettyPrimitiveExpression (NaturalLit a) = prettyNatural a prettyPrimitiveExpression (DoubleLit a) = - prettyScientific a + prettyDouble a prettyPrimitiveExpression (TextLit a) = prettyChunks a prettyPrimitiveExpression (Record a) = @@ -809,15 +810,15 @@ short = lparen <> prettyExpression a <> rparen prettyKeyValue :: Pretty a => Doc Ann -> (Text, Expr s a) -> (Doc Ann, Doc Ann) - prettyKeyValue separator (key, value) = - ( prettyLabel key <> " " <> separator <> " " <> prettyExpression value + prettyKeyValue separator (key, val) = + ( prettyLabel key <> " " <> separator <> " " <> prettyExpression val , prettyLabel key <> " " <> separator <> long ) where - long = Pretty.hardline <> " " <> prettyExpression value + long = Pretty.hardline <> " " <> prettyExpression val prettyRecord :: Pretty a => Map Text (Expr s a) -> Doc Ann prettyRecord = @@ -909,22 +910,22 @@ escapeText text = Text.concatMap adapt text where adapt c - | '\x20' <= c && c <= '\x21' = Text.singleton c + | '\x20' <= c && c <= '\x21' = Text.singleton c -- '\x22' == '"' - | '\x23' == c = Text.singleton c + | '\x23' == c = Text.singleton c -- '\x24' == '$' - | '\x25' <= c && c <= '\x5B' = Text.singleton c + | '\x25' <= c && c <= '\x5B' = Text.singleton c -- '\x5C' == '\\' - | '\x5D' <= c && c <= '\x7F' = Text.singleton c - | c == '"' = "\\\"" - | c == '$' = "\\$" - | c == '\\' = "\\\\" - | c == '\b' = "\\b" - | c == '\f' = "\\f" - | c == '\n' = "\\n" - | c == '\r' = "\\r" - | c == '\t' = "\\t" - | otherwise = "\\u" <> showDigits (Data.Char.ord c) + | '\x5D' <= c && c <= '\x10FFFF' = Text.singleton c + | c == '"' = "\\\"" + | c == '$' = "\\$" + | c == '\\' = "\\\\" + | c == '\b' = "\\b" + | c == '\f' = "\\f" + | c == '\n' = "\\n" + | c == '\r' = "\\r" + | c == '\t' = "\\t" + | otherwise = "\\u" <> showDigits (Data.Char.ord c) showDigits r0 = Text.pack (map showDigit [q1, q2, q3, r3]) where diff --git a/src/Dhall/Repl.hs b/src/Dhall/Repl.hs --- a/src/Dhall/Repl.hs +++ b/src/Dhall/Repl.hs @@ -26,6 +26,7 @@ import qualified Dhall import qualified Dhall.Binary import qualified Dhall.Context +import qualified Dhall.Core import qualified Dhall.Core as Dhall ( Var(V), Expr, normalize ) import qualified Dhall.Pretty import qualified Dhall.Core as Expr ( Expr(..) ) @@ -159,7 +160,7 @@ ( Dhall.normalize ( foldl' ( \a (k, Binding { bindingType, bindingExpr }) -> - Expr.Let k ( Just bindingType ) bindingExpr a + Expr.Let (pure (Dhall.Core.Binding k (Just bindingType) bindingExpr)) a ) e ( Dhall.Context.toList ( envToContext env ) ) diff --git a/src/Dhall/Set.hs b/src/Dhall/Set.hs new file mode 100644 --- /dev/null +++ b/src/Dhall/Set.hs @@ -0,0 +1,64 @@ +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE DeriveGeneric #-} + +-- | This module only exports ways of constructing a Set, +-- retrieving List, Set, and Seq representations of the same data, +-- as well as a novel "difference" function. +-- Any other Set-like or List-like functionality +-- should be obtained through toSet and toList, respectively. +module Dhall.Set ( + Set(..) + , toList + , toSet + , toSeq + , fromList + , append + , empty + , difference + ) where + +import Prelude +import Data.List (foldl') +import Data.Sequence (Seq, (|>)) +import Data.Data (Data) +import GHC.Generics (Generic) + +import qualified Data.Set +import qualified Data.Sequence +import qualified Data.Foldable + +data Set a = Set (Data.Set.Set a) (Seq a) + deriving (Eq, Generic, Ord, Show, Data) + +instance Foldable Set where + foldMap f = foldMap f . toSeq + +toSet :: Set a -> Data.Set.Set a +toSet (Set s _) = s + +toSeq :: Set a -> Seq a +toSeq (Set _ xs) = xs + +toList :: Set a -> [a] +toList = Data.Foldable.toList + +-- O(n log n) time complexity, O(n) space complexity. +-- Implementing it this way is a little silly, but is faster than (nub xs). +-- n.b. toList . fromList = id, only if the list elements are unique +fromList :: Ord a => [a] -> Set a +fromList = foldl' (flip append) empty + +-- O(log n) time complexity. +append :: Ord a => a -> Set a -> Set a +append x os@(Set s xs) + | Data.Set.member x s = os + | otherwise = Set (Data.Set.insert x s) (xs |> x) + +empty :: Set a +empty = Set Data.Set.empty Data.Sequence.empty + +-- | Returns, in order, all elements of the first Set not present in the second. +-- (It doesn't matter in what order the elements appear in the second Set.) +difference :: Ord a => Set a -> Set a -> [a] +difference os (Set s _) = + filter (\ x -> not (Data.Set.member x s)) (toList os) diff --git a/src/Dhall/TypeCheck.hs b/src/Dhall/TypeCheck.hs --- a/src/Dhall/TypeCheck.hs +++ b/src/Dhall/TypeCheck.hs @@ -24,6 +24,7 @@ import Control.Exception (Exception) import Data.Data (Data(..)) import Data.Foldable (forM_, toList) +import Data.List.NonEmpty (NonEmpty(..)) import Data.Sequence (Seq, ViewL(..)) import Data.Semigroup (Semigroup(..)) import Data.Set (Set) @@ -31,7 +32,7 @@ import Data.Text.Prettyprint.Doc (Doc, Pretty(..)) import Data.Traversable (forM) import Data.Typeable (Typeable) -import Dhall.Core (Const(..), Chunks(..), Expr(..), Var(..)) +import Dhall.Core (Binding(..), Const(..), Chunks(..), Expr(..), Var(..)) import Dhall.Context (Context) import Dhall.Pretty (Ann, layoutOpts) @@ -45,6 +46,7 @@ import qualified Dhall.Core import qualified Dhall.Diff import qualified Dhall.Map +import qualified Dhall.Set import qualified Dhall.Pretty.Internal import qualified Dhall.Util @@ -60,9 +62,9 @@ rule :: Const -> Const -> Either () Const rule Type Type = return Type rule Kind Type = return Type -rule Kind Kind = return Kind rule Sort Type = return Type -rule Sort Kind = return Kind +rule Kind Kind = return Kind +rule Sort Kind = return Sort rule Sort Sort = return Sort -- This forbids dependent types. If this ever changes, then the fast -- path in the Let case of typeWithA will become unsound. @@ -146,7 +148,7 @@ let nf_A = Dhall.Core.normalize _A let nf_A' = Dhall.Core.normalize _A' Left (TypeError ctx e (TypeMismatch f nf_A a nf_A')) - loop ctx e@(Let x mA a0 b0) = do + loop ctx e@(Let (Binding x mA a0 :| ls) b0) = do _A1 <- loop ctx a0 case mA of Just _A0 -> do @@ -163,6 +165,10 @@ let a1 = Dhall.Core.normalize a0 let a2 = Dhall.Core.shift 1 (V x 0) a1 + let rest = case ls of + [] -> b0 + l' : ls' -> Let (l' :| ls') b0 + -- The catch-all branch directly implements the Dhall -- specification as written; it is necessary to substitute in -- types in order to get 'dependent let' behaviour and to @@ -175,13 +181,13 @@ case Dhall.Core.normalize t of Const Type -> do let ctx' = fmap (Dhall.Core.shift 1 (V x 0)) (Dhall.Context.insert x (Dhall.Core.normalize _A1) ctx) - _B0 <- loop ctx' b0 + _B0 <- loop ctx' rest let _B1 = Dhall.Core.subst (V x 0) a2 _B0 let _B2 = Dhall.Core.shift (-1) (V x 0) _B1 return _B2 _ -> do - let b1 = Dhall.Core.subst (V x 0) a2 b0 + let b1 = Dhall.Core.subst (V x 0) a2 rest let b2 = Dhall.Core.shift (-1) (V x 0) b1 loop ctx b2 @@ -505,7 +511,11 @@ _ -> Left (TypeError ctx e (InvalidFieldType k t)) Dhall.Map.traverseWithKey_ process rest - return (Const c) + + case c of + Type -> return (Const Type) + Kind -> return (Const Sort) + Sort -> return (Const Sort) loop ctx e@(RecordLit kvs ) = do case Dhall.Map.toList kvs of [] -> return (Record mempty) @@ -770,6 +780,9 @@ return (Record (Dhall.Map.mapWithKey adapt kts)) loop ctx e@(Field r x ) = do t <- fmap Dhall.Core.normalize (loop ctx r) + + let text = Dhall.Pretty.Internal.docToStrictText (Dhall.Pretty.Internal.prettyLabel x) + case t of Record kts -> do _ <- loop ctx t @@ -777,9 +790,15 @@ case Dhall.Map.lookup x kts of Just t' -> return t' Nothing -> Left (TypeError ctx e (MissingField x t)) + Const Type -> do + case Dhall.Core.normalize r of + Union kts -> + case Dhall.Map.lookup x kts of + Just t' -> return (Pi x t' (Union kts)) + Nothing -> Left (TypeError ctx e (MissingField x t)) + r' -> Left (TypeError ctx e (CantAccess text r' t)) _ -> do - let text = Dhall.Pretty.Internal.docToStrictText (Dhall.Pretty.Internal.prettyLabel x) - Left (TypeError ctx e (NotARecord text r t)) + Left (TypeError ctx e (CantAccess text r t)) loop ctx e@(Project r xs ) = do t <- fmap Dhall.Core.normalize (loop ctx r) case t of @@ -791,10 +810,10 @@ Just t' -> return (k, t') Nothing -> Left (TypeError ctx e (MissingField k t)) let adapt = Record . Dhall.Map.fromList - fmap adapt (traverse process (Data.Set.toList xs)) + fmap adapt (traverse process (Dhall.Set.toList xs)) _ -> do let text = Dhall.Pretty.Internal.docToStrictText (Dhall.Pretty.Internal.prettyLabels xs) - Left (TypeError ctx e (NotARecord text r t)) + Left (TypeError ctx e (CantProject text r t)) loop ctx (Note s e' ) = case loop ctx e' of Left (TypeError ctx' (Note s' e'') m) -> Left (TypeError ctx' (Note s' e'') m) Left (TypeError ctx' e'' m) -> Left (TypeError ctx' (Note s e'') m) @@ -869,7 +888,8 @@ | MissingMergeType | HandlerNotAFunction Text (Expr s a) | ConstructorsRequiresAUnionType (Expr s a) (Expr s a) - | NotARecord Text (Expr s a) (Expr s a) + | CantAccess Text (Expr s a) (Expr s a) + | CantProject Text (Expr s a) (Expr s a) | MissingField Text (Expr s a) | CantAnd (Expr s a) (Expr s a) | CantOr (Expr s a) (Expr s a) @@ -3242,18 +3262,18 @@ where txt0 = insert expr0 txt1 = insert expr1 - -prettyTypeMessage (NotARecord lazyText0 expr0 expr1) = ErrorMessages {..} + +prettyTypeMessage (CantAccess lazyText0 expr0 expr1) = ErrorMessages {..} where - short = "Not a record" + short = "Not a record or a union" long = - "Explanation: You can only access fields on records, like this: \n\ + "Explanation: You can only access fields on records or unions, like this: \n\ \ \n\ \ \n\ - \ ┌─────────────────────────────────┐ \n\ + \ ┌───────────────────────────────────┐ \n\ \ │ { foo = True, bar = \"ABC\" }.foo │ This is valid ... \n\ - \ └─────────────────────────────────┘ \n\ + \ └───────────────────────────────────┘ \n\ \ \n\ \ \n\ \ ┌───────────────────────────────────────────┐ \n\ @@ -3261,6 +3281,16 @@ \ └───────────────────────────────────────────┘ \n\ \ \n\ \ \n\ + \ ┌─────────────────────────────────┐ \n\ + \ │ < foo : Bool | bar : Text >.foo │ ... and so is this \n\ + \ └─────────────────────────────────┘ \n\ + \ \n\ + \ \n\ + \ ┌────────────────────────────────────────────┐ \n\ + \ │ λ(r : < foo : Bool | bar : Text >) → r.foo │ ... and so is this \n\ + \ └────────────────────────────────────────────┘ \n\ + \ \n\ + \ \n\ \... but you cannot access fields on non-record expressions \n\ \ \n\ \For example, the following expression is " <> _NOT <> " valid: \n\ @@ -3273,22 +3303,70 @@ \ Invalid: Not a record \n\ \ \n\ \ \n\ + \────────────────────────────────────────────────────────────────────────────────\n\ + \ \n\ + \You tried to access the field: \n\ + \ \n\ + \" <> txt0 <> "\n\ + \ \n\ + \... on the following expression which is not a record nor a union type: \n\ + \ \n\ + \" <> txt1 <> "\n\ + \ \n\ + \... but is actually an expression of type: \n\ + \ \n\ + \" <> txt2 <> "\n" + where + txt0 = insert lazyText0 + txt1 = insert expr0 + txt2 = insert expr1 + +prettyTypeMessage (CantProject lazyText0 expr0 expr1) = ErrorMessages {..} + where + short = "Not a record" + + long = + "Explanation: You can only project fields on records, like this: \n\ + \ \n\ + \ \n\ + \ ┌─────────────────────────────────────────────────────┐ \n\ + \ │ { foo = True, bar = \"ABC\", baz = 1 }.{ foo, bar } │ This is valid ... \n\ + \ └─────────────────────────────────────────────────────┘ \n\ + \ \n\ + \ \n\ + \ ┌────────────────────────────────────────────────────────────────────┐ \n\ + \ │ λ(r : { foo : Bool, bar : Text , baz : Natural }) → r.{ foo, bar } │ ... and so is this \n\ + \ └────────────────────────────────────────────────────────────────────┘ \n\ + \ \n\ + \ \n\ + \... but you cannot project fields on non-record expressions \n\ + \ \n\ + \For example, the following expression is " <> _NOT <> " valid: \n\ + \ \n\ + \ \n\ + \ ┌────────────────┐ \n\ + \ │ 1.{ foo, bar } │ \n\ + \ └────────────────┘ \n\ + \ ⇧ \n\ + \ Invalid: Not a record \n\ + \ \n\ + \ \n\ \Some common reasons why you might get this error: \n\ \ \n\ - \● You accidentally try to access a field of a union instead of a record, like \n\ + \● You accidentally try to project fields of a union instead of a record, like \n\ \ this: \n\ \ \n\ \ \n\ - \ ┌─────────────────┐ \n\ - \ │ < foo : a >.foo │ \n\ - \ └─────────────────┘ \n\ + \ ┌────────────────────────────────────┐ \n\ + \ │ < foo : a | bar : b >.{ foo, bar } │ \n\ + \ └────────────────────────────────────┘ \n\ \ ⇧ \n\ \ This is a union, not a record \n\ \ \n\ \ \n\ \────────────────────────────────────────────────────────────────────────────────\n\ \ \n\ - \You tried to access the field(s): \n\ + \You tried to access the fields: \n\ \ \n\ \" <> txt0 <> "\n\ \ \n\ diff --git a/tests/Format.hs b/tests/Format.hs --- a/tests/Format.hs +++ b/tests/Format.hs @@ -34,6 +34,10 @@ "fieldOrder" , should Unicode + "preserve the original order of projections" + "projectionOrder" + , should + Unicode "escape numeric labels correctly" "escapeNumericLabel" , should @@ -42,6 +46,10 @@ "largeExponent" , should Unicode + "round a double to the nearest representable value. Ties go to even least significant bit" + "doubleRound" + , should + Unicode "correctly format the empty record literal" "emptyRecord" , should @@ -72,6 +80,10 @@ ASCII "be able to format with ASCII characters" "ascii" + , should + Unicode + "preserve Unicode characters" + "unicode" ] should :: CharacterSet -> Text -> Text -> TestTree diff --git a/tests/Import.hs b/tests/Import.hs --- a/tests/Import.hs +++ b/tests/Import.hs @@ -23,38 +23,38 @@ [ shouldFail 3 "alternative of several unset env variables" - "./tests/import/alternativeEnv.dhall" + "./tests/import/failure/alternativeEnv.dhall" , shouldFail 1 "alternative of env variable and missing" - "./tests/import/alternativeEnvMissing.dhall" + "./tests/import/failure/alternativeEnvMissing.dhall" , shouldFail 0 "just missing" - "./tests/import/missing.dhall" + "./tests/import/failure/missing.dhall" , shouldNotFail "alternative of env variable, missing, and a Natural" - "./tests/import/alternativeEnvNatural.dhall" + "./tests/import/success/alternativeEnvNaturalA.dhall" , shouldNotFail "alternative of env variable and a Natural" - "./tests/import/alternativeEnvSimple.dhall" + "./tests/import/success/alternativeEnvSimpleA.dhall" , shouldNotFail "alternative of a Natural and missing" - "./tests/import/alternativeNatural.dhall" + "./tests/import/success/alternativeNaturalA.dhall" ] , Test.Tasty.testGroup "import relative to argument" [ shouldNotFailRelative "works" "./tests/import/data/foo/bar" - "./tests/import/relative.dhall" + "./tests/import/success/relative.dhall" , shouldNotFailRelative "a semantic integrity check if fields are reordered" - "./tests/import/" - "./tests/import/fieldOrderC.dhall" + "./tests/import/success/" + "./tests/import/success/fieldOrderA.dhall" , shouldNotFailRelative "a semantic integrity check when importing an expression using `constructors`" - "./tests/import/" - "./tests/import/issue553B.dhall" + "./tests/import/success/" + "./tests/import/success/issue553B.dhall" ] ] diff --git a/tests/Normalization.hs b/tests/Normalization.hs --- a/tests/Normalization.hs +++ b/tests/Normalization.hs @@ -29,176 +29,181 @@ , simplifications , constantFolding , conversions - , shouldNormalize "Optional build/fold fusion" "optionalBuildFold" + , shouldNormalize "Optional build/fold fusion" "success/simple/optionalBuildFold" , customization - , shouldNormalize "a remote-systems.conf builder" "remoteSystems" - , shouldNormalize "multi-line strings correctly" "multiLine" - , shouldNormalize "the // operator and sort the fields" "sortOperator" + , shouldNormalize "a remote-systems.conf builder" "success/remoteSystems" + , shouldNormalize "multi-line strings correctly" "success/simple/multiLine" + , shouldNormalize "the // operator and sort the fields" "success/simple/sortOperator" ] tutorialExamples :: TestTree tutorialExamples = testGroup "Tutorial examples" - [ shouldNormalize "⩓" "./tutorial/combineTypes/0" - , shouldNormalize "projection" "./tutorial/projection/0" + [ shouldNormalize "⩓" "./success/haskell-tutorial/combineTypes/0" + , shouldNormalize "//\\\\" "./success/haskell-tutorial/combineTypes/1" + , shouldNormalize "//" "./success/haskell-tutorial/prefer/0" + , shouldNormalize "projection" "./success/haskell-tutorial/projection/0" + , shouldNormalize "access record" "./success/haskell-tutorial/access/0" + , shouldNormalize "access union" "./success/haskell-tutorial/access/1" ] preludeExamples :: TestTree preludeExamples = testGroup "Prelude examples" - [ shouldNormalize "Bool/and" "./examples/Bool/and/0" - , shouldNormalize "Bool/and" "./examples/Bool/and/1" - , shouldNormalize "Bool/build" "./examples/Bool/build/0" - , shouldNormalize "Bool/build" "./examples/Bool/build/1" - , shouldNormalize "Bool/even" "./examples/Bool/even/0" - , shouldNormalize "Bool/even" "./examples/Bool/even/1" - , shouldNormalize "Bool/even" "./examples/Bool/even/2" - , shouldNormalize "Bool/even" "./examples/Bool/even/3" - , shouldNormalize "Bool/fold" "./examples/Bool/fold/0" - , shouldNormalize "Bool/fold" "./examples/Bool/fold/1" - , shouldNormalize "Bool/not" "./examples/Bool/not/0" - , shouldNormalize "Bool/not" "./examples/Bool/not/1" - , shouldNormalize "Bool/odd" "./examples/Bool/odd/0" - , shouldNormalize "Bool/odd" "./examples/Bool/odd/1" - , shouldNormalize "Bool/odd" "./examples/Bool/odd/2" - , shouldNormalize "Bool/odd" "./examples/Bool/odd/3" - , shouldNormalize "Bool/or" "./examples/Bool/or/0" - , shouldNormalize "Bool/or" "./examples/Bool/or/1" - , shouldNormalize "Bool/show" "./examples/Bool/show/0" - , shouldNormalize "Bool/show" "./examples/Bool/show/1" - , shouldNormalize "Double/show" "./examples/Double/show/0" - , shouldNormalize "Double/show" "./examples/Double/show/1" - , shouldNormalize "Integer/show" "./examples/Integer/show/0" - , shouldNormalize "Integer/show" "./examples/Integer/show/1" - , shouldNormalize "Integer/toDouble" "./examples/Integer/toDouble/0" - , shouldNormalize "Integer/toDouble" "./examples/Integer/toDouble/1" - , shouldNormalize "List/all" "./examples/List/all/0" - , shouldNormalize "List/all" "./examples/List/all/1" - , shouldNormalize "List/any" "./examples/List/any/0" - , shouldNormalize "List/any" "./examples/List/any/1" - , shouldNormalize "List/build" "./examples/List/build/0" - , shouldNormalize "List/build" "./examples/List/build/1" - , shouldNormalize "List/concat" "./examples/List/concat/0" - , shouldNormalize "List/concat" "./examples/List/concat/1" - , shouldNormalize "List/concatMap" "./examples/List/concatMap/0" - , shouldNormalize "List/concatMap" "./examples/List/concatMap/1" - , shouldNormalize "List/filter" "./examples/List/filter/0" - , shouldNormalize "List/filter" "./examples/List/filter/1" - , shouldNormalize "List/fold" "./examples/List/fold/0" - , shouldNormalize "List/fold" "./examples/List/fold/1" - , shouldNormalize "List/fold" "./examples/List/fold/2" - , shouldNormalize "List/generate" "./examples/List/generate/0" - , shouldNormalize "List/generate" "./examples/List/generate/1" - , shouldNormalize "List/head" "./examples/List/head/0" - , shouldNormalize "List/head" "./examples/List/head/1" - , shouldNormalize "List/indexed" "./examples/List/indexed/0" - , shouldNormalize "List/indexed" "./examples/List/indexed/1" - , shouldNormalize "List/iterate" "./examples/List/iterate/0" - , shouldNormalize "List/iterate" "./examples/List/iterate/1" - , shouldNormalize "List/last" "./examples/List/last/0" - , shouldNormalize "List/last" "./examples/List/last/1" - , shouldNormalize "List/length" "./examples/List/length/0" - , shouldNormalize "List/length" "./examples/List/length/1" - , shouldNormalize "List/map" "./examples/List/map/0" - , shouldNormalize "List/map" "./examples/List/map/1" - , shouldNormalize "List/null" "./examples/List/null/0" - , shouldNormalize "List/null" "./examples/List/null/1" - , shouldNormalize "List/replicate" "./examples/List/replicate/0" - , shouldNormalize "List/replicate" "./examples/List/replicate/1" - , shouldNormalize "List/reverse" "./examples/List/reverse/0" - , shouldNormalize "List/reverse" "./examples/List/reverse/1" - , shouldNormalize "List/shifted" "./examples/List/shifted/0" - , shouldNormalize "List/shifted" "./examples/List/shifted/1" - , shouldNormalize "List/unzip" "./examples/List/unzip/0" - , shouldNormalize "List/unzip" "./examples/List/unzip/1" - , shouldNormalize "Natural/build" "./examples/Natural/build/0" - , shouldNormalize "Natural/build" "./examples/Natural/build/1" - , shouldNormalize "Natural/enumerate" "./examples/Natural/enumerate/0" - , shouldNormalize "Natural/enumerate" "./examples/Natural/enumerate/1" - , shouldNormalize "Natural/even" "./examples/Natural/even/0" - , shouldNormalize "Natural/even" "./examples/Natural/even/1" - , shouldNormalize "Natural/fold" "./examples/Natural/fold/0" - , shouldNormalize "Natural/fold" "./examples/Natural/fold/1" - , shouldNormalize "Natural/fold" "./examples/Natural/fold/2" - , shouldNormalize "Natural/isZero" "./examples/Natural/isZero/0" - , shouldNormalize "Natural/isZero" "./examples/Natural/isZero/1" - , shouldNormalize "Natural/odd" "./examples/Natural/odd/0" - , shouldNormalize "Natural/odd" "./examples/Natural/odd/1" - , shouldNormalize "Natural/product" "./examples/Natural/product/0" - , shouldNormalize "Natural/product" "./examples/Natural/product/1" - , shouldNormalize "Natural/show" "./examples/Natural/show/0" - , shouldNormalize "Natural/show" "./examples/Natural/show/1" - , shouldNormalize "Natural/sum" "./examples/Natural/sum/0" - , shouldNormalize "Natural/sum" "./examples/Natural/sum/1" - , shouldNormalize "Natural/toDouble" "./examples/Natural/toDouble/0" - , shouldNormalize "Natural/toDouble" "./examples/Natural/toDouble/1" - , shouldNormalize "Natural/toInteger" "./examples/Natural/toInteger/0" - , shouldNormalize "Natural/toInteger" "./examples/Natural/toInteger/1" - , shouldNormalize "Optional/all" "./examples/Optional/all/0" - , shouldNormalize "Optional/all" "./examples/Optional/all/1" - , shouldNormalize "Optional/any" "./examples/Optional/any/0" - , shouldNormalize "Optional/any" "./examples/Optional/any/1" - , shouldNormalize "Optional/build" "./examples/Optional/build/0" - , shouldNormalize "Optional/build" "./examples/Optional/build/1" - , shouldNormalize "Optional/concat" "./examples/Optional/concat/0" - , shouldNormalize "Optional/concat" "./examples/Optional/concat/1" - , shouldNormalize "Optional/concat" "./examples/Optional/concat/2" - , shouldNormalize "Optional/filter" "./examples/Optional/filter/0" - , shouldNormalize "Optional/filter" "./examples/Optional/filter/1" - , shouldNormalize "Optional/fold" "./examples/Optional/fold/0" - , shouldNormalize "Optional/fold" "./examples/Optional/fold/1" - , shouldNormalize "Optional/head" "./examples/Optional/head/0" - , shouldNormalize "Optional/head" "./examples/Optional/head/1" - , shouldNormalize "Optional/head" "./examples/Optional/head/2" - , shouldNormalize "Optional/last" "./examples/Optional/last/0" - , shouldNormalize "Optional/last" "./examples/Optional/last/1" - , shouldNormalize "Optional/last" "./examples/Optional/last/2" - , shouldNormalize "Optional/length" "./examples/Optional/length/0" - , shouldNormalize "Optional/length" "./examples/Optional/length/1" - , shouldNormalize "Optional/map" "./examples/Optional/map/0" - , shouldNormalize "Optional/map" "./examples/Optional/map/1" - , shouldNormalize "Optional/null" "./examples/Optional/null/0" - , shouldNormalize "Optional/null" "./examples/Optional/null/1" - , shouldNormalize "Optional/toList" "./examples/Optional/toList/0" - , shouldNormalize "Optional/toList" "./examples/Optional/toList/1" - , shouldNormalize "Optional/unzip" "./examples/Optional/unzip/0" - , shouldNormalize "Optional/unzip" "./examples/Optional/unzip/1" - , shouldNormalize "Text/concat" "./examples/Text/concat/0" - , shouldNormalize "Text/concat" "./examples/Text/concat/1" - , shouldNormalize "Text/concatMap" "./examples/Text/concatMap/0" - , shouldNormalize "Text/concatMap" "./examples/Text/concatMap/1" - , shouldNormalize "Text/concatMapSep" "./examples/Text/concatMapSep/0" - , shouldNormalize "Text/concatMapSep" "./examples/Text/concatMapSep/1" - , shouldNormalize "Text/concatSep" "./examples/Text/concatSep/0" - , shouldNormalize "Text/concatSep" "./examples/Text/concatSep/1" + [ shouldNormalize "Bool/and" "./success/prelude/Bool/and/0" + , shouldNormalize "Bool/and" "./success/prelude/Bool/and/1" + , shouldNormalize "Bool/build" "./success/prelude/Bool/build/0" + , shouldNormalize "Bool/build" "./success/prelude/Bool/build/1" + , shouldNormalize "Bool/even" "./success/prelude/Bool/even/0" + , shouldNormalize "Bool/even" "./success/prelude/Bool/even/1" + , shouldNormalize "Bool/even" "./success/prelude/Bool/even/2" + , shouldNormalize "Bool/even" "./success/prelude/Bool/even/3" + , shouldNormalize "Bool/fold" "./success/prelude/Bool/fold/0" + , shouldNormalize "Bool/fold" "./success/prelude/Bool/fold/1" + , shouldNormalize "Bool/not" "./success/prelude/Bool/not/0" + , shouldNormalize "Bool/not" "./success/prelude/Bool/not/1" + , shouldNormalize "Bool/odd" "./success/prelude/Bool/odd/0" + , shouldNormalize "Bool/odd" "./success/prelude/Bool/odd/1" + , shouldNormalize "Bool/odd" "./success/prelude/Bool/odd/2" + , shouldNormalize "Bool/odd" "./success/prelude/Bool/odd/3" + , shouldNormalize "Bool/or" "./success/prelude/Bool/or/0" + , shouldNormalize "Bool/or" "./success/prelude/Bool/or/1" + , shouldNormalize "Bool/show" "./success/prelude/Bool/show/0" + , shouldNormalize "Bool/show" "./success/prelude/Bool/show/1" + , shouldNormalize "Double/show" "./success/prelude/Double/show/0" + , shouldNormalize "Double/show" "./success/prelude/Double/show/1" + , shouldNormalize "Integer/show" "./success/prelude/Integer/show/0" + , shouldNormalize "Integer/show" "./success/prelude/Integer/show/1" + , shouldNormalize "Integer/toDouble" "./success/prelude/Integer/toDouble/0" + , shouldNormalize "Integer/toDouble" "./success/prelude/Integer/toDouble/1" + , shouldNormalize "List/all" "./success/prelude/List/all/0" + , shouldNormalize "List/all" "./success/prelude/List/all/1" + , shouldNormalize "List/any" "./success/prelude/List/any/0" + , shouldNormalize "List/any" "./success/prelude/List/any/1" + , shouldNormalize "List/build" "./success/prelude/List/build/0" + , shouldNormalize "List/build" "./success/prelude/List/build/1" + , shouldNormalize "List/concat" "./success/prelude/List/concat/0" + , shouldNormalize "List/concat" "./success/prelude/List/concat/1" + , shouldNormalize "List/concatMap" "./success/prelude/List/concatMap/0" + , shouldNormalize "List/concatMap" "./success/prelude/List/concatMap/1" + , shouldNormalize "List/filter" "./success/prelude/List/filter/0" + , shouldNormalize "List/filter" "./success/prelude/List/filter/1" + , shouldNormalize "List/fold" "./success/prelude/List/fold/0" + , shouldNormalize "List/fold" "./success/prelude/List/fold/1" + , shouldNormalize "List/fold" "./success/prelude/List/fold/2" + , shouldNormalize "List/generate" "./success/prelude/List/generate/0" + , shouldNormalize "List/generate" "./success/prelude/List/generate/1" + , shouldNormalize "List/head" "./success/prelude/List/head/0" + , shouldNormalize "List/head" "./success/prelude/List/head/1" + , shouldNormalize "List/indexed" "./success/prelude/List/indexed/0" + , shouldNormalize "List/indexed" "./success/prelude/List/indexed/1" + , shouldNormalize "List/iterate" "./success/prelude/List/iterate/0" + , shouldNormalize "List/iterate" "./success/prelude/List/iterate/1" + , shouldNormalize "List/last" "./success/prelude/List/last/0" + , shouldNormalize "List/last" "./success/prelude/List/last/1" + , shouldNormalize "List/length" "./success/prelude/List/length/0" + , shouldNormalize "List/length" "./success/prelude/List/length/1" + , shouldNormalize "List/map" "./success/prelude/List/map/0" + , shouldNormalize "List/map" "./success/prelude/List/map/1" + , shouldNormalize "List/null" "./success/prelude/List/null/0" + , shouldNormalize "List/null" "./success/prelude/List/null/1" + , shouldNormalize "List/replicate" "./success/prelude/List/replicate/0" + , shouldNormalize "List/replicate" "./success/prelude/List/replicate/1" + , shouldNormalize "List/reverse" "./success/prelude/List/reverse/0" + , shouldNormalize "List/reverse" "./success/prelude/List/reverse/1" + , shouldNormalize "List/shifted" "./success/prelude/List/shifted/0" + , shouldNormalize "List/shifted" "./success/prelude/List/shifted/1" + , shouldNormalize "List/unzip" "./success/prelude/List/unzip/0" + , shouldNormalize "List/unzip" "./success/prelude/List/unzip/1" + , shouldNormalize "Natural/build" "./success/prelude/Natural/build/0" + , shouldNormalize "Natural/build" "./success/prelude/Natural/build/1" + , shouldNormalize "Natural/enumerate" "./success/prelude/Natural/enumerate/0" + , shouldNormalize "Natural/enumerate" "./success/prelude/Natural/enumerate/1" + , shouldNormalize "Natural/even" "./success/prelude/Natural/even/0" + , shouldNormalize "Natural/even" "./success/prelude/Natural/even/1" + , shouldNormalize "Natural/fold" "./success/prelude/Natural/fold/0" + , shouldNormalize "Natural/fold" "./success/prelude/Natural/fold/1" + , shouldNormalize "Natural/fold" "./success/prelude/Natural/fold/2" + , shouldNormalize "Natural/isZero" "./success/prelude/Natural/isZero/0" + , shouldNormalize "Natural/isZero" "./success/prelude/Natural/isZero/1" + , shouldNormalize "Natural/odd" "./success/prelude/Natural/odd/0" + , shouldNormalize "Natural/odd" "./success/prelude/Natural/odd/1" + , shouldNormalize "Natural/product" "./success/prelude/Natural/product/0" + , shouldNormalize "Natural/product" "./success/prelude/Natural/product/1" + , shouldNormalize "Natural/show" "./success/prelude/Natural/show/0" + , shouldNormalize "Natural/show" "./success/prelude/Natural/show/1" + , shouldNormalize "Natural/sum" "./success/prelude/Natural/sum/0" + , shouldNormalize "Natural/sum" "./success/prelude/Natural/sum/1" + , shouldNormalize "Natural/toDouble" "./success/prelude/Natural/toDouble/0" + , shouldNormalize "Natural/toDouble" "./success/prelude/Natural/toDouble/1" + , shouldNormalize "Natural/toInteger" "./success/prelude/Natural/toInteger/0" + , shouldNormalize "Natural/toInteger" "./success/prelude/Natural/toInteger/1" + , shouldNormalize "Optional/all" "./success/prelude/Optional/all/0" + , shouldNormalize "Optional/all" "./success/prelude/Optional/all/1" + , shouldNormalize "Optional/any" "./success/prelude/Optional/any/0" + , shouldNormalize "Optional/any" "./success/prelude/Optional/any/1" + , shouldNormalize "Optional/build" "./success/prelude/Optional/build/0" + , shouldNormalize "Optional/build" "./success/prelude/Optional/build/1" + , shouldNormalize "Optional/concat" "./success/prelude/Optional/concat/0" + , shouldNormalize "Optional/concat" "./success/prelude/Optional/concat/1" + , shouldNormalize "Optional/concat" "./success/prelude/Optional/concat/2" + , shouldNormalize "Optional/filter" "./success/prelude/Optional/filter/0" + , shouldNormalize "Optional/filter" "./success/prelude/Optional/filter/1" + , shouldNormalize "Optional/fold" "./success/prelude/Optional/fold/0" + , shouldNormalize "Optional/fold" "./success/prelude/Optional/fold/1" + , shouldNormalize "Optional/head" "./success/prelude/Optional/head/0" + , shouldNormalize "Optional/head" "./success/prelude/Optional/head/1" + , shouldNormalize "Optional/head" "./success/prelude/Optional/head/2" + , shouldNormalize "Optional/last" "./success/prelude/Optional/last/0" + , shouldNormalize "Optional/last" "./success/prelude/Optional/last/1" + , shouldNormalize "Optional/last" "./success/prelude/Optional/last/2" + , shouldNormalize "Optional/length" "./success/prelude/Optional/length/0" + , shouldNormalize "Optional/length" "./success/prelude/Optional/length/1" + , shouldNormalize "Optional/map" "./success/prelude/Optional/map/0" + , shouldNormalize "Optional/map" "./success/prelude/Optional/map/1" + , shouldNormalize "Optional/null" "./success/prelude/Optional/null/0" + , shouldNormalize "Optional/null" "./success/prelude/Optional/null/1" + , shouldNormalize "Optional/toList" "./success/prelude/Optional/toList/0" + , shouldNormalize "Optional/toList" "./success/prelude/Optional/toList/1" + , shouldNormalize "Optional/unzip" "./success/prelude/Optional/unzip/0" + , shouldNormalize "Optional/unzip" "./success/prelude/Optional/unzip/1" + , shouldNormalize "Text/concat" "./success/prelude/Text/concat/0" + , shouldNormalize "Text/concat" "./success/prelude/Text/concat/1" + , shouldNormalize "Text/concatMap" "./success/prelude/Text/concatMap/0" + , shouldNormalize "Text/concatMap" "./success/prelude/Text/concatMap/1" + , shouldNormalize "Text/concatMapSep" "./success/prelude/Text/concatMapSep/0" + , shouldNormalize "Text/concatMapSep" "./success/prelude/Text/concatMapSep/1" + , shouldNormalize "Text/concatSep" "./success/prelude/Text/concatSep/0" + , shouldNormalize "Text/concatSep" "./success/prelude/Text/concatSep/1" ] simplifications :: TestTree simplifications = testGroup "Simplifications" - [ shouldNormalize "if/then/else" "./simplifications/ifThenElse" - , shouldNormalize "||" "./simplifications/or" - , shouldNormalize "&&" "./simplifications/and" - , shouldNormalize "==" "./simplifications/eq" - , shouldNormalize "!=" "./simplifications/ne" + [ shouldNormalize "if/then/else" "./success/simplifications/ifThenElse" + , shouldNormalize "||" "./success/simplifications/or" + , shouldNormalize "&&" "./success/simplifications/and" + , shouldNormalize "==" "./success/simplifications/eq" + , shouldNormalize "!=" "./success/simplifications/ne" ] constantFolding :: TestTree constantFolding = testGroup "folding of constants" - [ shouldNormalize "Natural/plus" "naturalPlus" - , shouldNormalize "Optional/fold" "optionalFold" - , shouldNormalize "Optional/build" "optionalBuild" - , shouldNormalize "Natural/build" "naturalBuild" + [ shouldNormalize "Natural/plus" "success/simple/naturalPlus" + , shouldNormalize "Optional/fold" "success/simple/optionalFold" + , shouldNormalize "Optional/build" "success/simple/optionalBuild" + , shouldNormalize "Natural/build" "success/simple/naturalBuild" ] conversions :: TestTree conversions = testGroup "conversions" - [ shouldNormalize "Natural/show" "naturalShow" - , shouldNormalize "Integer/show" "integerShow" - , shouldNormalize "Double/show" "doubleShow" - , shouldNormalize "Natural/toInteger" "naturalToInteger" + [ shouldNormalize "Natural/show" "success/simple/naturalShow" + , shouldNormalize "Integer/show" "success/simple/integerShow" + , shouldNormalize "Double/show" "success/simple/doubleShow" + , shouldNormalize "Natural/toInteger" "success/simple/naturalToInteger" + , shouldNormalize "Integer/toDouble" "success/simple/integerToDouble" ] customization :: TestTree @@ -212,8 +217,8 @@ simpleCustomization = testCase "simpleCustomization" $ do let tyCtx = insert "min" (Pi "_" Natural (Pi "_" Natural Natural)) empty valCtx e = case e of - (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalLit y)) -> Just (NaturalLit (min x y)) - _ -> Nothing + (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalLit y)) -> pure (Just (NaturalLit (min x y))) + _ -> pure Nothing e <- codeWith tyCtx "min (min 11 12) 8 + 1" assertNormalizesToWith valCtx e "9" @@ -224,12 +229,12 @@ wurbleType <- insert "wurble" <$> code "Natural → Integer" let tyCtx = minType . fiveorlessType . wurbleType $ empty valCtx e = case e of - (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalLit y)) -> Just (NaturalLit (min x y)) - (App (Var (V "wurble" 0)) (NaturalLit x)) -> Just - (App (Var (V "fiveorless" 0)) (NaturalPlus (NaturalLit x) (NaturalLit 2))) - (App (Var (V "fiveorless" 0)) (NaturalLit x)) -> Just - (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalPlus (NaturalLit 3) (NaturalLit 2))) - _ -> Nothing + (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalLit y)) -> pure (Just (NaturalLit (min x y))) + (App (Var (V "wurble" 0)) (NaturalLit x)) -> pure (Just + (App (Var (V "fiveorless" 0)) (NaturalPlus (NaturalLit x) (NaturalLit 2)))) + (App (Var (V "fiveorless" 0)) (NaturalLit x)) -> pure (Just + (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalPlus (NaturalLit 3) (NaturalLit 2)))) + _ -> pure Nothing e <- codeWith tyCtx "wurble 6" assertNormalizesToWith valCtx e "5" diff --git a/tests/Parser.hs b/tests/Parser.hs --- a/tests/Parser.hs +++ b/tests/Parser.hs @@ -18,145 +18,151 @@ [ Test.Tasty.testGroup "whitespace" [ shouldParse "prefix/suffix" - "./tests/parser/whitespace.dhall" + "./tests/parser/success/whitespace" , shouldParse "block comment" - "./tests/parser/blockComment.dhall" + "./tests/parser/success/blockComment" , shouldParse "nested block comment" - "./tests/parser/nestedBlockComment.dhall" + "./tests/parser/success/nestedBlockComment" , shouldParse "line comment" - "./tests/parser/lineComment.dhall" + "./tests/parser/success/lineComment" , shouldParse "Unicode comment" - "./tests/parser/unicodeComment.dhall" + "./tests/parser/success/unicodeComment" , shouldParse "whitespace buffet" - "./tests/parser/whitespaceBuffet.dhall" + "./tests/parser/success/whitespaceBuffet" ] , shouldParse "label" - "./tests/parser/label.dhall" + "./tests/parser/success/label" , shouldParse "quoted label" - "./tests/parser/quotedLabel.dhall" + "./tests/parser/success/quotedLabel" , shouldParse "double quoted string" - "./tests/parser/doubleQuotedString.dhall" + "./tests/parser/success/doubleQuotedString" , shouldParse "Unicode double quoted string" - "./tests/parser/unicodeDoubleQuotedString.dhall" + "./tests/parser/success/unicodeDoubleQuotedString" , shouldParse "escaped double quoted string" - "./tests/parser/escapedDoubleQuotedString.dhall" + "./tests/parser/success/escapedDoubleQuotedString" , shouldParse "interpolated double quoted string" - "./tests/parser/interpolatedDoubleQuotedString.dhall" + "./tests/parser/success/interpolatedDoubleQuotedString" , shouldParse "single quoted string" - "./tests/parser/singleQuotedString.dhall" + "./tests/parser/success/singleQuotedString" , shouldParse "escaped single quoted string" - "./tests/parser/escapedSingleQuotedString.dhall" + "./tests/parser/success/escapedSingleQuotedString" , shouldParse "interpolated single quoted string" - "./tests/parser/interpolatedSingleQuotedString.dhall" + "./tests/parser/success/interpolatedSingleQuotedString" , shouldParse "double" - "./tests/parser/double.dhall" + "./tests/parser/success/double" , shouldParse "natural" - "./tests/parser/natural.dhall" + "./tests/parser/success/natural" , shouldParse "identifier" - "./tests/parser/identifier.dhall" + "./tests/parser/success/identifier" , shouldParse "paths" - "./tests/parser/paths.dhall" + "./tests/parser/success/paths" , shouldParse "path termination" - "./tests/parser/pathTermination.dhall" + "./tests/parser/success/pathTermination" , shouldParse "urls" - "./tests/parser/urls.dhall" + "./tests/parser/success/urls" , shouldParse "environmentVariables" - "./tests/parser/environmentVariables.dhall" + "./tests/parser/success/environmentVariables" , shouldParse "lambda" - "./tests/parser/lambda.dhall" + "./tests/parser/success/lambda" , shouldParse "if then else" - "./tests/parser/ifThenElse.dhall" + "./tests/parser/success/ifThenElse" , shouldParse "let" - "./tests/parser/let.dhall" + "./tests/parser/success/let" , shouldParse "forall" - "./tests/parser/forall.dhall" + "./tests/parser/success/forall" , shouldParse "function type" - "./tests/parser/functionType.dhall" + "./tests/parser/success/functionType" , shouldParse "operators" - "./tests/parser/operators.dhall" + "./tests/parser/success/operators" , shouldParse "annotations" - "./tests/parser/annotations.dhall" + "./tests/parser/success/annotations" , shouldParse "merge" - "./tests/parser/merge.dhall" + "./tests/parser/success/merge" , shouldParse "constructors" - "./tests/parser/constructors.dhall" + "./tests/parser/success/constructors" , shouldParse "fields" - "./tests/parser/fields.dhall" + "./tests/parser/success/fields" , shouldParse "record" - "./tests/parser/record.dhall" + "./tests/parser/success/record" , shouldParse "union" - "./tests/parser/union.dhall" + "./tests/parser/success/union" , shouldParse "list" - "./tests/parser/list.dhall" + "./tests/parser/success/list" , shouldParse "builtins" - "./tests/parser/builtins.dhall" + "./tests/parser/success/builtins" , shouldParse "import alternatives" - "./tests/parser/importAlt.dhall" + "./tests/parser/success/importAlt" , shouldParse "large expression" - "./tests/parser/largeExpression.dhall" + "./tests/parser/success/largeExpression" , shouldParse "names that begin with reserved identifiers" - "./tests/parser/reservedPrefix.dhall" + "./tests/parser/success/reservedPrefix" , shouldParse "interpolated expressions with leading whitespace" - "./tests/parser/template.dhall" - , shouldNotParse - "records with duplicate fields" - "./tests/parser/failure/duplicateFields.dhall" + "./tests/parser/success/template" , shouldParse "collections with type annotations containing imports" - "./tests/parser/collectionImportType.dhall" + "./tests/parser/success/collectionImportType" , shouldParse "a parenthesized custom header import" - "./tests/parser/parenthesizeUsing.dhall" + "./tests/parser/success/parenthesizeUsing" , shouldNotParse "accessing a field of an import without parentheses" "./tests/parser/failure/importAccess.dhall" , shouldParse "Sort" - "./tests/parser/sort.dhall" + "./tests/parser/success/sort" + , shouldParse + "quoted path components" + "./tests/parser/success/quotedPaths" + , shouldNotParse + "positive double out of bounds" + "./tests/parser/failure/doubleBoundsPos.dhall" + , shouldNotParse + "negative double out of bounds" + "./tests/parser/failure/doubleBoundsNeg.dhall" ] shouldParse :: Text -> FilePath -> TestTree shouldParse name path = Test.Tasty.HUnit.testCase (Data.Text.unpack name) (do - text <- Data.Text.IO.readFile path + text <- Data.Text.IO.readFile (path <> "A.dhall") case Dhall.Parser.exprFromText mempty text of Left err -> Control.Exception.throwIO err Right _ -> return () ) diff --git a/tests/QuickCheck.hs b/tests/QuickCheck.hs --- a/tests/QuickCheck.hs +++ b/tests/QuickCheck.hs @@ -8,9 +8,11 @@ import Codec.Serialise (DeserialiseFailure(..)) import Control.Monad (guard) +import Data.List.NonEmpty (NonEmpty(..)) import Dhall.Map (Map) import Dhall.Core - ( Chunks(..) + ( Binding(..) + , Chunks(..) , Const(..) , Directory(..) , Expr(..) @@ -24,6 +26,7 @@ , URL(..) , Var(..) ) +import Dhall.Set (Set) import Numeric.Natural (Natural) import Test.QuickCheck (Arbitrary(..), Gen, Property, genericShrink, (===)) @@ -36,6 +39,7 @@ import qualified Data.Sequence import qualified Dhall.Binary import qualified Dhall.Core +import qualified Dhall.Set import qualified Test.QuickCheck import qualified Test.Tasty.QuickCheck @@ -46,6 +50,9 @@ D (DeserialiseFailure aL bL) == D (DeserialiseFailure aR bR) = aL == aR && bL == bR +instance (Arbitrary a, Ord a) => Arbitrary (Set a) where + arbitrary = Dhall.Set.fromList <$> arbitrary + lift0 :: a -> Gen a lift0 = pure @@ -121,6 +128,11 @@ . shrink . Dhall.Map.toList +instance (Arbitrary s, Arbitrary a) => Arbitrary (Binding s a) where + arbitrary = lift3 Binding + + shrink = genericShrink + instance (Arbitrary s, Arbitrary a) => Arbitrary (Chunks s a) where arbitrary = do n <- Test.QuickCheck.choose (0, 2) @@ -159,7 +171,13 @@ , ( 1, Test.QuickCheck.oneof [ lift2 (Lam "_"), lift3 Lam ]) , ( 1, Test.QuickCheck.oneof [ lift2 (Pi "_"), lift3 Pi ]) , ( 1, lift2 App) - , ( 1, Test.QuickCheck.oneof [ lift3 (Let "_"), lift4 Let ]) + , let letExpression = do + n <- Test.QuickCheck.choose (0, 2) + binding <- arbitrary + bindings <- Test.QuickCheck.vectorOf n arbitrary + body <- arbitrary + return (Let (binding :| bindings) body) + in ( 1, Test.QuickCheck.oneof [ letExpression ]) , ( 1, lift2 Annot) , ( 7, lift0 Bool) , ( 7, lift1 BoolLit) diff --git a/tests/TypeCheck.hs b/tests/TypeCheck.hs --- a/tests/TypeCheck.hs +++ b/tests/TypeCheck.hs @@ -21,40 +21,70 @@ typecheckTests :: TestTree typecheckTests = Test.Tasty.testGroup "typecheck tests" - [ Test.Tasty.testGroup "Prelude examples" - [ should "Monoid" "./examples/Monoid/00" - , should "Monoid" "./examples/Monoid/01" - , should "Monoid" "./examples/Monoid/02" - , should "Monoid" "./examples/Monoid/03" - , should "Monoid" "./examples/Monoid/04" - , should "Monoid" "./examples/Monoid/05" - , should "Monoid" "./examples/Monoid/06" - , should "Monoid" "./examples/Monoid/07" - , should "Monoid" "./examples/Monoid/08" - , should "Monoid" "./examples/Monoid/09" - , should "Monoid" "./examples/Monoid/10" - ] + [ preludeExamples + , accessTypeChecks , should "allow type-valued fields in a record" - "fieldsAreTypes" + "success/simple/fieldsAreTypes" , should "allow type-valued alternatives in a union" - "alternativesAreTypes" + "success/simple/alternativesAreTypes" , should "allow anonymous functions in types to be judgmentally equal" - "anonymousFunctionsInTypes" + "success/simple/anonymousFunctionsInTypes" , should "correctly handle α-equivalent merge alternatives" - "mergeEquivalence" + "success/simple/mergeEquivalence" , should "allow Kind variables" - "kindParameter" + "success/simple/kindParameter" , shouldNotTypeCheck "combining records of terms and types" "failure/combineMixedRecords" , shouldNotTypeCheck "preferring a record of types over a record of terms" "failure/preferMixedRecords" + , should + "allow records of types of mixed kinds" + "success/recordOfTypes" + , should + "allow Boehm-Berarducci-encoded records of types of mixed kinds" + "success/encodedRecordOfTypes" + , should + "allow accessing a type from a record" + "success/accessType" + , should + "allow accessing a type from a Boehm-Berarducci-encoded record" + "success/accessEncodedType" + , shouldNotTypeCheck + "Hurkens' paradox" + "failure/hurkensParadox" + , should + "allow accessing a constructor from a type stored inside a record" + "success/simple/mixedFieldAccess" + ] + +preludeExamples :: TestTree +preludeExamples = + Test.Tasty.testGroup "Prelude examples" + [ should "Monoid" "./success/prelude/Monoid/00" + , should "Monoid" "./success/prelude/Monoid/01" + , should "Monoid" "./success/prelude/Monoid/02" + , should "Monoid" "./success/prelude/Monoid/03" + , should "Monoid" "./success/prelude/Monoid/04" + , should "Monoid" "./success/prelude/Monoid/05" + , should "Monoid" "./success/prelude/Monoid/06" + , should "Monoid" "./success/prelude/Monoid/07" + , should "Monoid" "./success/prelude/Monoid/08" + , should "Monoid" "./success/prelude/Monoid/09" + , should "Monoid" "./success/prelude/Monoid/10" + ] + +accessTypeChecks :: TestTree +accessTypeChecks = + Test.Tasty.testGroup "typecheck access" + [ should "record" "./success/simple/access/0" + , should "record" "./success/simple/access/1" ] should :: Text -> Text -> TestTree diff --git a/tests/format/doubleRoundA.dhall b/tests/format/doubleRoundA.dhall new file mode 100644 --- /dev/null +++ b/tests/format/doubleRoundA.dhall @@ -0,0 +1,41 @@ +[ 1.0000000000000000 +, 1.0000000000000001 +, 1.0000000000000002 +, 1.0000000000000003 +, 1.0000000000000004 +, 1.0000000000000005 +, 1.0000000000000006 +, 1.0000000000000007 +, 1.0000000000000008 +, 1.0000000000000009 + +, 1.0000000000000000e64 +, 1.0000000000000001e64 +, 1.0000000000000002e64 +, 1.0000000000000003e64 +, 1.0000000000000004e64 +, 1.0000000000000005e64 +, 1.0000000000000006e64 +, 1.0000000000000007e64 +, 1.0000000000000008e64 +, 1.0000000000000009e64 + +, 1.0000000000000000e100 +, 1.0000000000000001e100 +, 1.0000000000000002e100 +, 1.0000000000000003e100 +, 1.0000000000000004e100 +, 1.0000000000000005e100 +, 1.0000000000000006e100 +, 1.0000000000000007e100 +, 1.0000000000000008e100 +, 1.0000000000000009e100 + +, 179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791.0 +, 179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218945.0 +, 179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944.0 + +, -179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791.0 +, -179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218945.0 +, -179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944.0 +] diff --git a/tests/format/doubleRoundB.dhall b/tests/format/doubleRoundB.dhall new file mode 100644 --- /dev/null +++ b/tests/format/doubleRoundB.dhall @@ -0,0 +1,37 @@ +[ 1.0 +, 1.0 +, 1.0000000000000002 +, 1.0000000000000002 +, 1.0000000000000004 +, 1.0000000000000004 +, 1.0000000000000007 +, 1.0000000000000007 +, 1.0000000000000009 +, 1.0000000000000009 +, 1.0e64 +, 1.0000000000000002e64 +, 1.0000000000000002e64 +, 1.0000000000000003e64 +, 1.0000000000000005e64 +, 1.0000000000000005e64 +, 1.0000000000000006e64 +, 1.0000000000000008e64 +, 1.0000000000000008e64 +, 1.0000000000000009e64 +, 1.0e100 +, 1.0e100 +, 1.0000000000000002e100 +, 1.0000000000000002e100 +, 1.0000000000000004e100 +, 1.0000000000000004e100 +, 1.0000000000000006e100 +, 1.0000000000000008e100 +, 1.0000000000000008e100 +, 1.000000000000001e100 +, 1.7976931348623157e308 +, 1.7976931348623157e308 +, 1.7976931348623155e308 +, -1.7976931348623157e308 +, -1.7976931348623157e308 +, -1.7976931348623155e308 +] diff --git a/tests/format/importLinesA.dhall b/tests/format/importLinesA.dhall --- a/tests/format/importLinesA.dhall +++ b/tests/format/importLinesA.dhall @@ -1,7 +1,7 @@ let _ = ./emptyRecordA.dhall -in let _ = ./emptyRecordA.dhall -in let _ = ./emptyRecordA.dhall -in let _ = ./emptyRecordA.dhall -in let _ = ./emptyRecordA.dhall -in let _ = ./emptyRecordA.dhall +let _ = ./emptyRecordA.dhall +let _ = ./emptyRecordA.dhall +let _ = ./emptyRecordA.dhall +let _ = ./emptyRecordA.dhall +let _ = ./emptyRecordA.dhall in 123 diff --git a/tests/format/importLinesB.dhall b/tests/format/importLinesB.dhall --- a/tests/format/importLinesB.dhall +++ b/tests/format/importLinesB.dhall @@ -1,13 +1,13 @@ - let _ = ./emptyRecordA.dhall +let _ = ./emptyRecordA.dhall -in let _ = ./emptyRecordA.dhall +let _ = ./emptyRecordA.dhall -in let _ = ./emptyRecordA.dhall +let _ = ./emptyRecordA.dhall -in let _ = ./emptyRecordA.dhall +let _ = ./emptyRecordA.dhall -in let _ = ./emptyRecordA.dhall +let _ = ./emptyRecordA.dhall -in let _ = ./emptyRecordA.dhall +let _ = ./emptyRecordA.dhall in 123 diff --git a/tests/format/largeExponentA.dhall b/tests/format/largeExponentA.dhall --- a/tests/format/largeExponentA.dhall +++ b/tests/format/largeExponentA.dhall @@ -1,1 +1,1 @@ -[ 1.0, 1e1000000000, 1e-1000000000 ] +[ 1.0, 1e100, 1e-100 ] diff --git a/tests/format/largeExponentB.dhall b/tests/format/largeExponentB.dhall --- a/tests/format/largeExponentB.dhall +++ b/tests/format/largeExponentB.dhall @@ -1,1 +1,1 @@ -[ 1.0, 1.0e1000000000, 1.0e-1000000000 ] +[ 1.0, 1.0e100, 1.0e-100 ] diff --git a/tests/format/projectionOrderA.dhall b/tests/format/projectionOrderA.dhall new file mode 100644 --- /dev/null +++ b/tests/format/projectionOrderA.dhall @@ -0,0 +1,1 @@ +e.{ foo, bar, baz } diff --git a/tests/format/projectionOrderB.dhall b/tests/format/projectionOrderB.dhall new file mode 100644 --- /dev/null +++ b/tests/format/projectionOrderB.dhall @@ -0,0 +1,1 @@ +e.{ foo, bar, baz } diff --git a/tests/format/sha256PrintingA.dhall b/tests/format/sha256PrintingA.dhall --- a/tests/format/sha256PrintingA.dhall +++ b/tests/format/sha256PrintingA.dhall @@ -1,2 +1,4 @@ let replicate = - https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate sha256:b0e3ec1797b32c80c0bcb7e8254b08c7e9e35e75e6b410c7ac21477ab90167ad in replicate 5 + https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate sha256:cc856d59b63f7699881bdb8e4b1036ca4c0013827268040a50c1e1405f646a2c + +in replicate 5 diff --git a/tests/format/sha256PrintingB.dhall b/tests/format/sha256PrintingB.dhall --- a/tests/format/sha256PrintingB.dhall +++ b/tests/format/sha256PrintingB.dhall @@ -1,4 +1,4 @@ - let replicate = - https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate sha256:b0e3ec1797b32c80c0bcb7e8254b08c7e9e35e75e6b410c7ac21477ab90167ad +let replicate = + https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate sha256:cc856d59b63f7699881bdb8e4b1036ca4c0013827268040a50c1e1405f646a2c in replicate 5 diff --git a/tests/format/unicodeA.dhall b/tests/format/unicodeA.dhall new file mode 100644 --- /dev/null +++ b/tests/format/unicodeA.dhall @@ -0,0 +1,16 @@ + λ(isActive : Bool) +→ { barLeftEnd = + [ "┨" ] : Optional Text + , barRightEnd = + [ "┠" ] : Optional Text + , separator = + [ "┃" ] : Optional Text + , alignment = + < ToTheLeft = {=} | ToTheRight : {} | Centered : {} > + : ./Alignment.dhall + , barWidth = + [] : Optional Natural + , barSegments = + [ "index", "command", "path", "title" ] + } + : ./Bar.dhall diff --git a/tests/format/unicodeB.dhall b/tests/format/unicodeB.dhall new file mode 100644 --- /dev/null +++ b/tests/format/unicodeB.dhall @@ -0,0 +1,16 @@ + λ(isActive : Bool) +→ { barLeftEnd = + [ "┨" ] : Optional Text + , barRightEnd = + [ "┠" ] : Optional Text + , separator = + [ "┃" ] : Optional Text + , alignment = + < ToTheLeft = {=} | ToTheRight : {} | Centered : {} > + : ./Alignment.dhall + , barWidth = + [] : Optional Natural + , barSegments = + [ "index", "command", "path", "title" ] + } + : ./Bar.dhall diff --git a/tests/import/alternativeEnv.dhall b/tests/import/alternativeEnv.dhall deleted file mode 100644 --- a/tests/import/alternativeEnv.dhall +++ /dev/null @@ -1,1 +0,0 @@ -env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 diff --git a/tests/import/alternativeEnvMissing.dhall b/tests/import/alternativeEnvMissing.dhall deleted file mode 100644 --- a/tests/import/alternativeEnvMissing.dhall +++ /dev/null @@ -1,1 +0,0 @@ -env:UNSET ? missing diff --git a/tests/import/alternativeEnvNatural.dhall b/tests/import/alternativeEnvNatural.dhall deleted file mode 100644 --- a/tests/import/alternativeEnvNatural.dhall +++ /dev/null @@ -1,1 +0,0 @@ -env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2 diff --git a/tests/import/alternativeEnvSimple.dhall b/tests/import/alternativeEnvSimple.dhall deleted file mode 100644 --- a/tests/import/alternativeEnvSimple.dhall +++ /dev/null @@ -1,1 +0,0 @@ -env:UNSET ? 3 diff --git a/tests/import/alternativeNatural.dhall b/tests/import/alternativeNatural.dhall deleted file mode 100644 --- a/tests/import/alternativeNatural.dhall +++ /dev/null @@ -1,1 +0,0 @@ -4 ? missing diff --git a/tests/import/data/fieldOrder/1.dhall b/tests/import/data/fieldOrder/1.dhall new file mode 100644 --- /dev/null +++ b/tests/import/data/fieldOrder/1.dhall @@ -0,0 +1,1 @@ +{ foo = 1, bar = True } diff --git a/tests/import/data/fieldOrder/2.dhall b/tests/import/data/fieldOrder/2.dhall new file mode 100644 --- /dev/null +++ b/tests/import/data/fieldOrder/2.dhall @@ -0,0 +1,1 @@ +{ bar = True, foo = 1 } diff --git a/tests/import/failure/alternativeEnv.dhall b/tests/import/failure/alternativeEnv.dhall new file mode 100644 --- /dev/null +++ b/tests/import/failure/alternativeEnv.dhall @@ -0,0 +1,1 @@ +env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 diff --git a/tests/import/failure/alternativeEnvMissing.dhall b/tests/import/failure/alternativeEnvMissing.dhall new file mode 100644 --- /dev/null +++ b/tests/import/failure/alternativeEnvMissing.dhall @@ -0,0 +1,1 @@ +env:UNSET ? missing diff --git a/tests/import/failure/missing.dhall b/tests/import/failure/missing.dhall new file mode 100644 --- /dev/null +++ b/tests/import/failure/missing.dhall @@ -0,0 +1,1 @@ +missing diff --git a/tests/import/fieldOrderA.dhall b/tests/import/fieldOrderA.dhall deleted file mode 100644 --- a/tests/import/fieldOrderA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ foo = 1, bar = True } diff --git a/tests/import/fieldOrderB.dhall b/tests/import/fieldOrderB.dhall deleted file mode 100644 --- a/tests/import/fieldOrderB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ bar = True, foo = 1 } diff --git a/tests/import/fieldOrderC.dhall b/tests/import/fieldOrderC.dhall deleted file mode 100644 --- a/tests/import/fieldOrderC.dhall +++ /dev/null @@ -1,5 +0,0 @@ -{ example0 = - ./fieldOrderA.dhall sha256:72791c3846cef2ec49baabe6a5d38ca25301ed30b45754dfa1c6b06bab8faaf6 -, example1 = - ./fieldOrderB.dhall sha256:72791c3846cef2ec49baabe6a5d38ca25301ed30b45754dfa1c6b06bab8faaf6 -} diff --git a/tests/import/issue553A.dhall b/tests/import/issue553A.dhall deleted file mode 100644 --- a/tests/import/issue553A.dhall +++ /dev/null @@ -1,5 +0,0 @@ - let T = < A : {} | B : {} > - -in let t = constructors T - -in t diff --git a/tests/import/issue553B.dhall b/tests/import/issue553B.dhall deleted file mode 100644 --- a/tests/import/issue553B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -./issue553A.dhall sha256:ef4cce5b6c440b2409f9ba86e48fb788b7ccb757569a713492654f23209cb19b diff --git a/tests/import/missing.dhall b/tests/import/missing.dhall deleted file mode 100644 --- a/tests/import/missing.dhall +++ /dev/null @@ -1,1 +0,0 @@ -missing diff --git a/tests/import/relative.dhall b/tests/import/relative.dhall deleted file mode 100644 --- a/tests/import/relative.dhall +++ /dev/null @@ -1,2 +0,0 @@ --- This file assumes its base directory is actually ./data/foo/bar/ -./a.dhall : Natural diff --git a/tests/import/success/alternativeEnvNaturalA.dhall b/tests/import/success/alternativeEnvNaturalA.dhall new file mode 100644 --- /dev/null +++ b/tests/import/success/alternativeEnvNaturalA.dhall @@ -0,0 +1,1 @@ +env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2 diff --git a/tests/import/success/alternativeEnvNaturalB.dhall b/tests/import/success/alternativeEnvNaturalB.dhall new file mode 100644 --- /dev/null +++ b/tests/import/success/alternativeEnvNaturalB.dhall @@ -0,0 +1,1 @@ +2 diff --git a/tests/import/success/alternativeEnvSimpleA.dhall b/tests/import/success/alternativeEnvSimpleA.dhall new file mode 100644 --- /dev/null +++ b/tests/import/success/alternativeEnvSimpleA.dhall @@ -0,0 +1,1 @@ +env:UNSET ? 3 diff --git a/tests/import/success/alternativeEnvSimpleB.dhall b/tests/import/success/alternativeEnvSimpleB.dhall new file mode 100644 --- /dev/null +++ b/tests/import/success/alternativeEnvSimpleB.dhall @@ -0,0 +1,1 @@ +3 diff --git a/tests/import/success/alternativeNaturalA.dhall b/tests/import/success/alternativeNaturalA.dhall new file mode 100644 --- /dev/null +++ b/tests/import/success/alternativeNaturalA.dhall @@ -0,0 +1,1 @@ +4 ? missing diff --git a/tests/import/success/alternativeNaturalB.dhall b/tests/import/success/alternativeNaturalB.dhall new file mode 100644 --- /dev/null +++ b/tests/import/success/alternativeNaturalB.dhall @@ -0,0 +1,1 @@ +4 diff --git a/tests/import/success/fieldOrderA.dhall b/tests/import/success/fieldOrderA.dhall new file mode 100644 --- /dev/null +++ b/tests/import/success/fieldOrderA.dhall @@ -0,0 +1,5 @@ +{ example0 = + ./../data/fieldOrder/1.dhall sha256:4a7866b88389e18cf481b525544fd7903325252faf3a86c8fdc981298c788a9b +, example1 = + ./../data/fieldOrder/2.dhall sha256:4a7866b88389e18cf481b525544fd7903325252faf3a86c8fdc981298c788a9b +} diff --git a/tests/import/success/fieldOrderB.dhall b/tests/import/success/fieldOrderB.dhall new file mode 100644 --- /dev/null +++ b/tests/import/success/fieldOrderB.dhall @@ -0,0 +1,1 @@ +{ example0 = { bar = True, foo = 1 }, example1 = { bar = True, foo = 1 } } diff --git a/tests/import/success/issue553A.dhall b/tests/import/success/issue553A.dhall new file mode 100644 --- /dev/null +++ b/tests/import/success/issue553A.dhall @@ -0,0 +1,5 @@ + let T = < A : {} | B : {} > + +in let t = constructors T + +in t diff --git a/tests/import/success/issue553B.dhall b/tests/import/success/issue553B.dhall new file mode 100644 --- /dev/null +++ b/tests/import/success/issue553B.dhall @@ -0,0 +1,1 @@ +./issue553A.dhall sha256:6fb582c043889dd5a4c97176f8a58d2633252b5374cb71e288b93bc3757f9643 diff --git a/tests/import/success/relative.dhall b/tests/import/success/relative.dhall new file mode 100644 --- /dev/null +++ b/tests/import/success/relative.dhall @@ -0,0 +1,2 @@ +-- This file assumes its base directory is actually ./data/foo/bar/ +./a.dhall : Natural diff --git a/tests/normalization/doubleShowA.dhall b/tests/normalization/doubleShowA.dhall deleted file mode 100644 --- a/tests/normalization/doubleShowA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ example0 = Double/show -0.42, example1 = Double/show 13.37 } diff --git a/tests/normalization/doubleShowB.dhall b/tests/normalization/doubleShowB.dhall deleted file mode 100644 --- a/tests/normalization/doubleShowB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ example0 = "-0.42", example1 = "13.37" } diff --git a/tests/normalization/examples/Bool/and/0A.dhall b/tests/normalization/examples/Bool/and/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/and/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.and [ True, False, True ] diff --git a/tests/normalization/examples/Bool/and/0B.dhall b/tests/normalization/examples/Bool/and/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/and/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Bool/and/1A.dhall b/tests/normalization/examples/Bool/and/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/and/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.and ([] : List Bool) diff --git a/tests/normalization/examples/Bool/and/1B.dhall b/tests/normalization/examples/Bool/and/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/and/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Bool/build/0A.dhall b/tests/normalization/examples/Bool/build/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/build/0A.dhall +++ /dev/null @@ -1,2 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.build -(λ(bool : Type) → λ(true : bool) → λ(false : bool) → true) diff --git a/tests/normalization/examples/Bool/build/0B.dhall b/tests/normalization/examples/Bool/build/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Bool/build/1A.dhall b/tests/normalization/examples/Bool/build/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/build/1A.dhall +++ /dev/null @@ -1,2 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.build -(λ(bool : Type) → λ(true : bool) → λ(false : bool) → false) diff --git a/tests/normalization/examples/Bool/build/1B.dhall b/tests/normalization/examples/Bool/build/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Bool/even/0A.dhall b/tests/normalization/examples/Bool/even/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/even/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.even [ False, True, False ] diff --git a/tests/normalization/examples/Bool/even/0B.dhall b/tests/normalization/examples/Bool/even/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/even/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Bool/even/1A.dhall b/tests/normalization/examples/Bool/even/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/even/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.even [ False, True ] diff --git a/tests/normalization/examples/Bool/even/1B.dhall b/tests/normalization/examples/Bool/even/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/even/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Bool/even/2A.dhall b/tests/normalization/examples/Bool/even/2A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/even/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.even [ False ] diff --git a/tests/normalization/examples/Bool/even/2B.dhall b/tests/normalization/examples/Bool/even/2B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/even/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Bool/even/3A.dhall b/tests/normalization/examples/Bool/even/3A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/even/3A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.even ([] : List Bool) diff --git a/tests/normalization/examples/Bool/even/3B.dhall b/tests/normalization/examples/Bool/even/3B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/even/3B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Bool/fold/0A.dhall b/tests/normalization/examples/Bool/fold/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/fold/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.fold True Natural 0 1 diff --git a/tests/normalization/examples/Bool/fold/0B.dhall b/tests/normalization/examples/Bool/fold/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/examples/Bool/fold/1A.dhall b/tests/normalization/examples/Bool/fold/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/fold/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.fold False Natural 0 1 diff --git a/tests/normalization/examples/Bool/fold/1B.dhall b/tests/normalization/examples/Bool/fold/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -1 diff --git a/tests/normalization/examples/Bool/not/0A.dhall b/tests/normalization/examples/Bool/not/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/not/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.not True diff --git a/tests/normalization/examples/Bool/not/0B.dhall b/tests/normalization/examples/Bool/not/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/not/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Bool/not/1A.dhall b/tests/normalization/examples/Bool/not/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/not/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.not False diff --git a/tests/normalization/examples/Bool/not/1B.dhall b/tests/normalization/examples/Bool/not/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/not/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Bool/odd/0A.dhall b/tests/normalization/examples/Bool/odd/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/odd/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.odd [ True, False, True ] diff --git a/tests/normalization/examples/Bool/odd/0B.dhall b/tests/normalization/examples/Bool/odd/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/odd/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Bool/odd/1A.dhall b/tests/normalization/examples/Bool/odd/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/odd/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.odd [ True, False ] diff --git a/tests/normalization/examples/Bool/odd/1B.dhall b/tests/normalization/examples/Bool/odd/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/odd/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Bool/odd/2A.dhall b/tests/normalization/examples/Bool/odd/2A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/odd/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.odd [ True ] diff --git a/tests/normalization/examples/Bool/odd/2B.dhall b/tests/normalization/examples/Bool/odd/2B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/odd/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Bool/odd/3A.dhall b/tests/normalization/examples/Bool/odd/3A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/odd/3A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.odd ([] : List Bool) diff --git a/tests/normalization/examples/Bool/odd/3B.dhall b/tests/normalization/examples/Bool/odd/3B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/odd/3B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Bool/or/0A.dhall b/tests/normalization/examples/Bool/or/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/or/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.or [ True, False, True ] diff --git a/tests/normalization/examples/Bool/or/0B.dhall b/tests/normalization/examples/Bool/or/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/or/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Bool/or/1A.dhall b/tests/normalization/examples/Bool/or/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/or/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.or ([] : List Bool) diff --git a/tests/normalization/examples/Bool/or/1B.dhall b/tests/normalization/examples/Bool/or/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/or/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Bool/show/0A.dhall b/tests/normalization/examples/Bool/show/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.show True diff --git a/tests/normalization/examples/Bool/show/0B.dhall b/tests/normalization/examples/Bool/show/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"True" diff --git a/tests/normalization/examples/Bool/show/1A.dhall b/tests/normalization/examples/Bool/show/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.show False diff --git a/tests/normalization/examples/Bool/show/1B.dhall b/tests/normalization/examples/Bool/show/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Bool/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"False" diff --git a/tests/normalization/examples/Double/show/0A.dhall b/tests/normalization/examples/Double/show/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Double/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Double`.show -3.1 diff --git a/tests/normalization/examples/Double/show/0B.dhall b/tests/normalization/examples/Double/show/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Double/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"-3.1" diff --git a/tests/normalization/examples/Double/show/1A.dhall b/tests/normalization/examples/Double/show/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Double/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Double`.show 0.4 diff --git a/tests/normalization/examples/Double/show/1B.dhall b/tests/normalization/examples/Double/show/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Double/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"0.4" diff --git a/tests/normalization/examples/Integer/show/0A.dhall b/tests/normalization/examples/Integer/show/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Integer/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Integer`.show -3 diff --git a/tests/normalization/examples/Integer/show/0B.dhall b/tests/normalization/examples/Integer/show/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Integer/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"-3" diff --git a/tests/normalization/examples/Integer/show/1A.dhall b/tests/normalization/examples/Integer/show/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Integer/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Integer`.show +0 diff --git a/tests/normalization/examples/Integer/show/1B.dhall b/tests/normalization/examples/Integer/show/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Integer/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"+0" diff --git a/tests/normalization/examples/Integer/toDouble/0A.dhall b/tests/normalization/examples/Integer/toDouble/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Integer/toDouble/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Integer`.toDouble -3 diff --git a/tests/normalization/examples/Integer/toDouble/0B.dhall b/tests/normalization/examples/Integer/toDouble/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Integer/toDouble/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ --3.0 diff --git a/tests/normalization/examples/Integer/toDouble/1A.dhall b/tests/normalization/examples/Integer/toDouble/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Integer/toDouble/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Integer`.toDouble +2 diff --git a/tests/normalization/examples/Integer/toDouble/1B.dhall b/tests/normalization/examples/Integer/toDouble/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Integer/toDouble/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -2.0 diff --git a/tests/normalization/examples/List/all/0A.dhall b/tests/normalization/examples/List/all/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/all/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.all Natural Natural/even [ 2, 3, 5 ] diff --git a/tests/normalization/examples/List/all/0B.dhall b/tests/normalization/examples/List/all/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/all/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/List/all/1A.dhall b/tests/normalization/examples/List/all/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/all/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.all Natural Natural/even ([] : List Natural) diff --git a/tests/normalization/examples/List/all/1B.dhall b/tests/normalization/examples/List/all/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/all/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/List/any/0A.dhall b/tests/normalization/examples/List/any/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/any/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.any Natural Natural/even [ 2, 3, 5 ] diff --git a/tests/normalization/examples/List/any/0B.dhall b/tests/normalization/examples/List/any/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/any/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/List/any/1A.dhall b/tests/normalization/examples/List/any/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/any/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.any Natural Natural/even ([] : List Natural) diff --git a/tests/normalization/examples/List/any/1B.dhall b/tests/normalization/examples/List/any/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/any/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/List/build/0A.dhall b/tests/normalization/examples/List/build/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/build/0A.dhall +++ /dev/null @@ -1,7 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.build -Text -( λ(list : Type) -→ λ(cons : Text → list → list) -→ λ(nil : list) -→ cons "ABC" (cons "DEF" nil) -) diff --git a/tests/normalization/examples/List/build/0B.dhall b/tests/normalization/examples/List/build/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ "ABC", "DEF" ] diff --git a/tests/normalization/examples/List/build/1A.dhall b/tests/normalization/examples/List/build/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/build/1A.dhall +++ /dev/null @@ -1,7 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.build -Text -( λ(list : Type) -→ λ(cons : Text → list → list) -→ λ(nil : list) -→ nil -) diff --git a/tests/normalization/examples/List/build/1B.dhall b/tests/normalization/examples/List/build/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Text diff --git a/tests/normalization/examples/List/concat/0A.dhall b/tests/normalization/examples/List/concat/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/concat/0A.dhall +++ /dev/null @@ -1,5 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.concat Natural -[ [ 0, 1, 2 ] -, [ 3, 4 ] -, [ 5, 6, 7, 8 ] -] diff --git a/tests/normalization/examples/List/concat/0B.dhall b/tests/normalization/examples/List/concat/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/concat/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 0, 1, 2, 3, 4, 5, 6, 7, 8 ] diff --git a/tests/normalization/examples/List/concat/1A.dhall b/tests/normalization/examples/List/concat/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/concat/1A.dhall +++ /dev/null @@ -1,5 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.concat Natural -[ [] : List Natural -, [] : List Natural -, [] : List Natural -] diff --git a/tests/normalization/examples/List/concat/1B.dhall b/tests/normalization/examples/List/concat/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/concat/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/examples/List/concatMap/0A.dhall b/tests/normalization/examples/List/concatMap/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/concatMap/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.concatMap Natural Natural (λ(n : Natural) → [ n, n ]) [ 2, 3, 5 ] diff --git a/tests/normalization/examples/List/concatMap/0B.dhall b/tests/normalization/examples/List/concatMap/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/concatMap/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 2, 2, 3, 3, 5, 5 ] diff --git a/tests/normalization/examples/List/concatMap/1A.dhall b/tests/normalization/examples/List/concatMap/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/concatMap/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.concatMap Natural Natural (λ(n : Natural) → [ n, n ]) ([] : List Natural) diff --git a/tests/normalization/examples/List/concatMap/1B.dhall b/tests/normalization/examples/List/concatMap/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/concatMap/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/examples/List/filter/0A.dhall b/tests/normalization/examples/List/filter/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/filter/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.filter Natural Natural/even [ 2, 3, 5 ] diff --git a/tests/normalization/examples/List/filter/0B.dhall b/tests/normalization/examples/List/filter/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/filter/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 2 ] diff --git a/tests/normalization/examples/List/filter/1A.dhall b/tests/normalization/examples/List/filter/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/filter/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.filter Natural Natural/odd [ 2, 3, 5 ] diff --git a/tests/normalization/examples/List/filter/1B.dhall b/tests/normalization/examples/List/filter/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/filter/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 3, 5 ] diff --git a/tests/normalization/examples/List/fold/0A.dhall b/tests/normalization/examples/List/fold/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/fold/0A.dhall +++ /dev/null @@ -1,6 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.fold -Natural -[ 2, 3, 5 ] -Natural -(λ(x : Natural) → λ(y : Natural) → x + y) -0 diff --git a/tests/normalization/examples/List/fold/0B.dhall b/tests/normalization/examples/List/fold/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -10 diff --git a/tests/normalization/examples/List/fold/1A.dhall b/tests/normalization/examples/List/fold/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/fold/1A.dhall +++ /dev/null @@ -1,7 +0,0 @@ - λ(nil : Natural) -→ (../../../../../Prelude/package.dhall).`List`.fold - Natural - [ 2, 3, 5 ] - Natural - (λ(x : Natural) → λ(y : Natural) → x + y) - nil diff --git a/tests/normalization/examples/List/fold/1B.dhall b/tests/normalization/examples/List/fold/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(nil : Natural) → 2 + (3 + (5 + nil)) diff --git a/tests/normalization/examples/List/fold/2A.dhall b/tests/normalization/examples/List/fold/2A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/fold/2A.dhall +++ /dev/null @@ -1,4 +0,0 @@ - λ(list : Type) -→ λ(cons : Natural → list → list) -→ λ(nil : list) -→ (../../../../../Prelude/package.dhall).`List`.fold Natural [ 2, 3, 5 ] list cons nil diff --git a/tests/normalization/examples/List/fold/2B.dhall b/tests/normalization/examples/List/fold/2B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/fold/2B.dhall +++ /dev/null @@ -1,4 +0,0 @@ - λ(list : Type) -→ λ(cons : Natural → list → list) -→ λ(nil : list) -→ cons 2 (cons 3 (cons 5 nil)) diff --git a/tests/normalization/examples/List/generate/0A.dhall b/tests/normalization/examples/List/generate/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/generate/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.generate 5 Bool Natural/even diff --git a/tests/normalization/examples/List/generate/0B.dhall b/tests/normalization/examples/List/generate/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/generate/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ True, False, True, False, True ] diff --git a/tests/normalization/examples/List/generate/1A.dhall b/tests/normalization/examples/List/generate/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/generate/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.generate 0 Bool Natural/even diff --git a/tests/normalization/examples/List/generate/1B.dhall b/tests/normalization/examples/List/generate/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/generate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Bool diff --git a/tests/normalization/examples/List/head/0A.dhall b/tests/normalization/examples/List/head/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/head/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.head Natural [ 0, 1, 2 ] diff --git a/tests/normalization/examples/List/head/0B.dhall b/tests/normalization/examples/List/head/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/head/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 0 diff --git a/tests/normalization/examples/List/head/1A.dhall b/tests/normalization/examples/List/head/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/head/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.head Natural ([] : List Natural) diff --git a/tests/normalization/examples/List/head/1B.dhall b/tests/normalization/examples/List/head/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/head/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/examples/List/indexed/0A.dhall b/tests/normalization/examples/List/indexed/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/indexed/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.indexed Bool [ True, False, True ] diff --git a/tests/normalization/examples/List/indexed/0B.dhall b/tests/normalization/examples/List/indexed/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/indexed/0B.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ { index = 0, value = True } -, { index = 1, value = False } -, { index = 2, value = True } -] diff --git a/tests/normalization/examples/List/indexed/1A.dhall b/tests/normalization/examples/List/indexed/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/indexed/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.indexed Bool ([] : List Bool) diff --git a/tests/normalization/examples/List/indexed/1B.dhall b/tests/normalization/examples/List/indexed/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/indexed/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List { index : Natural, value : Bool } diff --git a/tests/normalization/examples/List/iterate/0A.dhall b/tests/normalization/examples/List/iterate/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/iterate/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.iterate 10 Natural (λ(x : Natural) → x * 2) 1 diff --git a/tests/normalization/examples/List/iterate/0B.dhall b/tests/normalization/examples/List/iterate/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/iterate/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 ] diff --git a/tests/normalization/examples/List/iterate/1A.dhall b/tests/normalization/examples/List/iterate/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/iterate/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.iterate 0 Natural (λ(x : Natural) → x * 2) 1 diff --git a/tests/normalization/examples/List/iterate/1B.dhall b/tests/normalization/examples/List/iterate/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/iterate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/examples/List/last/0A.dhall b/tests/normalization/examples/List/last/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/last/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.last Natural [ 0, 1, 2 ] diff --git a/tests/normalization/examples/List/last/0B.dhall b/tests/normalization/examples/List/last/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/last/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 2 diff --git a/tests/normalization/examples/List/last/1A.dhall b/tests/normalization/examples/List/last/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/last/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.last Natural ([] : List Natural) diff --git a/tests/normalization/examples/List/last/1B.dhall b/tests/normalization/examples/List/last/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/last/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/examples/List/length/0A.dhall b/tests/normalization/examples/List/length/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/length/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.length Natural [ 0, 1, 2 ] diff --git a/tests/normalization/examples/List/length/0B.dhall b/tests/normalization/examples/List/length/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/length/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -3 diff --git a/tests/normalization/examples/List/length/1A.dhall b/tests/normalization/examples/List/length/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/length/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.length Natural ([] : List Natural) diff --git a/tests/normalization/examples/List/length/1B.dhall b/tests/normalization/examples/List/length/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/length/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/examples/List/map/0A.dhall b/tests/normalization/examples/List/map/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/map/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.map Natural Bool Natural/even [ 2, 3, 5 ] diff --git a/tests/normalization/examples/List/map/0B.dhall b/tests/normalization/examples/List/map/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/map/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ True, False, False ] diff --git a/tests/normalization/examples/List/map/1A.dhall b/tests/normalization/examples/List/map/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/map/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.map Natural Bool Natural/even ([] : List Natural) diff --git a/tests/normalization/examples/List/map/1B.dhall b/tests/normalization/examples/List/map/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/map/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Bool diff --git a/tests/normalization/examples/List/null/0A.dhall b/tests/normalization/examples/List/null/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/null/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.null Natural [ 0, 1, 2 ] diff --git a/tests/normalization/examples/List/null/0B.dhall b/tests/normalization/examples/List/null/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/null/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/List/null/1A.dhall b/tests/normalization/examples/List/null/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/null/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.null Natural ([] : List Natural) diff --git a/tests/normalization/examples/List/null/1B.dhall b/tests/normalization/examples/List/null/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/null/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/List/replicate/0A.dhall b/tests/normalization/examples/List/replicate/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/replicate/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.replicate 9 Natural 1 diff --git a/tests/normalization/examples/List/replicate/0B.dhall b/tests/normalization/examples/List/replicate/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/replicate/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 1, 1, 1, 1, 1, 1, 1, 1, 1 ] diff --git a/tests/normalization/examples/List/replicate/1A.dhall b/tests/normalization/examples/List/replicate/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/replicate/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.replicate 0 Natural 1 diff --git a/tests/normalization/examples/List/replicate/1B.dhall b/tests/normalization/examples/List/replicate/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/replicate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/examples/List/reverse/0A.dhall b/tests/normalization/examples/List/reverse/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/reverse/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.reverse Natural [ 0, 1, 2 ] diff --git a/tests/normalization/examples/List/reverse/0B.dhall b/tests/normalization/examples/List/reverse/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/reverse/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 2, 1, 0 ] diff --git a/tests/normalization/examples/List/reverse/1A.dhall b/tests/normalization/examples/List/reverse/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/reverse/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.reverse Natural ([] : List Natural) diff --git a/tests/normalization/examples/List/reverse/1B.dhall b/tests/normalization/examples/List/reverse/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/reverse/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/examples/List/shifted/0A.dhall b/tests/normalization/examples/List/shifted/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/shifted/0A.dhall +++ /dev/null @@ -1,15 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.shifted -Bool -[ [ { index = 0, value = True } - , { index = 1, value = True } - , { index = 2, value = False } - ] -, [ { index = 0, value = False } - , { index = 1, value = False } - ] -, [ { index = 0, value = True } - , { index = 1, value = True } - , { index = 2, value = True } - , { index = 3, value = True } - ] -] diff --git a/tests/normalization/examples/List/shifted/0B.dhall b/tests/normalization/examples/List/shifted/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/shifted/0B.dhall +++ /dev/null @@ -1,10 +0,0 @@ -[ { index = 0, value = True } -, { index = 1, value = True } -, { index = 2, value = False } -, { index = 3, value = False } -, { index = 4, value = False } -, { index = 5, value = True } -, { index = 6, value = True } -, { index = 7, value = True } -, { index = 8, value = True } -] diff --git a/tests/normalization/examples/List/shifted/1A.dhall b/tests/normalization/examples/List/shifted/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/shifted/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.shifted Bool ([] : List (List { index : Natural, value : Bool })) diff --git a/tests/normalization/examples/List/shifted/1B.dhall b/tests/normalization/examples/List/shifted/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/shifted/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List { index : Natural, value : Bool } diff --git a/tests/normalization/examples/List/unzip/0A.dhall b/tests/normalization/examples/List/unzip/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/unzip/0A.dhall +++ /dev/null @@ -1,7 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.unzip -Text -Bool -[ { _1 = "ABC", _2 = True } -, { _1 = "DEF", _2 = False } -, { _1 = "GHI", _2 = True } -] diff --git a/tests/normalization/examples/List/unzip/0B.dhall b/tests/normalization/examples/List/unzip/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/unzip/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _1 = [ "ABC", "DEF", "GHI" ], _2 = [ True, False, True ] } diff --git a/tests/normalization/examples/List/unzip/1A.dhall b/tests/normalization/examples/List/unzip/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/unzip/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.unzip Text Bool ([] : List { _1 : Text, _2 : Bool }) diff --git a/tests/normalization/examples/List/unzip/1B.dhall b/tests/normalization/examples/List/unzip/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/List/unzip/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _1 = [] : List Text, _2 = [] : List Bool } diff --git a/tests/normalization/examples/Natural/build/0A.dhall b/tests/normalization/examples/Natural/build/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/build/0A.dhall +++ /dev/null @@ -1,6 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.build -( λ(natural : Type) -→ λ(succ : natural → natural) -→ λ(zero : natural) -→ succ (succ (succ zero)) -) diff --git a/tests/normalization/examples/Natural/build/0B.dhall b/tests/normalization/examples/Natural/build/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -3 diff --git a/tests/normalization/examples/Natural/build/1A.dhall b/tests/normalization/examples/Natural/build/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/build/1A.dhall +++ /dev/null @@ -1,6 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.build -( λ(natural : Type) -→ λ(succ : natural → natural) -→ λ(zero : natural) -→ zero -) diff --git a/tests/normalization/examples/Natural/build/1B.dhall b/tests/normalization/examples/Natural/build/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/examples/Natural/enumerate/0A.dhall b/tests/normalization/examples/Natural/enumerate/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/enumerate/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.enumerate 10 diff --git a/tests/normalization/examples/Natural/enumerate/0B.dhall b/tests/normalization/examples/Natural/enumerate/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/enumerate/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] diff --git a/tests/normalization/examples/Natural/enumerate/1A.dhall b/tests/normalization/examples/Natural/enumerate/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/enumerate/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.enumerate 0 diff --git a/tests/normalization/examples/Natural/enumerate/1B.dhall b/tests/normalization/examples/Natural/enumerate/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/enumerate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/examples/Natural/even/0A.dhall b/tests/normalization/examples/Natural/even/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/even/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.even 3 diff --git a/tests/normalization/examples/Natural/even/0B.dhall b/tests/normalization/examples/Natural/even/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/even/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Natural/even/1A.dhall b/tests/normalization/examples/Natural/even/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/even/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.even 0 diff --git a/tests/normalization/examples/Natural/even/1B.dhall b/tests/normalization/examples/Natural/even/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/even/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Natural/fold/0A.dhall b/tests/normalization/examples/Natural/fold/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/fold/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.fold 3 Natural (λ(x : Natural) → 5 * x) 1 diff --git a/tests/normalization/examples/Natural/fold/0B.dhall b/tests/normalization/examples/Natural/fold/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -125 diff --git a/tests/normalization/examples/Natural/fold/1A.dhall b/tests/normalization/examples/Natural/fold/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/fold/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(zero : Natural) → (../../../../../Prelude/package.dhall).`Natural`.fold 3 Natural (λ(x : Natural) → 5 * x) zero diff --git a/tests/normalization/examples/Natural/fold/1B.dhall b/tests/normalization/examples/Natural/fold/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(zero : Natural) → 5 * (5 * (5 * zero)) diff --git a/tests/normalization/examples/Natural/fold/2A.dhall b/tests/normalization/examples/Natural/fold/2A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/fold/2A.dhall +++ /dev/null @@ -1,4 +0,0 @@ - λ(natural : Type) -→ λ(succ : natural → natural) -→ λ(zero : natural) -→ (../../../../../Prelude/package.dhall).`Natural`.fold 3 natural succ zero diff --git a/tests/normalization/examples/Natural/fold/2B.dhall b/tests/normalization/examples/Natural/fold/2B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/fold/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(natural : Type) → λ(succ : natural → natural) → λ(zero : natural) → succ (succ (succ zero)) diff --git a/tests/normalization/examples/Natural/isZero/0A.dhall b/tests/normalization/examples/Natural/isZero/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/isZero/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.isZero 2 diff --git a/tests/normalization/examples/Natural/isZero/0B.dhall b/tests/normalization/examples/Natural/isZero/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/isZero/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Natural/isZero/1A.dhall b/tests/normalization/examples/Natural/isZero/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/isZero/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.isZero 0 diff --git a/tests/normalization/examples/Natural/isZero/1B.dhall b/tests/normalization/examples/Natural/isZero/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/isZero/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Natural/odd/0A.dhall b/tests/normalization/examples/Natural/odd/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/odd/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.odd 3 diff --git a/tests/normalization/examples/Natural/odd/0B.dhall b/tests/normalization/examples/Natural/odd/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/odd/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Natural/odd/1A.dhall b/tests/normalization/examples/Natural/odd/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/odd/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.odd 0 diff --git a/tests/normalization/examples/Natural/odd/1B.dhall b/tests/normalization/examples/Natural/odd/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/odd/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Natural/product/0A.dhall b/tests/normalization/examples/Natural/product/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/product/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.product [ 2, 3, 5 ] diff --git a/tests/normalization/examples/Natural/product/0B.dhall b/tests/normalization/examples/Natural/product/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/product/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -30 diff --git a/tests/normalization/examples/Natural/product/1A.dhall b/tests/normalization/examples/Natural/product/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/product/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.product ([] : List Natural) diff --git a/tests/normalization/examples/Natural/product/1B.dhall b/tests/normalization/examples/Natural/product/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/product/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -1 diff --git a/tests/normalization/examples/Natural/show/0A.dhall b/tests/normalization/examples/Natural/show/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.show 3 diff --git a/tests/normalization/examples/Natural/show/0B.dhall b/tests/normalization/examples/Natural/show/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"3" diff --git a/tests/normalization/examples/Natural/show/1A.dhall b/tests/normalization/examples/Natural/show/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.show 0 diff --git a/tests/normalization/examples/Natural/show/1B.dhall b/tests/normalization/examples/Natural/show/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"0" diff --git a/tests/normalization/examples/Natural/sum/0A.dhall b/tests/normalization/examples/Natural/sum/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/sum/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.sum [ 2, 3, 5 ] diff --git a/tests/normalization/examples/Natural/sum/0B.dhall b/tests/normalization/examples/Natural/sum/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/sum/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -10 diff --git a/tests/normalization/examples/Natural/sum/1A.dhall b/tests/normalization/examples/Natural/sum/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/sum/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.sum ([] : List Natural) diff --git a/tests/normalization/examples/Natural/sum/1B.dhall b/tests/normalization/examples/Natural/sum/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/sum/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/examples/Natural/toDouble/0A.dhall b/tests/normalization/examples/Natural/toDouble/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/toDouble/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.toDouble 3 diff --git a/tests/normalization/examples/Natural/toDouble/0B.dhall b/tests/normalization/examples/Natural/toDouble/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/toDouble/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -3.0 diff --git a/tests/normalization/examples/Natural/toDouble/1A.dhall b/tests/normalization/examples/Natural/toDouble/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/toDouble/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.toDouble 0 diff --git a/tests/normalization/examples/Natural/toDouble/1B.dhall b/tests/normalization/examples/Natural/toDouble/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/toDouble/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0.0 diff --git a/tests/normalization/examples/Natural/toInteger/0A.dhall b/tests/normalization/examples/Natural/toInteger/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/toInteger/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.toInteger 3 diff --git a/tests/normalization/examples/Natural/toInteger/0B.dhall b/tests/normalization/examples/Natural/toInteger/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/toInteger/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -+3 diff --git a/tests/normalization/examples/Natural/toInteger/1A.dhall b/tests/normalization/examples/Natural/toInteger/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/toInteger/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.toInteger 0 diff --git a/tests/normalization/examples/Natural/toInteger/1B.dhall b/tests/normalization/examples/Natural/toInteger/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Natural/toInteger/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -+0 diff --git a/tests/normalization/examples/Optional/all/0A.dhall b/tests/normalization/examples/Optional/all/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/all/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (Some 3) diff --git a/tests/normalization/examples/Optional/all/0B.dhall b/tests/normalization/examples/Optional/all/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/all/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Optional/all/1A.dhall b/tests/normalization/examples/Optional/all/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/all/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (None Natural) diff --git a/tests/normalization/examples/Optional/all/1B.dhall b/tests/normalization/examples/Optional/all/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/all/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Optional/any/0A.dhall b/tests/normalization/examples/Optional/any/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/any/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (Some 2) diff --git a/tests/normalization/examples/Optional/any/0B.dhall b/tests/normalization/examples/Optional/any/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/any/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Optional/any/1A.dhall b/tests/normalization/examples/Optional/any/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/any/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (None Natural) diff --git a/tests/normalization/examples/Optional/any/1B.dhall b/tests/normalization/examples/Optional/any/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/any/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Optional/build/0A.dhall b/tests/normalization/examples/Optional/build/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/build/0A.dhall +++ /dev/null @@ -1,7 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.build -Natural -( λ(optional : Type) -→ λ(some : Natural → optional) -→ λ(none : optional) -→ some 1 -) diff --git a/tests/normalization/examples/Optional/build/0B.dhall b/tests/normalization/examples/Optional/build/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 1 diff --git a/tests/normalization/examples/Optional/build/1A.dhall b/tests/normalization/examples/Optional/build/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/build/1A.dhall +++ /dev/null @@ -1,7 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.build -Natural -( λ(optional : Type) -→ λ(some : Natural → optional) -→ λ(none : optional) -→ none -) diff --git a/tests/normalization/examples/Optional/build/1B.dhall b/tests/normalization/examples/Optional/build/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/examples/Optional/concat/0A.dhall b/tests/normalization/examples/Optional/concat/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/concat/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (Some 1)) diff --git a/tests/normalization/examples/Optional/concat/0B.dhall b/tests/normalization/examples/Optional/concat/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/concat/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 1 diff --git a/tests/normalization/examples/Optional/concat/1A.dhall b/tests/normalization/examples/Optional/concat/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/concat/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (None Natural)) diff --git a/tests/normalization/examples/Optional/concat/1B.dhall b/tests/normalization/examples/Optional/concat/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/concat/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/examples/Optional/concat/2A.dhall b/tests/normalization/examples/Optional/concat/2A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/concat/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.concat Natural (None (Optional Natural)) diff --git a/tests/normalization/examples/Optional/concat/2B.dhall b/tests/normalization/examples/Optional/concat/2B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/concat/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/examples/Optional/filter/0A.dhall b/tests/normalization/examples/Optional/filter/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/filter/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/even (Some 2) diff --git a/tests/normalization/examples/Optional/filter/0B.dhall b/tests/normalization/examples/Optional/filter/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/filter/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 2 diff --git a/tests/normalization/examples/Optional/filter/1A.dhall b/tests/normalization/examples/Optional/filter/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/filter/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/odd (Some 2) diff --git a/tests/normalization/examples/Optional/filter/1B.dhall b/tests/normalization/examples/Optional/filter/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/filter/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/examples/Optional/fold/0A.dhall b/tests/normalization/examples/Optional/fold/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/fold/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.fold Natural (Some 2) Natural (λ(x : Natural) → x) 0 diff --git a/tests/normalization/examples/Optional/fold/0B.dhall b/tests/normalization/examples/Optional/fold/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -2 diff --git a/tests/normalization/examples/Optional/fold/1A.dhall b/tests/normalization/examples/Optional/fold/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/fold/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.fold Natural (None Natural) Natural (λ(x : Natural) → x) 0 diff --git a/tests/normalization/examples/Optional/fold/1B.dhall b/tests/normalization/examples/Optional/fold/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/examples/Optional/head/0A.dhall b/tests/normalization/examples/Optional/head/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/head/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.head Natural [ None Natural, Some 1, Some 2 ] diff --git a/tests/normalization/examples/Optional/head/0B.dhall b/tests/normalization/examples/Optional/head/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/head/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 1 diff --git a/tests/normalization/examples/Optional/head/1A.dhall b/tests/normalization/examples/Optional/head/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/head/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.head Natural [ None Natural, None Natural ] diff --git a/tests/normalization/examples/Optional/head/1B.dhall b/tests/normalization/examples/Optional/head/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/head/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/examples/Optional/head/2A.dhall b/tests/normalization/examples/Optional/head/2A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/head/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.head Natural ([] : List (Optional Natural)) diff --git a/tests/normalization/examples/Optional/head/2B.dhall b/tests/normalization/examples/Optional/head/2B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/head/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/examples/Optional/last/0A.dhall b/tests/normalization/examples/Optional/last/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/last/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.last Natural [ None Natural, Some 1, Some 2 ] diff --git a/tests/normalization/examples/Optional/last/0B.dhall b/tests/normalization/examples/Optional/last/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/last/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 2 diff --git a/tests/normalization/examples/Optional/last/1A.dhall b/tests/normalization/examples/Optional/last/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/last/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.last Natural [ None Natural, None Natural ] diff --git a/tests/normalization/examples/Optional/last/1B.dhall b/tests/normalization/examples/Optional/last/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/last/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/examples/Optional/last/2A.dhall b/tests/normalization/examples/Optional/last/2A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/last/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.last Natural ([] : List (Optional Natural)) diff --git a/tests/normalization/examples/Optional/last/2B.dhall b/tests/normalization/examples/Optional/last/2B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/last/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/examples/Optional/length/0A.dhall b/tests/normalization/examples/Optional/length/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/length/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.length Natural (Some 2) diff --git a/tests/normalization/examples/Optional/length/0B.dhall b/tests/normalization/examples/Optional/length/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/length/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -1 diff --git a/tests/normalization/examples/Optional/length/1A.dhall b/tests/normalization/examples/Optional/length/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/length/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.length Natural (None Natural) diff --git a/tests/normalization/examples/Optional/length/1B.dhall b/tests/normalization/examples/Optional/length/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/length/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/examples/Optional/map/0A.dhall b/tests/normalization/examples/Optional/map/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/map/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (Some 3) diff --git a/tests/normalization/examples/Optional/map/0B.dhall b/tests/normalization/examples/Optional/map/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/map/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some False diff --git a/tests/normalization/examples/Optional/map/1A.dhall b/tests/normalization/examples/Optional/map/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/map/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (None Natural) diff --git a/tests/normalization/examples/Optional/map/1B.dhall b/tests/normalization/examples/Optional/map/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/map/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Bool diff --git a/tests/normalization/examples/Optional/null/0A.dhall b/tests/normalization/examples/Optional/null/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/null/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.null Natural (Some 2) diff --git a/tests/normalization/examples/Optional/null/0B.dhall b/tests/normalization/examples/Optional/null/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/null/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/examples/Optional/null/1A.dhall b/tests/normalization/examples/Optional/null/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/null/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.null Natural (None Natural) diff --git a/tests/normalization/examples/Optional/null/1B.dhall b/tests/normalization/examples/Optional/null/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/null/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/examples/Optional/toList/0A.dhall b/tests/normalization/examples/Optional/toList/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/toList/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.toList Natural (Some 1) diff --git a/tests/normalization/examples/Optional/toList/0B.dhall b/tests/normalization/examples/Optional/toList/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/toList/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 1 ] : List Natural diff --git a/tests/normalization/examples/Optional/toList/1A.dhall b/tests/normalization/examples/Optional/toList/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/toList/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.toList Natural (None Natural) diff --git a/tests/normalization/examples/Optional/toList/1B.dhall b/tests/normalization/examples/Optional/toList/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/toList/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/examples/Optional/unzip/0A.dhall b/tests/normalization/examples/Optional/unzip/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/unzip/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.unzip Text Bool (Some { _1 = "ABC", _2 = True }) diff --git a/tests/normalization/examples/Optional/unzip/0B.dhall b/tests/normalization/examples/Optional/unzip/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/unzip/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _1 = Some "ABC", _2 = Some True } diff --git a/tests/normalization/examples/Optional/unzip/1A.dhall b/tests/normalization/examples/Optional/unzip/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/unzip/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.unzip Text Bool (None { _1 : Text, _2 : Bool }) diff --git a/tests/normalization/examples/Optional/unzip/1B.dhall b/tests/normalization/examples/Optional/unzip/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Optional/unzip/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _1 = None Text, _2 = None Bool } diff --git a/tests/normalization/examples/Text/concat/0A.dhall b/tests/normalization/examples/Text/concat/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concat/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Text`.concat [ "ABC", "DEF", "GHI" ] diff --git a/tests/normalization/examples/Text/concat/0B.dhall b/tests/normalization/examples/Text/concat/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concat/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"ABCDEFGHI" diff --git a/tests/normalization/examples/Text/concat/1A.dhall b/tests/normalization/examples/Text/concat/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concat/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Text`.concat ([] : List Text) diff --git a/tests/normalization/examples/Text/concat/1B.dhall b/tests/normalization/examples/Text/concat/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concat/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"" diff --git a/tests/normalization/examples/Text/concatMap/0A.dhall b/tests/normalization/examples/Text/concatMap/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatMap/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Text`.concatMap Natural (λ(n : Natural) → "${Natural/show n} ") [ 0, 1, 2 ] diff --git a/tests/normalization/examples/Text/concatMap/0B.dhall b/tests/normalization/examples/Text/concatMap/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatMap/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"0 1 2 " diff --git a/tests/normalization/examples/Text/concatMap/1A.dhall b/tests/normalization/examples/Text/concatMap/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatMap/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Text`.concatMap Natural (λ(n : Natural) → "${Natural/show n} ") ([] : List Natural) diff --git a/tests/normalization/examples/Text/concatMap/1B.dhall b/tests/normalization/examples/Text/concatMap/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatMap/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"" diff --git a/tests/normalization/examples/Text/concatMapSep/0A.dhall b/tests/normalization/examples/Text/concatMapSep/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatMapSep/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show [ 0, 1, 2 ] diff --git a/tests/normalization/examples/Text/concatMapSep/0B.dhall b/tests/normalization/examples/Text/concatMapSep/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatMapSep/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"0, 1, 2" diff --git a/tests/normalization/examples/Text/concatMapSep/1A.dhall b/tests/normalization/examples/Text/concatMapSep/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatMapSep/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show ([] : List Natural) diff --git a/tests/normalization/examples/Text/concatMapSep/1B.dhall b/tests/normalization/examples/Text/concatMapSep/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatMapSep/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"" diff --git a/tests/normalization/examples/Text/concatSep/0A.dhall b/tests/normalization/examples/Text/concatSep/0A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatSep/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Text`.concatSep ", " [ "ABC", "DEF", "GHI" ] diff --git a/tests/normalization/examples/Text/concatSep/0B.dhall b/tests/normalization/examples/Text/concatSep/0B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatSep/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"ABC, DEF, GHI" diff --git a/tests/normalization/examples/Text/concatSep/1A.dhall b/tests/normalization/examples/Text/concatSep/1A.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatSep/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Text`.concatSep ", " ([] : List Text) diff --git a/tests/normalization/examples/Text/concatSep/1B.dhall b/tests/normalization/examples/Text/concatSep/1B.dhall deleted file mode 100644 --- a/tests/normalization/examples/Text/concatSep/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"" diff --git a/tests/normalization/integerShowA.dhall b/tests/normalization/integerShowA.dhall deleted file mode 100644 --- a/tests/normalization/integerShowA.dhall +++ /dev/null @@ -1,4 +0,0 @@ -{ example0 = Integer/show +1337 -, example1 = Integer/show -42 -, example2 = Integer/show +0 -} diff --git a/tests/normalization/integerShowB.dhall b/tests/normalization/integerShowB.dhall deleted file mode 100644 --- a/tests/normalization/integerShowB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ example0 = "+1337", example1 = "-42", example2 = "+0" } diff --git a/tests/normalization/listBuildA.dhall b/tests/normalization/listBuildA.dhall deleted file mode 100644 --- a/tests/normalization/listBuildA.dhall +++ /dev/null @@ -1,22 +0,0 @@ -{ example0 = - List/build - Bool - ( λ(list : Type) - → λ(cons : Bool → list → list) - → λ(nil : list) - → cons True (cons False nil) - ) -, example1 = - List/build - Bool - (λ(x : Type) → λ(x : Bool → x → x) → λ(x : x@1) → x@1 True (x@1 False x)) -, example2 = - λ(id : ∀(a : Type) → a → a) - → List/build - Bool - ( λ(list : Type) - → λ(cons : Bool → list → list) - → λ(nil : list) - → id list (cons True (cons False nil)) - ) -} diff --git a/tests/normalization/listBuildB.dhall b/tests/normalization/listBuildB.dhall deleted file mode 100644 --- a/tests/normalization/listBuildB.dhall +++ /dev/null @@ -1,7 +0,0 @@ -{ example0 = - [ True, False ] : List Bool -, example1 = - [ True, False ] : List Bool -, example2 = - λ(id : ∀(a : Type) → a → a) → id (List Bool) [ True, False ] -} diff --git a/tests/normalization/multiLineA.dhall b/tests/normalization/multiLineA.dhall deleted file mode 100644 --- a/tests/normalization/multiLineA.dhall +++ /dev/null @@ -1,4 +0,0 @@ -'' - foo -bar -'' diff --git a/tests/normalization/multiLineB.dhall b/tests/normalization/multiLineB.dhall deleted file mode 100644 --- a/tests/normalization/multiLineB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -'' - foo -bar -'' diff --git a/tests/normalization/naturalBuildA.dhall b/tests/normalization/naturalBuildA.dhall deleted file mode 100644 --- a/tests/normalization/naturalBuildA.dhall +++ /dev/null @@ -1,18 +0,0 @@ -{ example0 = - Natural/build - ( λ(natural : Type) - → λ(succ : natural → natural) - → λ(zero : natural) - → succ zero - ) -, example1 = - Natural/build (λ(x : Type) → λ(x : x → x) → λ(x : x@1) → x@1 x) -, example2 = - λ(id : ∀(a : Type) → a → a) - → Natural/build - ( λ(natural : Type) - → λ(succ : natural → natural) - → λ(zero : natural) - → id natural (succ zero) - ) -} diff --git a/tests/normalization/naturalBuildB.dhall b/tests/normalization/naturalBuildB.dhall deleted file mode 100644 --- a/tests/normalization/naturalBuildB.dhall +++ /dev/null @@ -1,7 +0,0 @@ -{ example0 = - 1 -, example1 = - 1 -, example2 = - λ(id : ∀(a : Type) → a → a) → id Natural 1 -} diff --git a/tests/normalization/naturalPlusA.dhall b/tests/normalization/naturalPlusA.dhall deleted file mode 100644 --- a/tests/normalization/naturalPlusA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -1 + 2 diff --git a/tests/normalization/naturalPlusB.dhall b/tests/normalization/naturalPlusB.dhall deleted file mode 100644 --- a/tests/normalization/naturalPlusB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -3 diff --git a/tests/normalization/naturalShowA.dhall b/tests/normalization/naturalShowA.dhall deleted file mode 100644 --- a/tests/normalization/naturalShowA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural/show 42 diff --git a/tests/normalization/naturalShowB.dhall b/tests/normalization/naturalShowB.dhall deleted file mode 100644 --- a/tests/normalization/naturalShowB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"42" diff --git a/tests/normalization/naturalToIntegerA.dhall b/tests/normalization/naturalToIntegerA.dhall deleted file mode 100644 --- a/tests/normalization/naturalToIntegerA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural/toInteger 1 diff --git a/tests/normalization/naturalToIntegerB.dhall b/tests/normalization/naturalToIntegerB.dhall deleted file mode 100644 --- a/tests/normalization/naturalToIntegerB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -+1 diff --git a/tests/normalization/optionalBuildA.dhall b/tests/normalization/optionalBuildA.dhall deleted file mode 100644 --- a/tests/normalization/optionalBuildA.dhall +++ /dev/null @@ -1,32 +0,0 @@ -{ example0 = - Optional/build - Natural - ( λ(optional : Type) - → λ(just : Natural → optional) - → λ(nothing : optional) - → just 1 - ) -, example1 = - Optional/build - Integer - (λ(optional : Type) → λ(x : Integer → optional) → λ(x : optional) → x@1 +1) -, example2 = - λ(id : ∀(a : Type) → a → a) - → Optional/build - Bool - ( λ(optional : Type) - → λ(just : Bool → optional) - → λ(nothing : optional) - → id optional (just True) - ) -, example3 = - λ(a : Type) - → λ(x : a) - → Optional/build - a - ( λ(optional : Type) - → λ(just : a → optional) - → λ(nothing : optional) - → just x - ) -} diff --git a/tests/normalization/optionalBuildB.dhall b/tests/normalization/optionalBuildB.dhall deleted file mode 100644 --- a/tests/normalization/optionalBuildB.dhall +++ /dev/null @@ -1,9 +0,0 @@ -{ example0 = - [ 1 ] : Optional Natural -, example1 = - [ +1 ] : Optional Integer -, example2 = - λ(id : ∀(a : Type) → a → a) → id (Optional Bool) ([ True ] : Optional Bool) -, example3 = - λ(a : Type) → λ(x : a) → [ x ] : Optional a -} diff --git a/tests/normalization/optionalBuildFoldA.dhall b/tests/normalization/optionalBuildFoldA.dhall deleted file mode 100644 --- a/tests/normalization/optionalBuildFoldA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional/build Text (Optional/fold Text ([ "foo" ] : Optional Text)) diff --git a/tests/normalization/optionalBuildFoldB.dhall b/tests/normalization/optionalBuildFoldB.dhall deleted file mode 100644 --- a/tests/normalization/optionalBuildFoldB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ "foo" ] : Optional Text diff --git a/tests/normalization/optionalFoldA.dhall b/tests/normalization/optionalFoldA.dhall deleted file mode 100644 --- a/tests/normalization/optionalFoldA.dhall +++ /dev/null @@ -1,7 +0,0 @@ - let f = - λ(o : Optional Text) - → Optional/fold Text o Natural (λ(j : Text) → 1) 2 - -in { example0 = f ([ "foo" ] : Optional Text) - , example1 = f ([] : Optional Text) - } diff --git a/tests/normalization/optionalFoldB.dhall b/tests/normalization/optionalFoldB.dhall deleted file mode 100644 --- a/tests/normalization/optionalFoldB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ example0 = 1, example1 = 2 } diff --git a/tests/normalization/remoteSystemsA.dhall b/tests/normalization/remoteSystemsA.dhall deleted file mode 100644 --- a/tests/normalization/remoteSystemsA.dhall +++ /dev/null @@ -1,55 +0,0 @@ - let Text/concatMap = -( ../../Prelude/package.dhall).`Text`.concatMap - -in let Text/concatSep = -( ../../Prelude/package.dhall).`Text`.concatSep - -in let Row = - { cores : - Natural - , host : - Text - , key : - Text - , mandatoryFeatures : - List Text - , platforms : - List Text - , speedFactor : - Natural - , supportedFeatures : - List Text - , user : - Optional Text - } - -in let renderRow = - λ ( row - : Row - ) - → let host = - Optional/fold - Text - row.user - Text - (λ(user : Text) → "${user}@${row.host}") - row.host - - in let platforms = Text/concatSep "," row.platforms - - in let key = row.key - - in let cores = Integer/show (Natural/toInteger row.cores) - - in let speedFactor = - Integer/show (Natural/toInteger row.speedFactor) - - in let supportedFeatures = Text/concatSep "," row.supportedFeatures - - in let mandatoryFeatures = Text/concatSep "," row.mandatoryFeatures - - in '' - ${host} ${platforms} ${key} ${cores} ${speedFactor} ${supportedFeatures} ${mandatoryFeatures} - '' - -in Text/concatMap Row renderRow diff --git a/tests/normalization/remoteSystemsB.dhall b/tests/normalization/remoteSystemsB.dhall deleted file mode 100644 --- a/tests/normalization/remoteSystemsB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(xs : List { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text }) → List/fold { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text } xs Text (λ(x : { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text }) → λ(y : Text) → "${Optional/fold Text x.user Text (λ(user : Text) → "${user}@${x.host}") x.host} ${merge { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } (List/fold Text x.platforms < Empty : {} | NonEmpty : Text > (λ(element : Text) → λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → < NonEmpty = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : 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 = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : Text} ${merge { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } (List/fold Text x.mandatoryFeatures < Empty : {} | NonEmpty : Text > (λ(element : Text) → λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → < NonEmpty = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : Text}\n" ++ y) "" diff --git a/tests/normalization/simplifications/andA.dhall b/tests/normalization/simplifications/andA.dhall deleted file mode 100644 --- a/tests/normalization/simplifications/andA.dhall +++ /dev/null @@ -1,6 +0,0 @@ -{ example0 = λ(x : Bool) → x && True -, example1 = λ(x : Bool) → True && x -, example2 = λ(x : Bool) → x && False -, example3 = λ(x : Bool) → False && x -, example4 = λ(x : Bool) → x && x -} diff --git a/tests/normalization/simplifications/andB.dhall b/tests/normalization/simplifications/andB.dhall deleted file mode 100644 --- a/tests/normalization/simplifications/andB.dhall +++ /dev/null @@ -1,6 +0,0 @@ -{ example0 = λ(x : Bool) → x -, example1 = λ(x : Bool) → x -, example2 = λ(x : Bool) → False -, example3 = λ(x : Bool) → False -, example4 = λ(x : Bool) → x -} diff --git a/tests/normalization/simplifications/eqA.dhall b/tests/normalization/simplifications/eqA.dhall deleted file mode 100644 --- a/tests/normalization/simplifications/eqA.dhall +++ /dev/null @@ -1,4 +0,0 @@ -{ example0 = λ(x : Bool) → x == True -, example1 = λ(x : Bool) → True == x -, example2 = λ(x : Bool) → x == x -} diff --git a/tests/normalization/simplifications/eqB.dhall b/tests/normalization/simplifications/eqB.dhall deleted file mode 100644 --- a/tests/normalization/simplifications/eqB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -{ example0 = λ(x : Bool) → x -, example1 = λ(x : Bool) → x -, example2 = λ(x : Bool) → True -} diff --git a/tests/normalization/simplifications/ifThenElseA.dhall b/tests/normalization/simplifications/ifThenElseA.dhall deleted file mode 100644 --- a/tests/normalization/simplifications/ifThenElseA.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{ example0 = λ(x : Bool) → if x then True else False -, example1 = λ(x : Bool) → λ(y : Text) → if x then y else y -} diff --git a/tests/normalization/simplifications/ifThenElseB.dhall b/tests/normalization/simplifications/ifThenElseB.dhall deleted file mode 100644 --- a/tests/normalization/simplifications/ifThenElseB.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{ example0 = λ(x : Bool) → x -, example1 = λ(x : Bool) → λ(y : Text) → y -} diff --git a/tests/normalization/simplifications/neA.dhall b/tests/normalization/simplifications/neA.dhall deleted file mode 100644 --- a/tests/normalization/simplifications/neA.dhall +++ /dev/null @@ -1,4 +0,0 @@ -{ example0 = λ(x : Bool) → x != False -, example1 = λ(x : Bool) → False != x -, example2 = λ(x : Bool) → x != x -} diff --git a/tests/normalization/simplifications/neB.dhall b/tests/normalization/simplifications/neB.dhall deleted file mode 100644 --- a/tests/normalization/simplifications/neB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -{ example0 = λ(x : Bool) → x -, example1 = λ(x : Bool) → x -, example2 = λ(x : Bool) → False -} diff --git a/tests/normalization/simplifications/orA.dhall b/tests/normalization/simplifications/orA.dhall deleted file mode 100644 --- a/tests/normalization/simplifications/orA.dhall +++ /dev/null @@ -1,6 +0,0 @@ -{ example0 = λ(x : Bool) → x || True -, example1 = λ(x : Bool) → True || x -, example2 = λ(x : Bool) → x || False -, example3 = λ(x : Bool) → False || x -, example4 = λ(x : Bool) → x || x -} diff --git a/tests/normalization/simplifications/orB.dhall b/tests/normalization/simplifications/orB.dhall deleted file mode 100644 --- a/tests/normalization/simplifications/orB.dhall +++ /dev/null @@ -1,6 +0,0 @@ -{ example0 = λ(x : Bool) → True -, example1 = λ(x : Bool) → True -, example2 = λ(x : Bool) → x -, example3 = λ(x : Bool) → x -, example4 = λ(x : Bool) → x -} diff --git a/tests/normalization/sortOperatorA.dhall b/tests/normalization/sortOperatorA.dhall deleted file mode 100644 --- a/tests/normalization/sortOperatorA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ b = 2 } // { a = 1 } diff --git a/tests/normalization/sortOperatorB.dhall b/tests/normalization/sortOperatorB.dhall deleted file mode 100644 --- a/tests/normalization/sortOperatorB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ a = 1, b = 2 } diff --git a/tests/normalization/success/haskell-tutorial/access/0A.dhall b/tests/normalization/success/haskell-tutorial/access/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/access/0A.dhall @@ -0,0 +1,1 @@ +{ x = "foo" }.x diff --git a/tests/normalization/success/haskell-tutorial/access/0B.dhall b/tests/normalization/success/haskell-tutorial/access/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/access/0B.dhall @@ -0,0 +1,1 @@ +"foo" diff --git a/tests/normalization/success/haskell-tutorial/access/1A.dhall b/tests/normalization/success/haskell-tutorial/access/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/access/1A.dhall @@ -0,0 +1,1 @@ +< Foo : Text | Bar : Natural >.Foo diff --git a/tests/normalization/success/haskell-tutorial/access/1B.dhall b/tests/normalization/success/haskell-tutorial/access/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/access/1B.dhall @@ -0,0 +1,1 @@ +λ(Foo : Text) → < Foo = Foo | Bar : Natural > diff --git a/tests/normalization/success/haskell-tutorial/combineTypes/0A.dhall b/tests/normalization/success/haskell-tutorial/combineTypes/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/combineTypes/0A.dhall @@ -0,0 +1,1 @@ +{ foo : { bar : Text } } ⩓ { foo : { baz : Bool }, qux : Integer } diff --git a/tests/normalization/success/haskell-tutorial/combineTypes/0B.dhall b/tests/normalization/success/haskell-tutorial/combineTypes/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/combineTypes/0B.dhall @@ -0,0 +1,1 @@ +{ foo : { bar : Text, baz : Bool }, qux : Integer } diff --git a/tests/normalization/success/haskell-tutorial/combineTypes/1A.dhall b/tests/normalization/success/haskell-tutorial/combineTypes/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/combineTypes/1A.dhall @@ -0,0 +1,1 @@ +{ foo : { bar : Text } } //\\ { foo : { baz : Bool }, qux : Integer } diff --git a/tests/normalization/success/haskell-tutorial/combineTypes/1B.dhall b/tests/normalization/success/haskell-tutorial/combineTypes/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/combineTypes/1B.dhall @@ -0,0 +1,1 @@ +{ foo : { bar : Text, baz : Bool }, qux : Integer } diff --git a/tests/normalization/success/haskell-tutorial/prefer/0A.dhall b/tests/normalization/success/haskell-tutorial/prefer/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/prefer/0A.dhall @@ -0,0 +1,1 @@ +{ foo = 1, bar = "ABC" } // { baz = True } diff --git a/tests/normalization/success/haskell-tutorial/prefer/0B.dhall b/tests/normalization/success/haskell-tutorial/prefer/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/prefer/0B.dhall @@ -0,0 +1,1 @@ +{ bar = "ABC", baz = True, foo = 1 } diff --git a/tests/normalization/success/haskell-tutorial/projection/0A.dhall b/tests/normalization/success/haskell-tutorial/projection/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/projection/0A.dhall @@ -0,0 +1,1 @@ +{ x = 1, y = True, z = "ABC" }.{ x, y } diff --git a/tests/normalization/success/haskell-tutorial/projection/0B.dhall b/tests/normalization/success/haskell-tutorial/projection/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/haskell-tutorial/projection/0B.dhall @@ -0,0 +1,1 @@ +{ x = 1, y = True } diff --git a/tests/normalization/success/prelude/Bool/and/0A.dhall b/tests/normalization/success/prelude/Bool/and/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/and/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.and [ True, False, True ] diff --git a/tests/normalization/success/prelude/Bool/and/0B.dhall b/tests/normalization/success/prelude/Bool/and/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/and/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Bool/and/1A.dhall b/tests/normalization/success/prelude/Bool/and/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/and/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.and ([] : List Bool) diff --git a/tests/normalization/success/prelude/Bool/and/1B.dhall b/tests/normalization/success/prelude/Bool/and/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/and/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Bool/build/0A.dhall b/tests/normalization/success/prelude/Bool/build/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/build/0A.dhall @@ -0,0 +1,2 @@ +(../../../../../../Prelude/package.dhall).`Bool`.build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → true) diff --git a/tests/normalization/success/prelude/Bool/build/0B.dhall b/tests/normalization/success/prelude/Bool/build/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/build/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Bool/build/1A.dhall b/tests/normalization/success/prelude/Bool/build/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/build/1A.dhall @@ -0,0 +1,2 @@ +(../../../../../../Prelude/package.dhall).`Bool`.build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → false) diff --git a/tests/normalization/success/prelude/Bool/build/1B.dhall b/tests/normalization/success/prelude/Bool/build/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/build/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Bool/even/0A.dhall b/tests/normalization/success/prelude/Bool/even/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/even/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.even [ False, True, False ] diff --git a/tests/normalization/success/prelude/Bool/even/0B.dhall b/tests/normalization/success/prelude/Bool/even/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/even/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Bool/even/1A.dhall b/tests/normalization/success/prelude/Bool/even/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/even/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.even [ False, True ] diff --git a/tests/normalization/success/prelude/Bool/even/1B.dhall b/tests/normalization/success/prelude/Bool/even/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/even/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Bool/even/2A.dhall b/tests/normalization/success/prelude/Bool/even/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/even/2A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.even [ False ] diff --git a/tests/normalization/success/prelude/Bool/even/2B.dhall b/tests/normalization/success/prelude/Bool/even/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/even/2B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Bool/even/3A.dhall b/tests/normalization/success/prelude/Bool/even/3A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/even/3A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.even ([] : List Bool) diff --git a/tests/normalization/success/prelude/Bool/even/3B.dhall b/tests/normalization/success/prelude/Bool/even/3B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/even/3B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Bool/fold/0A.dhall b/tests/normalization/success/prelude/Bool/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/fold/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.fold True Natural 0 1 diff --git a/tests/normalization/success/prelude/Bool/fold/0B.dhall b/tests/normalization/success/prelude/Bool/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/fold/0B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/tests/normalization/success/prelude/Bool/fold/1A.dhall b/tests/normalization/success/prelude/Bool/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/fold/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.fold False Natural 0 1 diff --git a/tests/normalization/success/prelude/Bool/fold/1B.dhall b/tests/normalization/success/prelude/Bool/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/fold/1B.dhall @@ -0,0 +1,1 @@ +1 diff --git a/tests/normalization/success/prelude/Bool/not/0A.dhall b/tests/normalization/success/prelude/Bool/not/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/not/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.not True diff --git a/tests/normalization/success/prelude/Bool/not/0B.dhall b/tests/normalization/success/prelude/Bool/not/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/not/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Bool/not/1A.dhall b/tests/normalization/success/prelude/Bool/not/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/not/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.not False diff --git a/tests/normalization/success/prelude/Bool/not/1B.dhall b/tests/normalization/success/prelude/Bool/not/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/not/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Bool/odd/0A.dhall b/tests/normalization/success/prelude/Bool/odd/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/odd/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.odd [ True, False, True ] diff --git a/tests/normalization/success/prelude/Bool/odd/0B.dhall b/tests/normalization/success/prelude/Bool/odd/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/odd/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Bool/odd/1A.dhall b/tests/normalization/success/prelude/Bool/odd/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/odd/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.odd [ True, False ] diff --git a/tests/normalization/success/prelude/Bool/odd/1B.dhall b/tests/normalization/success/prelude/Bool/odd/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/odd/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Bool/odd/2A.dhall b/tests/normalization/success/prelude/Bool/odd/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/odd/2A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.odd [ True ] diff --git a/tests/normalization/success/prelude/Bool/odd/2B.dhall b/tests/normalization/success/prelude/Bool/odd/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/odd/2B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Bool/odd/3A.dhall b/tests/normalization/success/prelude/Bool/odd/3A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/odd/3A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.odd ([] : List Bool) diff --git a/tests/normalization/success/prelude/Bool/odd/3B.dhall b/tests/normalization/success/prelude/Bool/odd/3B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/odd/3B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Bool/or/0A.dhall b/tests/normalization/success/prelude/Bool/or/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/or/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.or [ True, False, True ] diff --git a/tests/normalization/success/prelude/Bool/or/0B.dhall b/tests/normalization/success/prelude/Bool/or/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/or/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Bool/or/1A.dhall b/tests/normalization/success/prelude/Bool/or/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/or/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.or ([] : List Bool) diff --git a/tests/normalization/success/prelude/Bool/or/1B.dhall b/tests/normalization/success/prelude/Bool/or/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/or/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Bool/show/0A.dhall b/tests/normalization/success/prelude/Bool/show/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/show/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.show True diff --git a/tests/normalization/success/prelude/Bool/show/0B.dhall b/tests/normalization/success/prelude/Bool/show/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/show/0B.dhall @@ -0,0 +1,1 @@ +"True" diff --git a/tests/normalization/success/prelude/Bool/show/1A.dhall b/tests/normalization/success/prelude/Bool/show/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/show/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.show False diff --git a/tests/normalization/success/prelude/Bool/show/1B.dhall b/tests/normalization/success/prelude/Bool/show/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Bool/show/1B.dhall @@ -0,0 +1,1 @@ +"False" diff --git a/tests/normalization/success/prelude/Double/show/0A.dhall b/tests/normalization/success/prelude/Double/show/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Double/show/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Double`.show -3.1 diff --git a/tests/normalization/success/prelude/Double/show/0B.dhall b/tests/normalization/success/prelude/Double/show/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Double/show/0B.dhall @@ -0,0 +1,1 @@ +"-3.1" diff --git a/tests/normalization/success/prelude/Double/show/1A.dhall b/tests/normalization/success/prelude/Double/show/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Double/show/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Double`.show 0.4 diff --git a/tests/normalization/success/prelude/Double/show/1B.dhall b/tests/normalization/success/prelude/Double/show/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Double/show/1B.dhall @@ -0,0 +1,1 @@ +"0.4" diff --git a/tests/normalization/success/prelude/Integer/show/0A.dhall b/tests/normalization/success/prelude/Integer/show/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Integer/show/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Integer`.show -3 diff --git a/tests/normalization/success/prelude/Integer/show/0B.dhall b/tests/normalization/success/prelude/Integer/show/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Integer/show/0B.dhall @@ -0,0 +1,1 @@ +"-3" diff --git a/tests/normalization/success/prelude/Integer/show/1A.dhall b/tests/normalization/success/prelude/Integer/show/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Integer/show/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Integer`.show +0 diff --git a/tests/normalization/success/prelude/Integer/show/1B.dhall b/tests/normalization/success/prelude/Integer/show/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Integer/show/1B.dhall @@ -0,0 +1,1 @@ +"+0" diff --git a/tests/normalization/success/prelude/Integer/toDouble/0A.dhall b/tests/normalization/success/prelude/Integer/toDouble/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Integer/toDouble/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Integer`.toDouble -3 diff --git a/tests/normalization/success/prelude/Integer/toDouble/0B.dhall b/tests/normalization/success/prelude/Integer/toDouble/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Integer/toDouble/0B.dhall @@ -0,0 +1,1 @@ +-3.0 diff --git a/tests/normalization/success/prelude/Integer/toDouble/1A.dhall b/tests/normalization/success/prelude/Integer/toDouble/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Integer/toDouble/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Integer`.toDouble +2 diff --git a/tests/normalization/success/prelude/Integer/toDouble/1B.dhall b/tests/normalization/success/prelude/Integer/toDouble/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Integer/toDouble/1B.dhall @@ -0,0 +1,1 @@ +2.0 diff --git a/tests/normalization/success/prelude/List/all/0A.dhall b/tests/normalization/success/prelude/List/all/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/all/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.all Natural Natural/even [ 2, 3, 5 ] diff --git a/tests/normalization/success/prelude/List/all/0B.dhall b/tests/normalization/success/prelude/List/all/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/all/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/List/all/1A.dhall b/tests/normalization/success/prelude/List/all/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/all/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.all Natural Natural/even ([] : List Natural) diff --git a/tests/normalization/success/prelude/List/all/1B.dhall b/tests/normalization/success/prelude/List/all/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/all/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/List/any/0A.dhall b/tests/normalization/success/prelude/List/any/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/any/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.any Natural Natural/even [ 2, 3, 5 ] diff --git a/tests/normalization/success/prelude/List/any/0B.dhall b/tests/normalization/success/prelude/List/any/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/any/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/List/any/1A.dhall b/tests/normalization/success/prelude/List/any/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/any/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.any Natural Natural/even ([] : List Natural) diff --git a/tests/normalization/success/prelude/List/any/1B.dhall b/tests/normalization/success/prelude/List/any/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/any/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/List/build/0A.dhall b/tests/normalization/success/prelude/List/build/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/build/0A.dhall @@ -0,0 +1,7 @@ +(../../../../../../Prelude/package.dhall).`List`.build +Text +( λ(list : Type) +→ λ(cons : Text → list → list) +→ λ(nil : list) +→ cons "ABC" (cons "DEF" nil) +) diff --git a/tests/normalization/success/prelude/List/build/0B.dhall b/tests/normalization/success/prelude/List/build/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/build/0B.dhall @@ -0,0 +1,1 @@ +[ "ABC", "DEF" ] diff --git a/tests/normalization/success/prelude/List/build/1A.dhall b/tests/normalization/success/prelude/List/build/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/build/1A.dhall @@ -0,0 +1,7 @@ +(../../../../../../Prelude/package.dhall).`List`.build +Text +( λ(list : Type) +→ λ(cons : Text → list → list) +→ λ(nil : list) +→ nil +) diff --git a/tests/normalization/success/prelude/List/build/1B.dhall b/tests/normalization/success/prelude/List/build/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/build/1B.dhall @@ -0,0 +1,1 @@ +[] : List Text diff --git a/tests/normalization/success/prelude/List/concat/0A.dhall b/tests/normalization/success/prelude/List/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/concat/0A.dhall @@ -0,0 +1,5 @@ +(../../../../../../Prelude/package.dhall).`List`.concat Natural +[ [ 0, 1, 2 ] +, [ 3, 4 ] +, [ 5, 6, 7, 8 ] +] diff --git a/tests/normalization/success/prelude/List/concat/0B.dhall b/tests/normalization/success/prelude/List/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/concat/0B.dhall @@ -0,0 +1,1 @@ +[ 0, 1, 2, 3, 4, 5, 6, 7, 8 ] diff --git a/tests/normalization/success/prelude/List/concat/1A.dhall b/tests/normalization/success/prelude/List/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/concat/1A.dhall @@ -0,0 +1,5 @@ +(../../../../../../Prelude/package.dhall).`List`.concat Natural +[ [] : List Natural +, [] : List Natural +, [] : List Natural +] diff --git a/tests/normalization/success/prelude/List/concat/1B.dhall b/tests/normalization/success/prelude/List/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/concat/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/tests/normalization/success/prelude/List/concatMap/0A.dhall b/tests/normalization/success/prelude/List/concatMap/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/concatMap/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.concatMap Natural Natural (λ(n : Natural) → [ n, n ]) [ 2, 3, 5 ] diff --git a/tests/normalization/success/prelude/List/concatMap/0B.dhall b/tests/normalization/success/prelude/List/concatMap/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/concatMap/0B.dhall @@ -0,0 +1,1 @@ +[ 2, 2, 3, 3, 5, 5 ] diff --git a/tests/normalization/success/prelude/List/concatMap/1A.dhall b/tests/normalization/success/prelude/List/concatMap/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/concatMap/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.concatMap Natural Natural (λ(n : Natural) → [ n, n ]) ([] : List Natural) diff --git a/tests/normalization/success/prelude/List/concatMap/1B.dhall b/tests/normalization/success/prelude/List/concatMap/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/concatMap/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/tests/normalization/success/prelude/List/filter/0A.dhall b/tests/normalization/success/prelude/List/filter/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/filter/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.filter Natural Natural/even [ 2, 3, 5 ] diff --git a/tests/normalization/success/prelude/List/filter/0B.dhall b/tests/normalization/success/prelude/List/filter/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/filter/0B.dhall @@ -0,0 +1,1 @@ +[ 2 ] diff --git a/tests/normalization/success/prelude/List/filter/1A.dhall b/tests/normalization/success/prelude/List/filter/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/filter/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.filter Natural Natural/odd [ 2, 3, 5 ] diff --git a/tests/normalization/success/prelude/List/filter/1B.dhall b/tests/normalization/success/prelude/List/filter/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/filter/1B.dhall @@ -0,0 +1,1 @@ +[ 3, 5 ] diff --git a/tests/normalization/success/prelude/List/fold/0A.dhall b/tests/normalization/success/prelude/List/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/fold/0A.dhall @@ -0,0 +1,6 @@ +(../../../../../../Prelude/package.dhall).`List`.fold +Natural +[ 2, 3, 5 ] +Natural +(λ(x : Natural) → λ(y : Natural) → x + y) +0 diff --git a/tests/normalization/success/prelude/List/fold/0B.dhall b/tests/normalization/success/prelude/List/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/fold/0B.dhall @@ -0,0 +1,1 @@ +10 diff --git a/tests/normalization/success/prelude/List/fold/1A.dhall b/tests/normalization/success/prelude/List/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/fold/1A.dhall @@ -0,0 +1,7 @@ + λ(nil : Natural) +→ (../../../../../../Prelude/package.dhall).`List`.fold + Natural + [ 2, 3, 5 ] + Natural + (λ(x : Natural) → λ(y : Natural) → x + y) + nil diff --git a/tests/normalization/success/prelude/List/fold/1B.dhall b/tests/normalization/success/prelude/List/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/fold/1B.dhall @@ -0,0 +1,1 @@ +λ(nil : Natural) → 2 + (3 + (5 + nil)) diff --git a/tests/normalization/success/prelude/List/fold/2A.dhall b/tests/normalization/success/prelude/List/fold/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/fold/2A.dhall @@ -0,0 +1,4 @@ + λ(list : Type) +→ λ(cons : Natural → list → list) +→ λ(nil : list) +→ (../../../../../../Prelude/package.dhall).`List`.fold Natural [ 2, 3, 5 ] list cons nil diff --git a/tests/normalization/success/prelude/List/fold/2B.dhall b/tests/normalization/success/prelude/List/fold/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/fold/2B.dhall @@ -0,0 +1,4 @@ + λ(list : Type) +→ λ(cons : Natural → list → list) +→ λ(nil : list) +→ cons 2 (cons 3 (cons 5 nil)) diff --git a/tests/normalization/success/prelude/List/generate/0A.dhall b/tests/normalization/success/prelude/List/generate/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/generate/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.generate 5 Bool Natural/even diff --git a/tests/normalization/success/prelude/List/generate/0B.dhall b/tests/normalization/success/prelude/List/generate/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/generate/0B.dhall @@ -0,0 +1,1 @@ +[ True, False, True, False, True ] diff --git a/tests/normalization/success/prelude/List/generate/1A.dhall b/tests/normalization/success/prelude/List/generate/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/generate/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.generate 0 Bool Natural/even diff --git a/tests/normalization/success/prelude/List/generate/1B.dhall b/tests/normalization/success/prelude/List/generate/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/generate/1B.dhall @@ -0,0 +1,1 @@ +[] : List Bool diff --git a/tests/normalization/success/prelude/List/head/0A.dhall b/tests/normalization/success/prelude/List/head/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/head/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.head Natural [ 0, 1, 2 ] diff --git a/tests/normalization/success/prelude/List/head/0B.dhall b/tests/normalization/success/prelude/List/head/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/head/0B.dhall @@ -0,0 +1,1 @@ +Some 0 diff --git a/tests/normalization/success/prelude/List/head/1A.dhall b/tests/normalization/success/prelude/List/head/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/head/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.head Natural ([] : List Natural) diff --git a/tests/normalization/success/prelude/List/head/1B.dhall b/tests/normalization/success/prelude/List/head/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/head/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/tests/normalization/success/prelude/List/indexed/0A.dhall b/tests/normalization/success/prelude/List/indexed/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/indexed/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.indexed Bool [ True, False, True ] diff --git a/tests/normalization/success/prelude/List/indexed/0B.dhall b/tests/normalization/success/prelude/List/indexed/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/indexed/0B.dhall @@ -0,0 +1,4 @@ +[ { index = 0, value = True } +, { index = 1, value = False } +, { index = 2, value = True } +] diff --git a/tests/normalization/success/prelude/List/indexed/1A.dhall b/tests/normalization/success/prelude/List/indexed/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/indexed/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.indexed Bool ([] : List Bool) diff --git a/tests/normalization/success/prelude/List/indexed/1B.dhall b/tests/normalization/success/prelude/List/indexed/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/indexed/1B.dhall @@ -0,0 +1,1 @@ +[] : List { index : Natural, value : Bool } diff --git a/tests/normalization/success/prelude/List/iterate/0A.dhall b/tests/normalization/success/prelude/List/iterate/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/iterate/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.iterate 10 Natural (λ(x : Natural) → x * 2) 1 diff --git a/tests/normalization/success/prelude/List/iterate/0B.dhall b/tests/normalization/success/prelude/List/iterate/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/iterate/0B.dhall @@ -0,0 +1,1 @@ +[ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 ] diff --git a/tests/normalization/success/prelude/List/iterate/1A.dhall b/tests/normalization/success/prelude/List/iterate/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/iterate/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.iterate 0 Natural (λ(x : Natural) → x * 2) 1 diff --git a/tests/normalization/success/prelude/List/iterate/1B.dhall b/tests/normalization/success/prelude/List/iterate/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/iterate/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/tests/normalization/success/prelude/List/last/0A.dhall b/tests/normalization/success/prelude/List/last/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/last/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.last Natural [ 0, 1, 2 ] diff --git a/tests/normalization/success/prelude/List/last/0B.dhall b/tests/normalization/success/prelude/List/last/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/last/0B.dhall @@ -0,0 +1,1 @@ +Some 2 diff --git a/tests/normalization/success/prelude/List/last/1A.dhall b/tests/normalization/success/prelude/List/last/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/last/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.last Natural ([] : List Natural) diff --git a/tests/normalization/success/prelude/List/last/1B.dhall b/tests/normalization/success/prelude/List/last/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/last/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/tests/normalization/success/prelude/List/length/0A.dhall b/tests/normalization/success/prelude/List/length/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/length/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.length Natural [ 0, 1, 2 ] diff --git a/tests/normalization/success/prelude/List/length/0B.dhall b/tests/normalization/success/prelude/List/length/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/length/0B.dhall @@ -0,0 +1,1 @@ +3 diff --git a/tests/normalization/success/prelude/List/length/1A.dhall b/tests/normalization/success/prelude/List/length/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/length/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.length Natural ([] : List Natural) diff --git a/tests/normalization/success/prelude/List/length/1B.dhall b/tests/normalization/success/prelude/List/length/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/length/1B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/tests/normalization/success/prelude/List/map/0A.dhall b/tests/normalization/success/prelude/List/map/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/map/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.map Natural Bool Natural/even [ 2, 3, 5 ] diff --git a/tests/normalization/success/prelude/List/map/0B.dhall b/tests/normalization/success/prelude/List/map/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/map/0B.dhall @@ -0,0 +1,1 @@ +[ True, False, False ] diff --git a/tests/normalization/success/prelude/List/map/1A.dhall b/tests/normalization/success/prelude/List/map/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/map/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.map Natural Bool Natural/even ([] : List Natural) diff --git a/tests/normalization/success/prelude/List/map/1B.dhall b/tests/normalization/success/prelude/List/map/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/map/1B.dhall @@ -0,0 +1,1 @@ +[] : List Bool diff --git a/tests/normalization/success/prelude/List/null/0A.dhall b/tests/normalization/success/prelude/List/null/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/null/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.null Natural [ 0, 1, 2 ] diff --git a/tests/normalization/success/prelude/List/null/0B.dhall b/tests/normalization/success/prelude/List/null/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/null/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/List/null/1A.dhall b/tests/normalization/success/prelude/List/null/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/null/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.null Natural ([] : List Natural) diff --git a/tests/normalization/success/prelude/List/null/1B.dhall b/tests/normalization/success/prelude/List/null/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/null/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/List/replicate/0A.dhall b/tests/normalization/success/prelude/List/replicate/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/replicate/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.replicate 9 Natural 1 diff --git a/tests/normalization/success/prelude/List/replicate/0B.dhall b/tests/normalization/success/prelude/List/replicate/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/replicate/0B.dhall @@ -0,0 +1,1 @@ +[ 1, 1, 1, 1, 1, 1, 1, 1, 1 ] diff --git a/tests/normalization/success/prelude/List/replicate/1A.dhall b/tests/normalization/success/prelude/List/replicate/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/replicate/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.replicate 0 Natural 1 diff --git a/tests/normalization/success/prelude/List/replicate/1B.dhall b/tests/normalization/success/prelude/List/replicate/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/replicate/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/tests/normalization/success/prelude/List/reverse/0A.dhall b/tests/normalization/success/prelude/List/reverse/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/reverse/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.reverse Natural [ 0, 1, 2 ] diff --git a/tests/normalization/success/prelude/List/reverse/0B.dhall b/tests/normalization/success/prelude/List/reverse/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/reverse/0B.dhall @@ -0,0 +1,1 @@ +[ 2, 1, 0 ] diff --git a/tests/normalization/success/prelude/List/reverse/1A.dhall b/tests/normalization/success/prelude/List/reverse/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/reverse/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.reverse Natural ([] : List Natural) diff --git a/tests/normalization/success/prelude/List/reverse/1B.dhall b/tests/normalization/success/prelude/List/reverse/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/reverse/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/tests/normalization/success/prelude/List/shifted/0A.dhall b/tests/normalization/success/prelude/List/shifted/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/shifted/0A.dhall @@ -0,0 +1,15 @@ +(../../../../../../Prelude/package.dhall).`List`.shifted +Bool +[ [ { index = 0, value = True } + , { index = 1, value = True } + , { index = 2, value = False } + ] +, [ { index = 0, value = False } + , { index = 1, value = False } + ] +, [ { index = 0, value = True } + , { index = 1, value = True } + , { index = 2, value = True } + , { index = 3, value = True } + ] +] diff --git a/tests/normalization/success/prelude/List/shifted/0B.dhall b/tests/normalization/success/prelude/List/shifted/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/shifted/0B.dhall @@ -0,0 +1,10 @@ +[ { index = 0, value = True } +, { index = 1, value = True } +, { index = 2, value = False } +, { index = 3, value = False } +, { index = 4, value = False } +, { index = 5, value = True } +, { index = 6, value = True } +, { index = 7, value = True } +, { index = 8, value = True } +] diff --git a/tests/normalization/success/prelude/List/shifted/1A.dhall b/tests/normalization/success/prelude/List/shifted/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/shifted/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.shifted Bool ([] : List (List { index : Natural, value : Bool })) diff --git a/tests/normalization/success/prelude/List/shifted/1B.dhall b/tests/normalization/success/prelude/List/shifted/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/shifted/1B.dhall @@ -0,0 +1,1 @@ +[] : List { index : Natural, value : Bool } diff --git a/tests/normalization/success/prelude/List/unzip/0A.dhall b/tests/normalization/success/prelude/List/unzip/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/unzip/0A.dhall @@ -0,0 +1,7 @@ +(../../../../../../Prelude/package.dhall).`List`.unzip +Text +Bool +[ { _1 = "ABC", _2 = True } +, { _1 = "DEF", _2 = False } +, { _1 = "GHI", _2 = True } +] diff --git a/tests/normalization/success/prelude/List/unzip/0B.dhall b/tests/normalization/success/prelude/List/unzip/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/unzip/0B.dhall @@ -0,0 +1,1 @@ +{ _1 = [ "ABC", "DEF", "GHI" ], _2 = [ True, False, True ] } diff --git a/tests/normalization/success/prelude/List/unzip/1A.dhall b/tests/normalization/success/prelude/List/unzip/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/unzip/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.unzip Text Bool ([] : List { _1 : Text, _2 : Bool }) diff --git a/tests/normalization/success/prelude/List/unzip/1B.dhall b/tests/normalization/success/prelude/List/unzip/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/List/unzip/1B.dhall @@ -0,0 +1,1 @@ +{ _1 = [] : List Text, _2 = [] : List Bool } diff --git a/tests/normalization/success/prelude/Natural/build/0A.dhall b/tests/normalization/success/prelude/Natural/build/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/build/0A.dhall @@ -0,0 +1,6 @@ +(../../../../../../Prelude/package.dhall).`Natural`.build +( λ(natural : Type) +→ λ(succ : natural → natural) +→ λ(zero : natural) +→ succ (succ (succ zero)) +) diff --git a/tests/normalization/success/prelude/Natural/build/0B.dhall b/tests/normalization/success/prelude/Natural/build/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/build/0B.dhall @@ -0,0 +1,1 @@ +3 diff --git a/tests/normalization/success/prelude/Natural/build/1A.dhall b/tests/normalization/success/prelude/Natural/build/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/build/1A.dhall @@ -0,0 +1,6 @@ +(../../../../../../Prelude/package.dhall).`Natural`.build +( λ(natural : Type) +→ λ(succ : natural → natural) +→ λ(zero : natural) +→ zero +) diff --git a/tests/normalization/success/prelude/Natural/build/1B.dhall b/tests/normalization/success/prelude/Natural/build/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/build/1B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/tests/normalization/success/prelude/Natural/enumerate/0A.dhall b/tests/normalization/success/prelude/Natural/enumerate/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/enumerate/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.enumerate 10 diff --git a/tests/normalization/success/prelude/Natural/enumerate/0B.dhall b/tests/normalization/success/prelude/Natural/enumerate/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/enumerate/0B.dhall @@ -0,0 +1,1 @@ +[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] diff --git a/tests/normalization/success/prelude/Natural/enumerate/1A.dhall b/tests/normalization/success/prelude/Natural/enumerate/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/enumerate/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.enumerate 0 diff --git a/tests/normalization/success/prelude/Natural/enumerate/1B.dhall b/tests/normalization/success/prelude/Natural/enumerate/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/enumerate/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/tests/normalization/success/prelude/Natural/even/0A.dhall b/tests/normalization/success/prelude/Natural/even/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/even/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.even 3 diff --git a/tests/normalization/success/prelude/Natural/even/0B.dhall b/tests/normalization/success/prelude/Natural/even/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/even/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Natural/even/1A.dhall b/tests/normalization/success/prelude/Natural/even/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/even/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.even 0 diff --git a/tests/normalization/success/prelude/Natural/even/1B.dhall b/tests/normalization/success/prelude/Natural/even/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/even/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Natural/fold/0A.dhall b/tests/normalization/success/prelude/Natural/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/fold/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.fold 3 Natural (λ(x : Natural) → 5 * x) 1 diff --git a/tests/normalization/success/prelude/Natural/fold/0B.dhall b/tests/normalization/success/prelude/Natural/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/fold/0B.dhall @@ -0,0 +1,1 @@ +125 diff --git a/tests/normalization/success/prelude/Natural/fold/1A.dhall b/tests/normalization/success/prelude/Natural/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/fold/1A.dhall @@ -0,0 +1,1 @@ +λ(zero : Natural) → (../../../../../../Prelude/package.dhall).`Natural`.fold 3 Natural (λ(x : Natural) → 5 * x) zero diff --git a/tests/normalization/success/prelude/Natural/fold/1B.dhall b/tests/normalization/success/prelude/Natural/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/fold/1B.dhall @@ -0,0 +1,1 @@ +λ(zero : Natural) → 5 * (5 * (5 * zero)) diff --git a/tests/normalization/success/prelude/Natural/fold/2A.dhall b/tests/normalization/success/prelude/Natural/fold/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/fold/2A.dhall @@ -0,0 +1,4 @@ + λ(natural : Type) +→ λ(succ : natural → natural) +→ λ(zero : natural) +→ (../../../../../../Prelude/package.dhall).`Natural`.fold 3 natural succ zero diff --git a/tests/normalization/success/prelude/Natural/fold/2B.dhall b/tests/normalization/success/prelude/Natural/fold/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/fold/2B.dhall @@ -0,0 +1,1 @@ +λ(natural : Type) → λ(succ : natural → natural) → λ(zero : natural) → succ (succ (succ zero)) diff --git a/tests/normalization/success/prelude/Natural/isZero/0A.dhall b/tests/normalization/success/prelude/Natural/isZero/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/isZero/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.isZero 2 diff --git a/tests/normalization/success/prelude/Natural/isZero/0B.dhall b/tests/normalization/success/prelude/Natural/isZero/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/isZero/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Natural/isZero/1A.dhall b/tests/normalization/success/prelude/Natural/isZero/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/isZero/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.isZero 0 diff --git a/tests/normalization/success/prelude/Natural/isZero/1B.dhall b/tests/normalization/success/prelude/Natural/isZero/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/isZero/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Natural/odd/0A.dhall b/tests/normalization/success/prelude/Natural/odd/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/odd/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.odd 3 diff --git a/tests/normalization/success/prelude/Natural/odd/0B.dhall b/tests/normalization/success/prelude/Natural/odd/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/odd/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Natural/odd/1A.dhall b/tests/normalization/success/prelude/Natural/odd/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/odd/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.odd 0 diff --git a/tests/normalization/success/prelude/Natural/odd/1B.dhall b/tests/normalization/success/prelude/Natural/odd/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/odd/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Natural/product/0A.dhall b/tests/normalization/success/prelude/Natural/product/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/product/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.product [ 2, 3, 5 ] diff --git a/tests/normalization/success/prelude/Natural/product/0B.dhall b/tests/normalization/success/prelude/Natural/product/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/product/0B.dhall @@ -0,0 +1,1 @@ +30 diff --git a/tests/normalization/success/prelude/Natural/product/1A.dhall b/tests/normalization/success/prelude/Natural/product/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/product/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.product ([] : List Natural) diff --git a/tests/normalization/success/prelude/Natural/product/1B.dhall b/tests/normalization/success/prelude/Natural/product/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/product/1B.dhall @@ -0,0 +1,1 @@ +1 diff --git a/tests/normalization/success/prelude/Natural/show/0A.dhall b/tests/normalization/success/prelude/Natural/show/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/show/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.show 3 diff --git a/tests/normalization/success/prelude/Natural/show/0B.dhall b/tests/normalization/success/prelude/Natural/show/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/show/0B.dhall @@ -0,0 +1,1 @@ +"3" diff --git a/tests/normalization/success/prelude/Natural/show/1A.dhall b/tests/normalization/success/prelude/Natural/show/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/show/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.show 0 diff --git a/tests/normalization/success/prelude/Natural/show/1B.dhall b/tests/normalization/success/prelude/Natural/show/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/show/1B.dhall @@ -0,0 +1,1 @@ +"0" diff --git a/tests/normalization/success/prelude/Natural/sum/0A.dhall b/tests/normalization/success/prelude/Natural/sum/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/sum/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.sum [ 2, 3, 5 ] diff --git a/tests/normalization/success/prelude/Natural/sum/0B.dhall b/tests/normalization/success/prelude/Natural/sum/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/sum/0B.dhall @@ -0,0 +1,1 @@ +10 diff --git a/tests/normalization/success/prelude/Natural/sum/1A.dhall b/tests/normalization/success/prelude/Natural/sum/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/sum/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.sum ([] : List Natural) diff --git a/tests/normalization/success/prelude/Natural/sum/1B.dhall b/tests/normalization/success/prelude/Natural/sum/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/sum/1B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/tests/normalization/success/prelude/Natural/toDouble/0A.dhall b/tests/normalization/success/prelude/Natural/toDouble/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/toDouble/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.toDouble 3 diff --git a/tests/normalization/success/prelude/Natural/toDouble/0B.dhall b/tests/normalization/success/prelude/Natural/toDouble/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/toDouble/0B.dhall @@ -0,0 +1,1 @@ +3.0 diff --git a/tests/normalization/success/prelude/Natural/toDouble/1A.dhall b/tests/normalization/success/prelude/Natural/toDouble/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/toDouble/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.toDouble 0 diff --git a/tests/normalization/success/prelude/Natural/toDouble/1B.dhall b/tests/normalization/success/prelude/Natural/toDouble/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/toDouble/1B.dhall @@ -0,0 +1,1 @@ +0.0 diff --git a/tests/normalization/success/prelude/Natural/toInteger/0A.dhall b/tests/normalization/success/prelude/Natural/toInteger/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/toInteger/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.toInteger 3 diff --git a/tests/normalization/success/prelude/Natural/toInteger/0B.dhall b/tests/normalization/success/prelude/Natural/toInteger/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/toInteger/0B.dhall @@ -0,0 +1,1 @@ ++3 diff --git a/tests/normalization/success/prelude/Natural/toInteger/1A.dhall b/tests/normalization/success/prelude/Natural/toInteger/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/toInteger/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.toInteger 0 diff --git a/tests/normalization/success/prelude/Natural/toInteger/1B.dhall b/tests/normalization/success/prelude/Natural/toInteger/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Natural/toInteger/1B.dhall @@ -0,0 +1,1 @@ ++0 diff --git a/tests/normalization/success/prelude/Optional/all/0A.dhall b/tests/normalization/success/prelude/Optional/all/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/all/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (Some 3) diff --git a/tests/normalization/success/prelude/Optional/all/0B.dhall b/tests/normalization/success/prelude/Optional/all/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/all/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Optional/all/1A.dhall b/tests/normalization/success/prelude/Optional/all/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/all/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (None Natural) diff --git a/tests/normalization/success/prelude/Optional/all/1B.dhall b/tests/normalization/success/prelude/Optional/all/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/all/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Optional/any/0A.dhall b/tests/normalization/success/prelude/Optional/any/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/any/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (Some 2) diff --git a/tests/normalization/success/prelude/Optional/any/0B.dhall b/tests/normalization/success/prelude/Optional/any/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/any/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Optional/any/1A.dhall b/tests/normalization/success/prelude/Optional/any/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/any/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (None Natural) diff --git a/tests/normalization/success/prelude/Optional/any/1B.dhall b/tests/normalization/success/prelude/Optional/any/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/any/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Optional/build/0A.dhall b/tests/normalization/success/prelude/Optional/build/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/build/0A.dhall @@ -0,0 +1,7 @@ +(../../../../../../Prelude/package.dhall).`Optional`.build +Natural +( λ(optional : Type) +→ λ(some : Natural → optional) +→ λ(none : optional) +→ some 1 +) diff --git a/tests/normalization/success/prelude/Optional/build/0B.dhall b/tests/normalization/success/prelude/Optional/build/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/build/0B.dhall @@ -0,0 +1,1 @@ +Some 1 diff --git a/tests/normalization/success/prelude/Optional/build/1A.dhall b/tests/normalization/success/prelude/Optional/build/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/build/1A.dhall @@ -0,0 +1,7 @@ +(../../../../../../Prelude/package.dhall).`Optional`.build +Natural +( λ(optional : Type) +→ λ(some : Natural → optional) +→ λ(none : optional) +→ none +) diff --git a/tests/normalization/success/prelude/Optional/build/1B.dhall b/tests/normalization/success/prelude/Optional/build/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/build/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/tests/normalization/success/prelude/Optional/concat/0A.dhall b/tests/normalization/success/prelude/Optional/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/concat/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (Some 1)) diff --git a/tests/normalization/success/prelude/Optional/concat/0B.dhall b/tests/normalization/success/prelude/Optional/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/concat/0B.dhall @@ -0,0 +1,1 @@ +Some 1 diff --git a/tests/normalization/success/prelude/Optional/concat/1A.dhall b/tests/normalization/success/prelude/Optional/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/concat/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (None Natural)) diff --git a/tests/normalization/success/prelude/Optional/concat/1B.dhall b/tests/normalization/success/prelude/Optional/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/concat/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/tests/normalization/success/prelude/Optional/concat/2A.dhall b/tests/normalization/success/prelude/Optional/concat/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/concat/2A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (None (Optional Natural)) diff --git a/tests/normalization/success/prelude/Optional/concat/2B.dhall b/tests/normalization/success/prelude/Optional/concat/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/concat/2B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/tests/normalization/success/prelude/Optional/filter/0A.dhall b/tests/normalization/success/prelude/Optional/filter/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/filter/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/even (Some 2) diff --git a/tests/normalization/success/prelude/Optional/filter/0B.dhall b/tests/normalization/success/prelude/Optional/filter/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/filter/0B.dhall @@ -0,0 +1,1 @@ +Some 2 diff --git a/tests/normalization/success/prelude/Optional/filter/1A.dhall b/tests/normalization/success/prelude/Optional/filter/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/filter/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/odd (Some 2) diff --git a/tests/normalization/success/prelude/Optional/filter/1B.dhall b/tests/normalization/success/prelude/Optional/filter/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/filter/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/tests/normalization/success/prelude/Optional/fold/0A.dhall b/tests/normalization/success/prelude/Optional/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/fold/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.fold Natural (Some 2) Natural (λ(x : Natural) → x) 0 diff --git a/tests/normalization/success/prelude/Optional/fold/0B.dhall b/tests/normalization/success/prelude/Optional/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/fold/0B.dhall @@ -0,0 +1,1 @@ +2 diff --git a/tests/normalization/success/prelude/Optional/fold/1A.dhall b/tests/normalization/success/prelude/Optional/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/fold/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.fold Natural (None Natural) Natural (λ(x : Natural) → x) 0 diff --git a/tests/normalization/success/prelude/Optional/fold/1B.dhall b/tests/normalization/success/prelude/Optional/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/fold/1B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/tests/normalization/success/prelude/Optional/head/0A.dhall b/tests/normalization/success/prelude/Optional/head/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/head/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.head Natural [ None Natural, Some 1, Some 2 ] diff --git a/tests/normalization/success/prelude/Optional/head/0B.dhall b/tests/normalization/success/prelude/Optional/head/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/head/0B.dhall @@ -0,0 +1,1 @@ +Some 1 diff --git a/tests/normalization/success/prelude/Optional/head/1A.dhall b/tests/normalization/success/prelude/Optional/head/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/head/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.head Natural [ None Natural, None Natural ] diff --git a/tests/normalization/success/prelude/Optional/head/1B.dhall b/tests/normalization/success/prelude/Optional/head/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/head/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/tests/normalization/success/prelude/Optional/head/2A.dhall b/tests/normalization/success/prelude/Optional/head/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/head/2A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.head Natural ([] : List (Optional Natural)) diff --git a/tests/normalization/success/prelude/Optional/head/2B.dhall b/tests/normalization/success/prelude/Optional/head/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/head/2B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/tests/normalization/success/prelude/Optional/last/0A.dhall b/tests/normalization/success/prelude/Optional/last/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/last/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.last Natural [ None Natural, Some 1, Some 2 ] diff --git a/tests/normalization/success/prelude/Optional/last/0B.dhall b/tests/normalization/success/prelude/Optional/last/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/last/0B.dhall @@ -0,0 +1,1 @@ +Some 2 diff --git a/tests/normalization/success/prelude/Optional/last/1A.dhall b/tests/normalization/success/prelude/Optional/last/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/last/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.last Natural [ None Natural, None Natural ] diff --git a/tests/normalization/success/prelude/Optional/last/1B.dhall b/tests/normalization/success/prelude/Optional/last/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/last/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/tests/normalization/success/prelude/Optional/last/2A.dhall b/tests/normalization/success/prelude/Optional/last/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/last/2A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.last Natural ([] : List (Optional Natural)) diff --git a/tests/normalization/success/prelude/Optional/last/2B.dhall b/tests/normalization/success/prelude/Optional/last/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/last/2B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/tests/normalization/success/prelude/Optional/length/0A.dhall b/tests/normalization/success/prelude/Optional/length/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/length/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.length Natural (Some 2) diff --git a/tests/normalization/success/prelude/Optional/length/0B.dhall b/tests/normalization/success/prelude/Optional/length/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/length/0B.dhall @@ -0,0 +1,1 @@ +1 diff --git a/tests/normalization/success/prelude/Optional/length/1A.dhall b/tests/normalization/success/prelude/Optional/length/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/length/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.length Natural (None Natural) diff --git a/tests/normalization/success/prelude/Optional/length/1B.dhall b/tests/normalization/success/prelude/Optional/length/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/length/1B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/tests/normalization/success/prelude/Optional/map/0A.dhall b/tests/normalization/success/prelude/Optional/map/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/map/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (Some 3) diff --git a/tests/normalization/success/prelude/Optional/map/0B.dhall b/tests/normalization/success/prelude/Optional/map/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/map/0B.dhall @@ -0,0 +1,1 @@ +Some False diff --git a/tests/normalization/success/prelude/Optional/map/1A.dhall b/tests/normalization/success/prelude/Optional/map/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/map/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (None Natural) diff --git a/tests/normalization/success/prelude/Optional/map/1B.dhall b/tests/normalization/success/prelude/Optional/map/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/map/1B.dhall @@ -0,0 +1,1 @@ +None Bool diff --git a/tests/normalization/success/prelude/Optional/null/0A.dhall b/tests/normalization/success/prelude/Optional/null/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/null/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.null Natural (Some 2) diff --git a/tests/normalization/success/prelude/Optional/null/0B.dhall b/tests/normalization/success/prelude/Optional/null/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/null/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/tests/normalization/success/prelude/Optional/null/1A.dhall b/tests/normalization/success/prelude/Optional/null/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/null/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.null Natural (None Natural) diff --git a/tests/normalization/success/prelude/Optional/null/1B.dhall b/tests/normalization/success/prelude/Optional/null/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/null/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/tests/normalization/success/prelude/Optional/toList/0A.dhall b/tests/normalization/success/prelude/Optional/toList/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/toList/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.toList Natural (Some 1) diff --git a/tests/normalization/success/prelude/Optional/toList/0B.dhall b/tests/normalization/success/prelude/Optional/toList/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/toList/0B.dhall @@ -0,0 +1,1 @@ +[ 1 ] : List Natural diff --git a/tests/normalization/success/prelude/Optional/toList/1A.dhall b/tests/normalization/success/prelude/Optional/toList/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/toList/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.toList Natural (None Natural) diff --git a/tests/normalization/success/prelude/Optional/toList/1B.dhall b/tests/normalization/success/prelude/Optional/toList/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/toList/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/tests/normalization/success/prelude/Optional/unzip/0A.dhall b/tests/normalization/success/prelude/Optional/unzip/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/unzip/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.unzip Text Bool (Some { _1 = "ABC", _2 = True }) diff --git a/tests/normalization/success/prelude/Optional/unzip/0B.dhall b/tests/normalization/success/prelude/Optional/unzip/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/unzip/0B.dhall @@ -0,0 +1,1 @@ +{ _1 = Some "ABC", _2 = Some True } diff --git a/tests/normalization/success/prelude/Optional/unzip/1A.dhall b/tests/normalization/success/prelude/Optional/unzip/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/unzip/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.unzip Text Bool (None { _1 : Text, _2 : Bool }) diff --git a/tests/normalization/success/prelude/Optional/unzip/1B.dhall b/tests/normalization/success/prelude/Optional/unzip/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Optional/unzip/1B.dhall @@ -0,0 +1,1 @@ +{ _1 = None Text, _2 = None Bool } diff --git a/tests/normalization/success/prelude/Text/concat/0A.dhall b/tests/normalization/success/prelude/Text/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concat/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concat [ "ABC", "DEF", "GHI" ] diff --git a/tests/normalization/success/prelude/Text/concat/0B.dhall b/tests/normalization/success/prelude/Text/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concat/0B.dhall @@ -0,0 +1,1 @@ +"ABCDEFGHI" diff --git a/tests/normalization/success/prelude/Text/concat/1A.dhall b/tests/normalization/success/prelude/Text/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concat/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concat ([] : List Text) diff --git a/tests/normalization/success/prelude/Text/concat/1B.dhall b/tests/normalization/success/prelude/Text/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concat/1B.dhall @@ -0,0 +1,1 @@ +"" diff --git a/tests/normalization/success/prelude/Text/concatMap/0A.dhall b/tests/normalization/success/prelude/Text/concatMap/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatMap/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concatMap Natural (λ(n : Natural) → "${Natural/show n} ") [ 0, 1, 2 ] diff --git a/tests/normalization/success/prelude/Text/concatMap/0B.dhall b/tests/normalization/success/prelude/Text/concatMap/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatMap/0B.dhall @@ -0,0 +1,1 @@ +"0 1 2 " diff --git a/tests/normalization/success/prelude/Text/concatMap/1A.dhall b/tests/normalization/success/prelude/Text/concatMap/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatMap/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concatMap Natural (λ(n : Natural) → "${Natural/show n} ") ([] : List Natural) diff --git a/tests/normalization/success/prelude/Text/concatMap/1B.dhall b/tests/normalization/success/prelude/Text/concatMap/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatMap/1B.dhall @@ -0,0 +1,1 @@ +"" diff --git a/tests/normalization/success/prelude/Text/concatMapSep/0A.dhall b/tests/normalization/success/prelude/Text/concatMapSep/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatMapSep/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show [ 0, 1, 2 ] diff --git a/tests/normalization/success/prelude/Text/concatMapSep/0B.dhall b/tests/normalization/success/prelude/Text/concatMapSep/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatMapSep/0B.dhall @@ -0,0 +1,1 @@ +"0, 1, 2" diff --git a/tests/normalization/success/prelude/Text/concatMapSep/1A.dhall b/tests/normalization/success/prelude/Text/concatMapSep/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatMapSep/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show ([] : List Natural) diff --git a/tests/normalization/success/prelude/Text/concatMapSep/1B.dhall b/tests/normalization/success/prelude/Text/concatMapSep/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatMapSep/1B.dhall @@ -0,0 +1,1 @@ +"" diff --git a/tests/normalization/success/prelude/Text/concatSep/0A.dhall b/tests/normalization/success/prelude/Text/concatSep/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatSep/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concatSep ", " [ "ABC", "DEF", "GHI" ] diff --git a/tests/normalization/success/prelude/Text/concatSep/0B.dhall b/tests/normalization/success/prelude/Text/concatSep/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatSep/0B.dhall @@ -0,0 +1,1 @@ +"ABC, DEF, GHI" diff --git a/tests/normalization/success/prelude/Text/concatSep/1A.dhall b/tests/normalization/success/prelude/Text/concatSep/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatSep/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concatSep ", " ([] : List Text) diff --git a/tests/normalization/success/prelude/Text/concatSep/1B.dhall b/tests/normalization/success/prelude/Text/concatSep/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/prelude/Text/concatSep/1B.dhall @@ -0,0 +1,1 @@ +"" diff --git a/tests/normalization/success/remoteSystemsA.dhall b/tests/normalization/success/remoteSystemsA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/remoteSystemsA.dhall @@ -0,0 +1,52 @@ +let Text/concatMap = (./../../../Prelude/package.dhall).`Text`.concatMap + +let Text/concatSep = (./../../../Prelude/package.dhall).`Text`.concatSep + +let Row = + { cores : + Natural + , host : + Text + , key : + Text + , mandatoryFeatures : + List Text + , platforms : + List Text + , speedFactor : + Natural + , supportedFeatures : + List Text + , user : + Optional Text + } + +let renderRow = + λ ( row + : Row + ) + → let host = + Optional/fold + Text + row.user + Text + (λ(user : Text) → "${user}@${row.host}") + row.host + + let platforms = Text/concatSep "," row.platforms + + let key = row.key + + let cores = Integer/show (Natural/toInteger row.cores) + + let speedFactor = Integer/show (Natural/toInteger row.speedFactor) + + let supportedFeatures = Text/concatSep "," row.supportedFeatures + + let mandatoryFeatures = Text/concatSep "," row.mandatoryFeatures + + in '' + ${host} ${platforms} ${key} ${cores} ${speedFactor} ${supportedFeatures} ${mandatoryFeatures} + '' + +in Text/concatMap Row renderRow diff --git a/tests/normalization/success/remoteSystemsB.dhall b/tests/normalization/success/remoteSystemsB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/remoteSystemsB.dhall @@ -0,0 +1,1 @@ +λ(xs : List { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text }) → List/fold { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text } xs Text (λ(x : { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text }) → λ(y : Text) → "${Optional/fold Text x.user Text (λ(user : Text) → "${user}@${x.host}") x.host} ${merge { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } (List/fold Text x.platforms < Empty : {} | NonEmpty : Text > (λ(element : Text) → λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → < NonEmpty = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : 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 = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : Text} ${merge { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } (List/fold Text x.mandatoryFeatures < Empty : {} | NonEmpty : Text > (λ(element : Text) → λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → < NonEmpty = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : Text}\n" ++ y) "" diff --git a/tests/normalization/success/simple/doubleShowA.dhall b/tests/normalization/success/simple/doubleShowA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/doubleShowA.dhall @@ -0,0 +1,1 @@ +{ example0 = Double/show -0.42, example1 = Double/show 13.37 } diff --git a/tests/normalization/success/simple/doubleShowB.dhall b/tests/normalization/success/simple/doubleShowB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/doubleShowB.dhall @@ -0,0 +1,1 @@ +{ example0 = "-0.42", example1 = "13.37" } diff --git a/tests/normalization/success/simple/integerShowA.dhall b/tests/normalization/success/simple/integerShowA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/integerShowA.dhall @@ -0,0 +1,4 @@ +{ example0 = Integer/show +1337 +, example1 = Integer/show -42 +, example2 = Integer/show +0 +} diff --git a/tests/normalization/success/simple/integerShowB.dhall b/tests/normalization/success/simple/integerShowB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/integerShowB.dhall @@ -0,0 +1,1 @@ +{ example0 = "+1337", example1 = "-42", example2 = "+0" } diff --git a/tests/normalization/success/simple/integerToDoubleA.dhall b/tests/normalization/success/simple/integerToDoubleA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/integerToDoubleA.dhall @@ -0,0 +1,10 @@ +[ Integer/toDouble +179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792 +, Integer/toDouble +179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791 +, Integer/toDouble +179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218945 +, Integer/toDouble +179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944 + +, Integer/toDouble -179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792 +, Integer/toDouble -179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791 +, Integer/toDouble -179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218945 +, Integer/toDouble -179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944 +] diff --git a/tests/normalization/success/simple/integerToDoubleB.dhall b/tests/normalization/success/simple/integerToDoubleB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/integerToDoubleB.dhall @@ -0,0 +1,9 @@ +[ Infinity +, 1.7976931348623157e308 +, 1.7976931348623157e308 +, 1.7976931348623155e308 +, -Infinity +, -1.7976931348623157e308 +, -1.7976931348623157e308 +, -1.7976931348623155e308 +] diff --git a/tests/normalization/success/simple/letletA.dhall b/tests/normalization/success/simple/letletA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/letletA.dhall @@ -0,0 +1,3 @@ +let l = λ(n : Natural) → λ(m : Natural) → λ(x : Natural) → n + m * x +let f = l 2 3 +in f 445 diff --git a/tests/normalization/success/simple/letletB.dhall b/tests/normalization/success/simple/letletB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/letletB.dhall @@ -0,0 +1,1 @@ +1337 diff --git a/tests/normalization/success/simple/listBuildA.dhall b/tests/normalization/success/simple/listBuildA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/listBuildA.dhall @@ -0,0 +1,22 @@ +{ example0 = + List/build + Bool + ( λ(list : Type) + → λ(cons : Bool → list → list) + → λ(nil : list) + → cons True (cons False nil) + ) +, example1 = + List/build + Bool + (λ(x : Type) → λ(x : Bool → x → x) → λ(x : x@1) → x@1 True (x@1 False x)) +, example2 = + λ(id : ∀(a : Type) → a → a) + → List/build + Bool + ( λ(list : Type) + → λ(cons : Bool → list → list) + → λ(nil : list) + → id list (cons True (cons False nil)) + ) +} diff --git a/tests/normalization/success/simple/listBuildB.dhall b/tests/normalization/success/simple/listBuildB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/listBuildB.dhall @@ -0,0 +1,7 @@ +{ example0 = + [ True, False ] : List Bool +, example1 = + [ True, False ] : List Bool +, example2 = + λ(id : ∀(a : Type) → a → a) → id (List Bool) [ True, False ] +} diff --git a/tests/normalization/success/simple/multiLineA.dhall b/tests/normalization/success/simple/multiLineA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/multiLineA.dhall @@ -0,0 +1,4 @@ +'' + foo +bar +'' diff --git a/tests/normalization/success/simple/multiLineB.dhall b/tests/normalization/success/simple/multiLineB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/multiLineB.dhall @@ -0,0 +1,4 @@ +'' + foo +bar +'' diff --git a/tests/normalization/success/simple/naturalBuildA.dhall b/tests/normalization/success/simple/naturalBuildA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/naturalBuildA.dhall @@ -0,0 +1,18 @@ +{ example0 = + Natural/build + ( λ(natural : Type) + → λ(succ : natural → natural) + → λ(zero : natural) + → succ zero + ) +, example1 = + Natural/build (λ(x : Type) → λ(x : x → x) → λ(x : x@1) → x@1 x) +, example2 = + λ(id : ∀(a : Type) → a → a) + → Natural/build + ( λ(natural : Type) + → λ(succ : natural → natural) + → λ(zero : natural) + → id natural (succ zero) + ) +} diff --git a/tests/normalization/success/simple/naturalBuildB.dhall b/tests/normalization/success/simple/naturalBuildB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/naturalBuildB.dhall @@ -0,0 +1,7 @@ +{ example0 = + 1 +, example1 = + 1 +, example2 = + λ(id : ∀(a : Type) → a → a) → id Natural 1 +} diff --git a/tests/normalization/success/simple/naturalPlusA.dhall b/tests/normalization/success/simple/naturalPlusA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/naturalPlusA.dhall @@ -0,0 +1,1 @@ +1 + 2 diff --git a/tests/normalization/success/simple/naturalPlusB.dhall b/tests/normalization/success/simple/naturalPlusB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/naturalPlusB.dhall @@ -0,0 +1,1 @@ +3 diff --git a/tests/normalization/success/simple/naturalShowA.dhall b/tests/normalization/success/simple/naturalShowA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/naturalShowA.dhall @@ -0,0 +1,1 @@ +Natural/show 42 diff --git a/tests/normalization/success/simple/naturalShowB.dhall b/tests/normalization/success/simple/naturalShowB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/naturalShowB.dhall @@ -0,0 +1,1 @@ +"42" diff --git a/tests/normalization/success/simple/naturalToIntegerA.dhall b/tests/normalization/success/simple/naturalToIntegerA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/naturalToIntegerA.dhall @@ -0,0 +1,1 @@ +Natural/toInteger 1 diff --git a/tests/normalization/success/simple/naturalToIntegerB.dhall b/tests/normalization/success/simple/naturalToIntegerB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/naturalToIntegerB.dhall @@ -0,0 +1,1 @@ ++1 diff --git a/tests/normalization/success/simple/optionalBuildA.dhall b/tests/normalization/success/simple/optionalBuildA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/optionalBuildA.dhall @@ -0,0 +1,32 @@ +{ example0 = + Optional/build + Natural + ( λ(optional : Type) + → λ(just : Natural → optional) + → λ(nothing : optional) + → just 1 + ) +, example1 = + Optional/build + Integer + (λ(optional : Type) → λ(x : Integer → optional) → λ(x : optional) → x@1 +1) +, example2 = + λ(id : ∀(a : Type) → a → a) + → Optional/build + Bool + ( λ(optional : Type) + → λ(just : Bool → optional) + → λ(nothing : optional) + → id optional (just True) + ) +, example3 = + λ(a : Type) + → λ(x : a) + → Optional/build + a + ( λ(optional : Type) + → λ(just : a → optional) + → λ(nothing : optional) + → just x + ) +} diff --git a/tests/normalization/success/simple/optionalBuildB.dhall b/tests/normalization/success/simple/optionalBuildB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/optionalBuildB.dhall @@ -0,0 +1,9 @@ +{ example0 = + [ 1 ] : Optional Natural +, example1 = + [ +1 ] : Optional Integer +, example2 = + λ(id : ∀(a : Type) → a → a) → id (Optional Bool) ([ True ] : Optional Bool) +, example3 = + λ(a : Type) → λ(x : a) → [ x ] : Optional a +} diff --git a/tests/normalization/success/simple/optionalBuildFoldA.dhall b/tests/normalization/success/simple/optionalBuildFoldA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/optionalBuildFoldA.dhall @@ -0,0 +1,1 @@ +Optional/build Text (Optional/fold Text ([ "foo" ] : Optional Text)) diff --git a/tests/normalization/success/simple/optionalBuildFoldB.dhall b/tests/normalization/success/simple/optionalBuildFoldB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/optionalBuildFoldB.dhall @@ -0,0 +1,1 @@ +[ "foo" ] : Optional Text diff --git a/tests/normalization/success/simple/optionalFoldA.dhall b/tests/normalization/success/simple/optionalFoldA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/optionalFoldA.dhall @@ -0,0 +1,7 @@ + let f = + λ(o : Optional Text) + → Optional/fold Text o Natural (λ(j : Text) → 1) 2 + +in { example0 = f ([ "foo" ] : Optional Text) + , example1 = f ([] : Optional Text) + } diff --git a/tests/normalization/success/simple/optionalFoldB.dhall b/tests/normalization/success/simple/optionalFoldB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/optionalFoldB.dhall @@ -0,0 +1,1 @@ +{ example0 = 1, example1 = 2 } diff --git a/tests/normalization/success/simple/sortOperatorA.dhall b/tests/normalization/success/simple/sortOperatorA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/sortOperatorA.dhall @@ -0,0 +1,1 @@ +{ b = 2 } // { a = 1 } diff --git a/tests/normalization/success/simple/sortOperatorB.dhall b/tests/normalization/success/simple/sortOperatorB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simple/sortOperatorB.dhall @@ -0,0 +1,1 @@ +{ a = 1, b = 2 } diff --git a/tests/normalization/success/simplifications/andA.dhall b/tests/normalization/success/simplifications/andA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simplifications/andA.dhall @@ -0,0 +1,6 @@ +{ example0 = λ(x : Bool) → x && True +, example1 = λ(x : Bool) → True && x +, example2 = λ(x : Bool) → x && False +, example3 = λ(x : Bool) → False && x +, example4 = λ(x : Bool) → x && x +} diff --git a/tests/normalization/success/simplifications/andB.dhall b/tests/normalization/success/simplifications/andB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simplifications/andB.dhall @@ -0,0 +1,6 @@ +{ example0 = λ(x : Bool) → x +, example1 = λ(x : Bool) → x +, example2 = λ(x : Bool) → False +, example3 = λ(x : Bool) → False +, example4 = λ(x : Bool) → x +} diff --git a/tests/normalization/success/simplifications/eqA.dhall b/tests/normalization/success/simplifications/eqA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simplifications/eqA.dhall @@ -0,0 +1,4 @@ +{ example0 = λ(x : Bool) → x == True +, example1 = λ(x : Bool) → True == x +, example2 = λ(x : Bool) → x == x +} diff --git a/tests/normalization/success/simplifications/eqB.dhall b/tests/normalization/success/simplifications/eqB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simplifications/eqB.dhall @@ -0,0 +1,4 @@ +{ example0 = λ(x : Bool) → x +, example1 = λ(x : Bool) → x +, example2 = λ(x : Bool) → True +} diff --git a/tests/normalization/success/simplifications/ifThenElseA.dhall b/tests/normalization/success/simplifications/ifThenElseA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simplifications/ifThenElseA.dhall @@ -0,0 +1,3 @@ +{ example0 = λ(x : Bool) → if x then True else False +, example1 = λ(x : Bool) → λ(y : Text) → if x then y else y +} diff --git a/tests/normalization/success/simplifications/ifThenElseB.dhall b/tests/normalization/success/simplifications/ifThenElseB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simplifications/ifThenElseB.dhall @@ -0,0 +1,3 @@ +{ example0 = λ(x : Bool) → x +, example1 = λ(x : Bool) → λ(y : Text) → y +} diff --git a/tests/normalization/success/simplifications/neA.dhall b/tests/normalization/success/simplifications/neA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simplifications/neA.dhall @@ -0,0 +1,4 @@ +{ example0 = λ(x : Bool) → x != False +, example1 = λ(x : Bool) → False != x +, example2 = λ(x : Bool) → x != x +} diff --git a/tests/normalization/success/simplifications/neB.dhall b/tests/normalization/success/simplifications/neB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simplifications/neB.dhall @@ -0,0 +1,4 @@ +{ example0 = λ(x : Bool) → x +, example1 = λ(x : Bool) → x +, example2 = λ(x : Bool) → False +} diff --git a/tests/normalization/success/simplifications/orA.dhall b/tests/normalization/success/simplifications/orA.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simplifications/orA.dhall @@ -0,0 +1,6 @@ +{ example0 = λ(x : Bool) → x || True +, example1 = λ(x : Bool) → True || x +, example2 = λ(x : Bool) → x || False +, example3 = λ(x : Bool) → False || x +, example4 = λ(x : Bool) → x || x +} diff --git a/tests/normalization/success/simplifications/orB.dhall b/tests/normalization/success/simplifications/orB.dhall new file mode 100644 --- /dev/null +++ b/tests/normalization/success/simplifications/orB.dhall @@ -0,0 +1,6 @@ +{ example0 = λ(x : Bool) → True +, example1 = λ(x : Bool) → True +, example2 = λ(x : Bool) → x +, example3 = λ(x : Bool) → x +, example4 = λ(x : Bool) → x +} diff --git a/tests/normalization/tutorial/combineTypes/0A.dhall b/tests/normalization/tutorial/combineTypes/0A.dhall deleted file mode 100644 --- a/tests/normalization/tutorial/combineTypes/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ foo : { bar : Text } } ⩓ { foo : { baz : Bool }, qux : Integer } diff --git a/tests/normalization/tutorial/combineTypes/0B.dhall b/tests/normalization/tutorial/combineTypes/0B.dhall deleted file mode 100644 --- a/tests/normalization/tutorial/combineTypes/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ foo : { bar : Text, baz : Bool }, qux : Integer } diff --git a/tests/normalization/tutorial/projection/0A.dhall b/tests/normalization/tutorial/projection/0A.dhall deleted file mode 100644 --- a/tests/normalization/tutorial/projection/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ x = 1, y = True, z = "ABC" }.{ x, y } diff --git a/tests/normalization/tutorial/projection/0B.dhall b/tests/normalization/tutorial/projection/0B.dhall deleted file mode 100644 --- a/tests/normalization/tutorial/projection/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ x = 1, y = True } diff --git a/tests/parser/annotations.dhall b/tests/parser/annotations.dhall deleted file mode 100644 --- a/tests/parser/annotations.dhall +++ /dev/null @@ -1,4 +0,0 @@ -{ foo = ([] : List Integer) # [1, 2, 3] # ([1, 2, 3] : List Integer) -, bar = [] : Optional Integer -, baz = [1] : Optional Integer -} : { foo : List Integer, bar : Optional Integer, baz : Optional Integer } diff --git a/tests/parser/blockComment.dhall b/tests/parser/blockComment.dhall deleted file mode 100644 --- a/tests/parser/blockComment.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{- foo -} - -1 diff --git a/tests/parser/builtins.dhall b/tests/parser/builtins.dhall deleted file mode 100644 --- a/tests/parser/builtins.dhall +++ /dev/null @@ -1,31 +0,0 @@ - λ ( x - : { field0 : Bool - , field1 : Optional (Optional Bool) - , field2 : Natural - , field3 : Integer - , field4 : Double - , field5 : Text - , field6 : List (List Bool) - } - ) -→ { field00 = Natural/fold - , field01 = Natural/build - , field02 = Natural/isZero - , field03 = Natural/even - , field04 = Natural/odd - , field05 = Natural/toInteger - , field06 = Natural/show - , field07 = Integer/show - , field08 = Double/show - , field09 = List/build - , field10 = List/fold - , field11 = List/length - , field12 = List/head - , field13 = List/last - , field14 = List/indexed - , field15 = List/reverse - , field16 = Optional/fold - , field17 = Optional/build - , field18 = True - , field19 = False - } diff --git a/tests/parser/collectionImportType.dhall b/tests/parser/collectionImportType.dhall deleted file mode 100644 --- a/tests/parser/collectionImportType.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{ example0 = [] : Optional ./type.dhall -, example1 = [] : List ./type.dhall -} diff --git a/tests/parser/constructors.dhall b/tests/parser/constructors.dhall deleted file mode 100644 --- a/tests/parser/constructors.dhall +++ /dev/null @@ -1,1 +0,0 @@ -constructors < Left : Natural | Right : Bool > diff --git a/tests/parser/double.dhall b/tests/parser/double.dhall deleted file mode 100644 --- a/tests/parser/double.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 1.1, -1.1, 1e1, 1.1e1, -1.1 ] diff --git a/tests/parser/doubleQuotedString.dhall b/tests/parser/doubleQuotedString.dhall deleted file mode 100644 --- a/tests/parser/doubleQuotedString.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"ABC" diff --git a/tests/parser/environmentVariables.dhall b/tests/parser/environmentVariables.dhall deleted file mode 100644 --- a/tests/parser/environmentVariables.dhall +++ /dev/null @@ -1,5 +0,0 @@ -[ env:FOO - - -- Yes, this is legal -, env:"\"\\\a\b\f\n\r\t\v" -] diff --git a/tests/parser/escapedDoubleQuotedString.dhall b/tests/parser/escapedDoubleQuotedString.dhall deleted file mode 100644 --- a/tests/parser/escapedDoubleQuotedString.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"\\\"\$\\\/\b\f\n\r\t \u2200(a : Type) \u2192 a" diff --git a/tests/parser/escapedSingleQuotedString.dhall b/tests/parser/escapedSingleQuotedString.dhall deleted file mode 100644 --- a/tests/parser/escapedSingleQuotedString.dhall +++ /dev/null @@ -1,4 +0,0 @@ -'' -''${ -''' -'' diff --git a/tests/parser/failure/doubleBoundsNeg.dhall b/tests/parser/failure/doubleBoundsNeg.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/failure/doubleBoundsNeg.dhall @@ -0,0 +1,1 @@ +-179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0 diff --git a/tests/parser/failure/doubleBoundsPos.dhall b/tests/parser/failure/doubleBoundsPos.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/failure/doubleBoundsPos.dhall @@ -0,0 +1,1 @@ +179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0 diff --git a/tests/parser/failure/duplicateFields.dhall b/tests/parser/failure/duplicateFields.dhall deleted file mode 100644 --- a/tests/parser/failure/duplicateFields.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ a = 1, a = 2 } diff --git a/tests/parser/fields.dhall b/tests/parser/fields.dhall deleted file mode 100644 --- a/tests/parser/fields.dhall +++ /dev/null @@ -1,1 +0,0 @@ -({ foo = { bar = { baz = 1 } } }).foo. bar .baz diff --git a/tests/parser/forall.dhall b/tests/parser/forall.dhall deleted file mode 100644 --- a/tests/parser/forall.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(a : Type) → forall (b : Type) -> a diff --git a/tests/parser/functionType.dhall b/tests/parser/functionType.dhall deleted file mode 100644 --- a/tests/parser/functionType.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool → Bool -> Bool diff --git a/tests/parser/identifier.dhall b/tests/parser/identifier.dhall deleted file mode 100644 --- a/tests/parser/identifier.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(a : Type) → λ(a : Type) → a@1 diff --git a/tests/parser/ifThenElse.dhall b/tests/parser/ifThenElse.dhall deleted file mode 100644 --- a/tests/parser/ifThenElse.dhall +++ /dev/null @@ -1,1 +0,0 @@ -if True then 1 else 2 diff --git a/tests/parser/importAlt.dhall b/tests/parser/importAlt.dhall deleted file mode 100644 --- a/tests/parser/importAlt.dhall +++ /dev/null @@ -1,1 +0,0 @@ -env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2 diff --git a/tests/parser/interpolatedDoubleQuotedString.dhall b/tests/parser/interpolatedDoubleQuotedString.dhall deleted file mode 100644 --- a/tests/parser/interpolatedDoubleQuotedString.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"ABC${Integer/show 123}" diff --git a/tests/parser/interpolatedSingleQuotedString.dhall b/tests/parser/interpolatedSingleQuotedString.dhall deleted file mode 100644 --- a/tests/parser/interpolatedSingleQuotedString.dhall +++ /dev/null @@ -1,4 +0,0 @@ -'' -ABC -${Integer/show 123} -'' diff --git a/tests/parser/label.dhall b/tests/parser/label.dhall deleted file mode 100644 --- a/tests/parser/label.dhall +++ /dev/null @@ -1,2 +0,0 @@ -let _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ = 1 -in _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ diff --git a/tests/parser/lambda.dhall b/tests/parser/lambda.dhall deleted file mode 100644 --- a/tests/parser/lambda.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(a : Type) → \(b : Type) -> a diff --git a/tests/parser/largeExpression.dhall b/tests/parser/largeExpression.dhall deleted file mode 100644 --- a/tests/parser/largeExpression.dhall +++ /dev/null @@ -1,254 +0,0 @@ - λ ( 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) - → ( Optional/fold - Text - x.user - Text - (λ(user : Text) → user ++ "@" ++ x.host ++ "") - x.host - ++ " " - ++ ( 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 = - 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 - | Empty : {} - > - , NonEmpty = - λ(result : Text) - → < 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 - | Empty : {} - > - } - status - : < Empty : {} | NonEmpty : Text > - ) - < Empty = {=} | NonEmpty : Text > - ) - : 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 = element | Empty : {} > - , NonEmpty = - λ(result : Text) - → < NonEmpty = element ++ "," ++ result - | Empty : {} - > - } - status - : < Empty : {} | NonEmpty : Text > - ) - < Empty = {=} | NonEmpty : Text > - ) - : Text - ) - ++ " " - ++ ( merge - { Empty = λ(_ : {}) → "" - , NonEmpty = λ(result : Text) → result - } - ( List/fold - Text - x.mandatoryFeatures - < Empty : {} | NonEmpty : Text > - ( λ(element : Text) - → λ(status : < Empty : {} | NonEmpty : Text >) - → merge - { Empty = - λ(_ : {}) → < NonEmpty = element | Empty : {} > - , NonEmpty = - λ(result : Text) - → < NonEmpty = element ++ "," ++ result - | Empty : {} - > - } - status - : < Empty : {} | NonEmpty : Text > - ) - < Empty = {=} | NonEmpty : Text > - ) - : Text - ) - ++ "\n" - ) - ++ y - ) - "" diff --git a/tests/parser/let.dhall b/tests/parser/let.dhall deleted file mode 100644 --- a/tests/parser/let.dhall +++ /dev/null @@ -1,3 +0,0 @@ - let x = 1 -in let y : Integer = 2 -in x diff --git a/tests/parser/lineComment.dhall b/tests/parser/lineComment.dhall deleted file mode 100644 --- a/tests/parser/lineComment.dhall +++ /dev/null @@ -1,3 +0,0 @@ --- foo - -1 diff --git a/tests/parser/list.dhall b/tests/parser/list.dhall deleted file mode 100644 --- a/tests/parser/list.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ [1, 2, 3] -, [1, 2, 3] : List Integer -, [] : List Integer -] diff --git a/tests/parser/merge.dhall b/tests/parser/merge.dhall deleted file mode 100644 --- a/tests/parser/merge.dhall +++ /dev/null @@ -1,7 +0,0 @@ - λ(x : <>) -→ { bar = merge {=} x : Integer - , foo = - merge - { Left = λ(b : Bool) → b, Right = Natural/even } - < Left = True | Right : Natural > - } diff --git a/tests/parser/natural.dhall b/tests/parser/natural.dhall deleted file mode 100644 --- a/tests/parser/natural.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ +0, +1, +01, +10 ] diff --git a/tests/parser/nestedBlockComment.dhall b/tests/parser/nestedBlockComment.dhall deleted file mode 100644 --- a/tests/parser/nestedBlockComment.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{- foo {- bar -} baz -} - -1 diff --git a/tests/parser/operators.dhall b/tests/parser/operators.dhall deleted file mode 100644 --- a/tests/parser/operators.dhall +++ /dev/null @@ -1,2 +0,0 @@ - { foo = (False && Natural/even (+1 + +2 * +3)) || True == False != True } -∧ { bar = [ "ABC" ++ "DEF" ] # [ "GHI" ] } ⫽ { baz = True } diff --git a/tests/parser/parenthesizeUsing.dhall b/tests/parser/parenthesizeUsing.dhall deleted file mode 100644 --- a/tests/parser/parenthesizeUsing.dhall +++ /dev/null @@ -1,1 +0,0 @@ -https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate using (./a.dhall sha256:16173e984d35ee3ffd8b6b79167df89480e67d1cd03ea5d0fc93689e4d928e61) sha256:b0e3ec1797b32c80c0bcb7e8254b08c7e9e35e75e6b410c7ac21477ab90167ad diff --git a/tests/parser/pathTermination.dhall b/tests/parser/pathTermination.dhall deleted file mode 100644 --- a/tests/parser/pathTermination.dhall +++ /dev/null @@ -1,3 +0,0 @@ --- Verify that certain punctuation marks terminate paths correctly - λ(x : ./example) -→ ./example[./example, ./example{bar = ./example, qux = ./example}, ./example] diff --git a/tests/parser/paths.dhall b/tests/parser/paths.dhall deleted file mode 100644 --- a/tests/parser/paths.dhall +++ /dev/null @@ -1,5 +0,0 @@ -[ /absolute/path -, ./relative/path -, ~/home/anchored/path -, /ipfs/QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx/Prelude -] diff --git a/tests/parser/quotedLabel.dhall b/tests/parser/quotedLabel.dhall deleted file mode 100644 --- a/tests/parser/quotedLabel.dhall +++ /dev/null @@ -1,4 +0,0 @@ -{ example1 = let `let` = 1 in `let` -, example2 = let `:.` = 1 in `:.` -, example3 = let `$ref` = 1 in `$ref` -} diff --git a/tests/parser/record.dhall b/tests/parser/record.dhall deleted file mode 100644 --- a/tests/parser/record.dhall +++ /dev/null @@ -1,4 +0,0 @@ -{ foo = 1 -, bar = +2 -, baz = True -} : { foo : Integer, bar : Natural, baz : Bool } diff --git a/tests/parser/reservedPrefix.dhall b/tests/parser/reservedPrefix.dhall deleted file mode 100644 --- a/tests/parser/reservedPrefix.dhall +++ /dev/null @@ -1,1 +0,0 @@ -let TypeSynonym = Integer in 1 : TypeSynonym diff --git a/tests/parser/singleQuotedString.dhall b/tests/parser/singleQuotedString.dhall deleted file mode 100644 --- a/tests/parser/singleQuotedString.dhall +++ /dev/null @@ -1,4 +0,0 @@ -'' -ABC -DEF -'' diff --git a/tests/parser/sort.dhall b/tests/parser/sort.dhall deleted file mode 100644 --- a/tests/parser/sort.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Sort diff --git a/tests/parser/success/annotationsA.dhall b/tests/parser/success/annotationsA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/annotationsA.dhall @@ -0,0 +1,4 @@ +{ foo = ([] : List Integer) # [1, 2, 3] # ([1, 2, 3] : List Integer) +, bar = [] : Optional Integer +, baz = [1] : Optional Integer +} : { foo : List Integer, bar : Optional Integer, baz : Optional Integer } diff --git a/tests/parser/success/annotationsB.dhall b/tests/parser/success/annotationsB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/annotationsB.dhall @@ -0,0 +1,84 @@ +[ + 26, + [ + 8, + { + "foo": [ + 3, + 7, + [ + 3, + 7, + [ + 4, + "Integer" + ], + [ + 4, + null, + [ + 15, + 1 + ], + [ + 15, + 2 + ], + [ + 15, + 3 + ] + ] + ], + [ + 4, + null, + [ + 15, + 1 + ], + [ + 15, + 2 + ], + [ + 15, + 3 + ] + ] + ], + "bar": [ + 5, + "Integer" + ], + "baz": [ + 5, + "Integer", + [ + 15, + 1 + ] + ] + } + ], + [ + 7, + { + "foo": [ + 0, + "List", + "Integer" + ], + "bar": [ + 0, + "Optional", + "Integer" + ], + "baz": [ + 0, + "Optional", + "Integer" + ] + } + ] +] diff --git a/tests/parser/success/blockCommentA.dhall b/tests/parser/success/blockCommentA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/blockCommentA.dhall @@ -0,0 +1,3 @@ +{- foo -} + +1 diff --git a/tests/parser/success/blockCommentB.dhall b/tests/parser/success/blockCommentB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/blockCommentB.dhall @@ -0,0 +1,4 @@ +[ + 15, + 1 +] diff --git a/tests/parser/success/builtinsA.dhall b/tests/parser/success/builtinsA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/builtinsA.dhall @@ -0,0 +1,31 @@ + λ ( x + : { field0 : Bool + , field1 : Optional (Optional Bool) + , field2 : Natural + , field3 : Integer + , field4 : Double + , field5 : Text + , field6 : List (List Bool) + } + ) +→ { field00 = Natural/fold + , field01 = Natural/build + , field02 = Natural/isZero + , field03 = Natural/even + , field04 = Natural/odd + , field05 = Natural/toInteger + , field06 = Natural/show + , field07 = Integer/show + , field08 = Double/show + , field09 = List/build + , field10 = List/fold + , field11 = List/length + , field12 = List/head + , field13 = List/last + , field14 = List/indexed + , field15 = List/reverse + , field16 = Optional/fold + , field17 = Optional/build + , field18 = True + , field19 = False + } diff --git a/tests/parser/success/builtinsB.dhall b/tests/parser/success/builtinsB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/builtinsB.dhall @@ -0,0 +1,57 @@ +[ + 1, + "x", + [ + 7, + { + "field0": "Bool", + "field1": [ + 0, + "Optional", + [ + 0, + "Optional", + "Bool" + ] + ], + "field2": "Natural", + "field3": "Integer", + "field4": "Double", + "field5": "Text", + "field6": [ + 0, + "List", + [ + 0, + "List", + "Bool" + ] + ] + } + ], + [ + 8, + { + "field00": "Natural/fold", + "field01": "Natural/build", + "field02": "Natural/isZero", + "field03": "Natural/even", + "field04": "Natural/odd", + "field05": "Natural/toInteger", + "field06": "Natural/show", + "field07": "Integer/show", + "field08": "Double/show", + "field09": "List/build", + "field10": "List/fold", + "field11": "List/length", + "field12": "List/head", + "field13": "List/last", + "field14": "List/indexed", + "field15": "List/reverse", + "field16": "Optional/fold", + "field17": "Optional/build", + "field18": true, + "field19": false + } + ] +] diff --git a/tests/parser/success/collectionImportTypeA.dhall b/tests/parser/success/collectionImportTypeA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/collectionImportTypeA.dhall @@ -0,0 +1,3 @@ +{ example0 = [] : Optional ./type.dhall +, example1 = [] : List ./type.dhall +} diff --git a/tests/parser/success/collectionImportTypeB.dhall b/tests/parser/success/collectionImportTypeB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/collectionImportTypeB.dhall @@ -0,0 +1,21 @@ +[ + 8, + { + "example0": [ + 5, + [ + 24, + 3, + "type.dhall" + ] + ], + "example1": [ + 4, + [ + 24, + 3, + "type.dhall" + ] + ] + } +] diff --git a/tests/parser/success/constructorsA.dhall b/tests/parser/success/constructorsA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/constructorsA.dhall @@ -0,0 +1,1 @@ +constructors < Left : Natural | Right : Bool > diff --git a/tests/parser/success/constructorsB.dhall b/tests/parser/success/constructorsB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/constructorsB.dhall @@ -0,0 +1,10 @@ +[ + 13, + [ + 11, + { + "Left": "Natural", + "Right": "Bool" + } + ] +] diff --git a/tests/parser/success/doubleA.dhall b/tests/parser/success/doubleA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/doubleA.dhall @@ -0,0 +1,1 @@ +[ 1.1, -1.1, 1e1, 1.1e1, -1.1 ] diff --git a/tests/parser/success/doubleB.dhall b/tests/parser/success/doubleB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/doubleB.dhall @@ -0,0 +1,24 @@ +[ + 4, + null, + [ + 17, + 1.1 + ], + [ + 17, + -1.1 + ], + [ + 17, + 10.0 + ], + [ + 17, + 11.0 + ], + [ + 17, + -1.1 + ] +] diff --git a/tests/parser/success/doubleQuotedStringA.dhall b/tests/parser/success/doubleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/doubleQuotedStringA.dhall @@ -0,0 +1,1 @@ +"ABC" diff --git a/tests/parser/success/doubleQuotedStringB.dhall b/tests/parser/success/doubleQuotedStringB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/doubleQuotedStringB.dhall @@ -0,0 +1,4 @@ +[ + 18, + "ABC" +] diff --git a/tests/parser/success/environmentVariablesA.dhall b/tests/parser/success/environmentVariablesA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/environmentVariablesA.dhall @@ -0,0 +1,5 @@ +[ env:FOO + + -- Yes, this is legal +, env:"\"\\\a\b\f\n\r\t\v" +] diff --git a/tests/parser/success/environmentVariablesB.dhall b/tests/parser/success/environmentVariablesB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/environmentVariablesB.dhall @@ -0,0 +1,14 @@ +[ + 4, + null, + [ + 24, + 6, + "FOO" + ], + [ + 24, + 6, + "\\\"\\\\\\a\\b\\f\\n\\r\\t\\v" + ] +] diff --git a/tests/parser/success/escapedDoubleQuotedStringA.dhall b/tests/parser/success/escapedDoubleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/escapedDoubleQuotedStringA.dhall @@ -0,0 +1,1 @@ +"\\\"\$\\\/\b\f\n\r\t \u2200(a : Type) \u2192 a" diff --git a/tests/parser/success/escapedDoubleQuotedStringB.dhall b/tests/parser/success/escapedDoubleQuotedStringB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/escapedDoubleQuotedStringB.dhall @@ -0,0 +1,4 @@ +[ + 18, + "\\\"$\\/\b\f\n\r\t ∀(a : Type) → a" +] diff --git a/tests/parser/success/escapedSingleQuotedStringA.dhall b/tests/parser/success/escapedSingleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/escapedSingleQuotedStringA.dhall @@ -0,0 +1,4 @@ +'' +''${ +''' +'' diff --git a/tests/parser/success/escapedSingleQuotedStringB.dhall b/tests/parser/success/escapedSingleQuotedStringB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/escapedSingleQuotedStringB.dhall @@ -0,0 +1,4 @@ +[ + 18, + "${\n''\n" +] diff --git a/tests/parser/success/fieldsA.dhall b/tests/parser/success/fieldsA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/fieldsA.dhall @@ -0,0 +1,1 @@ +({ foo = { bar = { baz = 1 } } }).foo. bar .baz diff --git a/tests/parser/success/fieldsB.dhall b/tests/parser/success/fieldsB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/fieldsB.dhall @@ -0,0 +1,31 @@ +[ + 9, + [ + 9, + [ + 9, + [ + 8, + { + "foo": [ + 8, + { + "bar": [ + 8, + { + "baz": [ + 15, + 1 + ] + } + ] + } + ] + } + ], + "foo" + ], + "bar" + ], + "baz" +] diff --git a/tests/parser/success/forallA.dhall b/tests/parser/success/forallA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/forallA.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → forall (b : Type) -> a diff --git a/tests/parser/success/forallB.dhall b/tests/parser/success/forallB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/forallB.dhall @@ -0,0 +1,11 @@ +[ + 2, + "a", + "Type", + [ + 2, + "b", + "Type", + "a" + ] +] diff --git a/tests/parser/success/functionTypeA.dhall b/tests/parser/success/functionTypeA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/functionTypeA.dhall @@ -0,0 +1,1 @@ +Bool → Bool -> Bool diff --git a/tests/parser/success/functionTypeB.dhall b/tests/parser/success/functionTypeB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/functionTypeB.dhall @@ -0,0 +1,9 @@ +[ + 2, + "Bool", + [ + 2, + "Bool", + "Bool" + ] +] diff --git a/tests/parser/success/identifierA.dhall b/tests/parser/success/identifierA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/identifierA.dhall @@ -0,0 +1,1 @@ +λ(a : Type) → λ(a : Type) → a@1 diff --git a/tests/parser/success/identifierB.dhall b/tests/parser/success/identifierB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/identifierB.dhall @@ -0,0 +1,14 @@ +[ + 1, + "a", + "Type", + [ + 1, + "a", + "Type", + [ + "a", + 1 + ] + ] +] diff --git a/tests/parser/success/ifThenElseA.dhall b/tests/parser/success/ifThenElseA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/ifThenElseA.dhall @@ -0,0 +1,1 @@ +if True then 1 else 2 diff --git a/tests/parser/success/ifThenElseB.dhall b/tests/parser/success/ifThenElseB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/ifThenElseB.dhall @@ -0,0 +1,12 @@ +[ + 14, + true, + [ + 15, + 1 + ], + [ + 15, + 2 + ] +] diff --git a/tests/parser/success/importAltA.dhall b/tests/parser/success/importAltA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/importAltA.dhall @@ -0,0 +1,1 @@ +env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2 diff --git a/tests/parser/success/importAltB.dhall b/tests/parser/success/importAltB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/importAltB.dhall @@ -0,0 +1,39 @@ +[ + 3, + 11, + [ + 3, + 11, + [ + 3, + 11, + [ + 3, + 11, + [ + 24, + 6, + "UNSET1" + ], + [ + 24, + 6, + "UNSET2" + ] + ], + [ + 24, + 7 + ] + ], + [ + 24, + 6, + "UNSET3" + ] + ], + [ + 15, + 2 + ] +] diff --git a/tests/parser/success/interpolatedDoubleQuotedStringA.dhall b/tests/parser/success/interpolatedDoubleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/interpolatedDoubleQuotedStringA.dhall @@ -0,0 +1,1 @@ +"ABC${Integer/show 123}" diff --git a/tests/parser/success/interpolatedDoubleQuotedStringB.dhall b/tests/parser/success/interpolatedDoubleQuotedStringB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/interpolatedDoubleQuotedStringB.dhall @@ -0,0 +1,13 @@ +[ + 18, + "ABC", + [ + 0, + "Integer/show", + [ + 15, + 123 + ] + ], + "" +] diff --git a/tests/parser/success/interpolatedSingleQuotedStringA.dhall b/tests/parser/success/interpolatedSingleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/interpolatedSingleQuotedStringA.dhall @@ -0,0 +1,4 @@ +'' +ABC +${Integer/show 123} +'' diff --git a/tests/parser/success/interpolatedSingleQuotedStringB.dhall b/tests/parser/success/interpolatedSingleQuotedStringB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/interpolatedSingleQuotedStringB.dhall @@ -0,0 +1,13 @@ +[ + 18, + "ABC\n", + [ + 0, + "Integer/show", + [ + 15, + 123 + ] + ], + "\n" +] diff --git a/tests/parser/success/labelA.dhall b/tests/parser/success/labelA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/labelA.dhall @@ -0,0 +1,2 @@ +let _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ = 1 +in _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ diff --git a/tests/parser/success/labelB.dhall b/tests/parser/success/labelB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/labelB.dhall @@ -0,0 +1,10 @@ +[ + 25, + "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/", + null, + [ + 15, + 1 + ], + "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/" +] diff --git a/tests/parser/success/lambdaA.dhall b/tests/parser/success/lambdaA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/lambdaA.dhall @@ -0,0 +1,1 @@ +λ(a : Type) → \(b : Type) -> a diff --git a/tests/parser/success/lambdaB.dhall b/tests/parser/success/lambdaB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/lambdaB.dhall @@ -0,0 +1,11 @@ +[ + 1, + "a", + "Type", + [ + 1, + "b", + "Type", + "a" + ] +] diff --git a/tests/parser/success/largeExpressionA.dhall b/tests/parser/success/largeExpressionA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/largeExpressionA.dhall @@ -0,0 +1,254 @@ + λ ( 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) + → ( Optional/fold + Text + x.user + Text + (λ(user : Text) → user ++ "@" ++ x.host ++ "") + x.host + ++ " " + ++ ( 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 = + 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 + | Empty : {} + > + , NonEmpty = + λ(result : Text) + → < 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 + | Empty : {} + > + } + status + : < Empty : {} | NonEmpty : Text > + ) + < Empty = {=} | NonEmpty : Text > + ) + : 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 = element | Empty : {} > + , NonEmpty = + λ(result : Text) + → < NonEmpty = element ++ "," ++ result + | Empty : {} + > + } + status + : < Empty : {} | NonEmpty : Text > + ) + < Empty = {=} | NonEmpty : Text > + ) + : Text + ) + ++ " " + ++ ( merge + { Empty = λ(_ : {}) → "" + , NonEmpty = λ(result : Text) → result + } + ( List/fold + Text + x.mandatoryFeatures + < Empty : {} | NonEmpty : Text > + ( λ(element : Text) + → λ(status : < Empty : {} | NonEmpty : Text >) + → merge + { Empty = + λ(_ : {}) → < NonEmpty = element | Empty : {} > + , NonEmpty = + λ(result : Text) + → < NonEmpty = element ++ "," ++ result + | Empty : {} + > + } + status + : < Empty : {} | NonEmpty : Text > + ) + < Empty = {=} | NonEmpty : Text > + ) + : Text + ) + ++ "\n" + ) + ++ y + ) + "" diff --git a/tests/parser/success/largeExpressionB.dhall b/tests/parser/success/largeExpressionB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/largeExpressionB.dhall @@ -0,0 +1,1303 @@ +[ + 1, + "xs", + [ + 0, + "List", + [ + 7, + { + "cores": "Natural", + "host": "Text", + "key": "Text", + "mandatoryFeatures": [ + 0, + "List", + "Text" + ], + "platforms": [ + 0, + "List", + [ + 11, + { + "AArch64_Linux": [ + 7, + {} + ], + "ARMv5tel_Linux": [ + 7, + {} + ], + "ARMv7l_Linux": [ + 7, + {} + ], + "I686_Cygwin": [ + 7, + {} + ], + "I686_Linux": [ + 7, + {} + ], + "MIPS64el_Linux": [ + 7, + {} + ], + "PowerPC_Linux": [ + 7, + {} + ], + "X86_64_Cygwin": [ + 7, + {} + ], + "X86_64_Darwin": [ + 7, + {} + ], + "X86_64_FreeBSD": [ + 7, + {} + ], + "X86_64_Linux": [ + 7, + {} + ], + "X86_64_Solaris": [ + 7, + {} + ] + } + ] + ], + "speedFactor": "Natural", + "supportedFeatures": [ + 0, + "List", + "Text" + ], + "user": [ + 0, + "Optional", + "Text" + ] + } + ] + ], + [ + 0, + [ + 0, + [ + 0, + [ + 0, + [ + 0, + "List/fold", + [ + 7, + { + "cores": "Natural", + "host": "Text", + "key": "Text", + "mandatoryFeatures": [ + 0, + "List", + "Text" + ], + "platforms": [ + 0, + "List", + [ + 11, + { + "AArch64_Linux": [ + 7, + {} + ], + "ARMv5tel_Linux": [ + 7, + {} + ], + "ARMv7l_Linux": [ + 7, + {} + ], + "I686_Cygwin": [ + 7, + {} + ], + "I686_Linux": [ + 7, + {} + ], + "MIPS64el_Linux": [ + 7, + {} + ], + "PowerPC_Linux": [ + 7, + {} + ], + "X86_64_Cygwin": [ + 7, + {} + ], + "X86_64_Darwin": [ + 7, + {} + ], + "X86_64_FreeBSD": [ + 7, + {} + ], + "X86_64_Linux": [ + 7, + {} + ], + "X86_64_Solaris": [ + 7, + {} + ] + } + ] + ], + "speedFactor": "Natural", + "supportedFeatures": [ + 0, + "List", + "Text" + ], + "user": [ + 0, + "Optional", + "Text" + ] + } + ] + ], + "xs" + ], + "Text" + ], + [ + 1, + "x", + [ + 7, + { + "cores": "Natural", + "host": "Text", + "key": "Text", + "mandatoryFeatures": [ + 0, + "List", + "Text" + ], + "platforms": [ + 0, + "List", + [ + 11, + { + "AArch64_Linux": [ + 7, + {} + ], + "ARMv5tel_Linux": [ + 7, + {} + ], + "ARMv7l_Linux": [ + 7, + {} + ], + "I686_Cygwin": [ + 7, + {} + ], + "I686_Linux": [ + 7, + {} + ], + "MIPS64el_Linux": [ + 7, + {} + ], + "PowerPC_Linux": [ + 7, + {} + ], + "X86_64_Cygwin": [ + 7, + {} + ], + "X86_64_Darwin": [ + 7, + {} + ], + "X86_64_FreeBSD": [ + 7, + {} + ], + "X86_64_Linux": [ + 7, + {} + ], + "X86_64_Solaris": [ + 7, + {} + ] + } + ] + ], + "speedFactor": "Natural", + "supportedFeatures": [ + 0, + "List", + "Text" + ], + "user": [ + 0, + "Optional", + "Text" + ] + } + ], + [ + 1, + "y", + "Text", + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + [ + 0, + [ + 0, + [ + 0, + [ + 0, + [ + 0, + "Optional/fold", + "Text" + ], + [ + 9, + "x", + "user" + ] + ], + "Text" + ], + [ + 1, + "user", + "Text", + [ + 3, + 6, + [ + 3, + 6, + [ + 3, + 6, + "user", + [ + 18, + "@" + ] + ], + [ + 9, + "x", + "host" + ] + ], + [ + 18, + "" + ] + ] + ] + ], + [ + 9, + "x", + "host" + ] + ], + [ + 18, + " " + ] + ], + [ + 6, + [ + 8, + { + "Empty": [ + 1, + [ + 7, + {} + ], + [ + 18, + "" + ] + ], + "NonEmpty": [ + 1, + "result", + "Text", + "result" + ] + } + ], + [ + 0, + [ + 0, + [ + 0, + [ + 0, + [ + 0, + "List/fold", + [ + 11, + { + "AArch64_Linux": [ + 7, + {} + ], + "ARMv5tel_Linux": [ + 7, + {} + ], + "ARMv7l_Linux": [ + 7, + {} + ], + "I686_Cygwin": [ + 7, + {} + ], + "I686_Linux": [ + 7, + {} + ], + "MIPS64el_Linux": [ + 7, + {} + ], + "PowerPC_Linux": [ + 7, + {} + ], + "X86_64_Cygwin": [ + 7, + {} + ], + "X86_64_Darwin": [ + 7, + {} + ], + "X86_64_FreeBSD": [ + 7, + {} + ], + "X86_64_Linux": [ + 7, + {} + ], + "X86_64_Solaris": [ + 7, + {} + ] + } + ] + ], + [ + 9, + "x", + "platforms" + ] + ], + [ + 11, + { + "Empty": [ + 7, + {} + ], + "NonEmpty": "Text" + } + ] + ], + [ + 1, + "element", + [ + 11, + { + "AArch64_Linux": [ + 7, + {} + ], + "ARMv5tel_Linux": [ + 7, + {} + ], + "ARMv7l_Linux": [ + 7, + {} + ], + "I686_Cygwin": [ + 7, + {} + ], + "I686_Linux": [ + 7, + {} + ], + "MIPS64el_Linux": [ + 7, + {} + ], + "PowerPC_Linux": [ + 7, + {} + ], + "X86_64_Cygwin": [ + 7, + {} + ], + "X86_64_Darwin": [ + 7, + {} + ], + "X86_64_FreeBSD": [ + 7, + {} + ], + "X86_64_Linux": [ + 7, + {} + ], + "X86_64_Solaris": [ + 7, + {} + ] + } + ], + [ + 1, + "status", + [ + 11, + { + "Empty": [ + 7, + {} + ], + "NonEmpty": "Text" + } + ], + [ + 6, + [ + 8, + { + "Empty": [ + 1, + [ + 7, + {} + ], + [ + 12, + "NonEmpty", + [ + 6, + [ + 8, + { + "AArch64_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "aarch64-linux" + ] + ], + "ARMv5tel_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "armv5tel-linux" + ] + ], + "ARMv7l_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "armv7l-linux" + ] + ], + "I686_Cygwin": [ + 1, + [ + 7, + {} + ], + [ + 18, + "i686-cygwin" + ] + ], + "I686_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "i686-linux" + ] + ], + "MIPS64el_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "mips64el-linux" + ] + ], + "PowerPC_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "powerpc-linux" + ] + ], + "X86_64_Cygwin": [ + 1, + [ + 7, + {} + ], + [ + 18, + "x86_64-cygwin" + ] + ], + "X86_64_Darwin": [ + 1, + [ + 7, + {} + ], + [ + 18, + "x86_64-darwin" + ] + ], + "X86_64_FreeBSD": [ + 1, + [ + 7, + {} + ], + [ + 18, + "x86_64-freebsd" + ] + ], + "X86_64_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "x86_64-linux" + ] + ], + "X86_64_Solaris": [ + 1, + [ + 7, + {} + ], + [ + 18, + "x86_64-solaris" + ] + ] + } + ], + "element" + ], + { + "Empty": [ + 7, + {} + ] + } + ] + ], + "NonEmpty": [ + 1, + "result", + "Text", + [ + 12, + "NonEmpty", + [ + 3, + 6, + [ + 3, + 6, + [ + 6, + [ + 8, + { + "AArch64_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "aarch64-linux" + ] + ], + "ARMv5tel_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "armv5tel-linux" + ] + ], + "ARMv7l_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "armv7l-linux" + ] + ], + "I686_Cygwin": [ + 1, + [ + 7, + {} + ], + [ + 18, + "i686-cygwin" + ] + ], + "I686_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "i686-linux" + ] + ], + "MIPS64el_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "mips64el-linux" + ] + ], + "PowerPC_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "powerpc-linux" + ] + ], + "X86_64_Cygwin": [ + 1, + [ + 7, + {} + ], + [ + 18, + "x86_64-cygwin" + ] + ], + "X86_64_Darwin": [ + 1, + [ + 7, + {} + ], + [ + 18, + "x86_64-darwin" + ] + ], + "X86_64_FreeBSD": [ + 1, + [ + 7, + {} + ], + [ + 18, + "x86_64-freebsd" + ] + ], + "X86_64_Linux": [ + 1, + [ + 7, + {} + ], + [ + 18, + "x86_64-linux" + ] + ], + "X86_64_Solaris": [ + 1, + [ + 7, + {} + ], + [ + 18, + "x86_64-solaris" + ] + ] + } + ], + "element" + ], + [ + 18, + "," + ] + ], + "result" + ], + { + "Empty": [ + 7, + {} + ] + } + ] + ] + } + ], + "status", + [ + 11, + { + "Empty": [ + 7, + {} + ], + "NonEmpty": "Text" + } + ] + ] + ] + ] + ], + [ + 12, + "Empty", + [ + 8, + {} + ], + { + "NonEmpty": "Text" + } + ] + ], + "Text" + ] + ], + [ + 18, + " " + ] + ], + [ + 9, + "x", + "key" + ] + ], + [ + 18, + " " + ] + ], + [ + 0, + "Integer/show", + [ + 0, + "Natural/toInteger", + [ + 9, + "x", + "cores" + ] + ] + ] + ], + [ + 18, + " " + ] + ], + [ + 0, + "Integer/show", + [ + 0, + "Natural/toInteger", + [ + 9, + "x", + "speedFactor" + ] + ] + ] + ], + [ + 18, + " " + ] + ], + [ + 6, + [ + 8, + { + "Empty": [ + 1, + [ + 7, + {} + ], + [ + 18, + "" + ] + ], + "NonEmpty": [ + 1, + "result", + "Text", + "result" + ] + } + ], + [ + 0, + [ + 0, + [ + 0, + [ + 0, + [ + 0, + "List/fold", + "Text" + ], + [ + 9, + "x", + "supportedFeatures" + ] + ], + [ + 11, + { + "Empty": [ + 7, + {} + ], + "NonEmpty": "Text" + } + ] + ], + [ + 1, + "element", + "Text", + [ + 1, + "status", + [ + 11, + { + "Empty": [ + 7, + {} + ], + "NonEmpty": "Text" + } + ], + [ + 6, + [ + 8, + { + "Empty": [ + 1, + [ + 7, + {} + ], + [ + 12, + "NonEmpty", + "element", + { + "Empty": [ + 7, + {} + ] + } + ] + ], + "NonEmpty": [ + 1, + "result", + "Text", + [ + 12, + "NonEmpty", + [ + 3, + 6, + [ + 3, + 6, + "element", + [ + 18, + "," + ] + ], + "result" + ], + { + "Empty": [ + 7, + {} + ] + } + ] + ] + } + ], + "status", + [ + 11, + { + "Empty": [ + 7, + {} + ], + "NonEmpty": "Text" + } + ] + ] + ] + ] + ], + [ + 12, + "Empty", + [ + 8, + {} + ], + { + "NonEmpty": "Text" + } + ] + ], + "Text" + ] + ], + [ + 18, + " " + ] + ], + [ + 6, + [ + 8, + { + "Empty": [ + 1, + [ + 7, + {} + ], + [ + 18, + "" + ] + ], + "NonEmpty": [ + 1, + "result", + "Text", + "result" + ] + } + ], + [ + 0, + [ + 0, + [ + 0, + [ + 0, + [ + 0, + "List/fold", + "Text" + ], + [ + 9, + "x", + "mandatoryFeatures" + ] + ], + [ + 11, + { + "Empty": [ + 7, + {} + ], + "NonEmpty": "Text" + } + ] + ], + [ + 1, + "element", + "Text", + [ + 1, + "status", + [ + 11, + { + "Empty": [ + 7, + {} + ], + "NonEmpty": "Text" + } + ], + [ + 6, + [ + 8, + { + "Empty": [ + 1, + [ + 7, + {} + ], + [ + 12, + "NonEmpty", + "element", + { + "Empty": [ + 7, + {} + ] + } + ] + ], + "NonEmpty": [ + 1, + "result", + "Text", + [ + 12, + "NonEmpty", + [ + 3, + 6, + [ + 3, + 6, + "element", + [ + 18, + "," + ] + ], + "result" + ], + { + "Empty": [ + 7, + {} + ] + } + ] + ] + } + ], + "status", + [ + 11, + { + "Empty": [ + 7, + {} + ], + "NonEmpty": "Text" + } + ] + ] + ] + ] + ], + [ + 12, + "Empty", + [ + 8, + {} + ], + { + "NonEmpty": "Text" + } + ] + ], + "Text" + ] + ], + [ + 18, + "\n" + ] + ], + "y" + ] + ] + ] + ], + [ + 18, + "" + ] + ] +] diff --git a/tests/parser/success/letA.dhall b/tests/parser/success/letA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/letA.dhall @@ -0,0 +1,3 @@ + let x = 1 +in let y : Integer = 2 +in x diff --git a/tests/parser/success/letB.dhall b/tests/parser/success/letB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/letB.dhall @@ -0,0 +1,19 @@ +[ + 25, + "x", + null, + [ + 15, + 1 + ], + [ + 25, + "y", + "Integer", + [ + 15, + 2 + ], + "x" + ] +] diff --git a/tests/parser/success/lineCommentA.dhall b/tests/parser/success/lineCommentA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/lineCommentA.dhall @@ -0,0 +1,3 @@ +-- foo + +1 diff --git a/tests/parser/success/lineCommentB.dhall b/tests/parser/success/lineCommentB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/lineCommentB.dhall @@ -0,0 +1,4 @@ +[ + 15, + 1 +] diff --git a/tests/parser/success/listA.dhall b/tests/parser/success/listA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/listA.dhall @@ -0,0 +1,4 @@ +[ [1, 2, 3] +, [1, 2, 3] : List Integer +, [] : List Integer +] diff --git a/tests/parser/success/listB.dhall b/tests/parser/success/listB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/listB.dhall @@ -0,0 +1,40 @@ +[ + 4, + null, + [ + 4, + null, + [ + 15, + 1 + ], + [ + 15, + 2 + ], + [ + 15, + 3 + ] + ], + [ + 4, + null, + [ + 15, + 1 + ], + [ + 15, + 2 + ], + [ + 15, + 3 + ] + ], + [ + 4, + "Integer" + ] +] diff --git a/tests/parser/success/mergeA.dhall b/tests/parser/success/mergeA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/mergeA.dhall @@ -0,0 +1,7 @@ + λ(x : <>) +→ { bar = merge {=} x : Integer + , foo = + merge + { Left = λ(b : Bool) → b, Right = Natural/even } + < Left = True | Right : Natural > + } diff --git a/tests/parser/success/mergeB.dhall b/tests/parser/success/mergeB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/mergeB.dhall @@ -0,0 +1,45 @@ +[ + 1, + "x", + [ + 11, + {} + ], + [ + 8, + { + "bar": [ + 6, + [ + 8, + {} + ], + "x", + "Integer" + ], + "foo": [ + 6, + [ + 8, + { + "Left": [ + 1, + "b", + "Bool", + "b" + ], + "Right": "Natural/even" + } + ], + [ + 12, + "Left", + true, + { + "Right": "Natural" + } + ] + ] + } + ] +] diff --git a/tests/parser/success/multiletA.dhall b/tests/parser/success/multiletA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/multiletA.dhall @@ -0,0 +1,3 @@ +let a = 1 +let b = 2 +in a + b diff --git a/tests/parser/success/multiletB.dhall b/tests/parser/success/multiletB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/multiletB.dhall @@ -0,0 +1,21 @@ +[ + 25, + "a", + null, + [ + 15, + 1 + ], + "b", + null, + [ + 15, + 2 + ], + [ + 3, + 4, + "a", + "b" + ] +] diff --git a/tests/parser/success/naturalA.dhall b/tests/parser/success/naturalA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/naturalA.dhall @@ -0,0 +1,1 @@ +[ +0, +1, +01, +10 ] diff --git a/tests/parser/success/naturalB.dhall b/tests/parser/success/naturalB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/naturalB.dhall @@ -0,0 +1,20 @@ +[ + 4, + null, + [ + 16, + 0 + ], + [ + 16, + 1 + ], + [ + 16, + 1 + ], + [ + 16, + 10 + ] +] diff --git a/tests/parser/success/nestedBlockCommentA.dhall b/tests/parser/success/nestedBlockCommentA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/nestedBlockCommentA.dhall @@ -0,0 +1,3 @@ +{- foo {- bar -} baz -} + +1 diff --git a/tests/parser/success/nestedBlockCommentB.dhall b/tests/parser/success/nestedBlockCommentB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/nestedBlockCommentB.dhall @@ -0,0 +1,4 @@ +[ + 15, + 1 +] diff --git a/tests/parser/success/operatorsA.dhall b/tests/parser/success/operatorsA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/operatorsA.dhall @@ -0,0 +1,2 @@ + { foo = (False && Natural/even (+1 + +2 * +3)) || True == False != True } +∧ { bar = [ "ABC" ++ "DEF" ] # [ "GHI" ] } ⫽ { baz = True } diff --git a/tests/parser/success/operatorsB.dhall b/tests/parser/success/operatorsB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/operatorsB.dhall @@ -0,0 +1,96 @@ +[ + 3, + 8, + [ + 8, + { + "foo": [ + 3, + 0, + [ + 3, + 1, + false, + [ + 0, + "Natural/even", + [ + 3, + 4, + [ + 16, + 1 + ], + [ + 3, + 5, + [ + 16, + 2 + ], + [ + 16, + 3 + ] + ] + ] + ] + ], + [ + 3, + 3, + [ + 3, + 2, + true, + false + ], + true + ] + ] + } + ], + [ + 3, + 9, + [ + 8, + { + "bar": [ + 3, + 7, + [ + 4, + null, + [ + 3, + 6, + [ + 18, + "ABC" + ], + [ + 18, + "DEF" + ] + ] + ], + [ + 4, + null, + [ + 18, + "GHI" + ] + ] + ] + } + ], + [ + 8, + { + "baz": true + } + ] + ] +] diff --git a/tests/parser/success/parenthesizeUsingA.dhall b/tests/parser/success/parenthesizeUsingA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/parenthesizeUsingA.dhall @@ -0,0 +1,1 @@ +https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate using (./a.dhall sha256:16173e984d35ee3ffd8b6b79167df89480e67d1cd03ea5d0fc93689e4d928e61) sha256:b0e3ec1797b32c80c0bcb7e8254b08c7e9e35e75e6b410c7ac21477ab90167ad diff --git a/tests/parser/success/parenthesizeUsingB.dhall b/tests/parser/success/parenthesizeUsingB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/parenthesizeUsingB.dhall @@ -0,0 +1,12 @@ +[ + 24, + 1, + "raw.githubusercontent.com", + "dhall-lang", + "Prelude", + "c79c2bc3c46f129cc5b6d594ce298a381bcae92c", + "List", + "replicate", + null, + null +] diff --git a/tests/parser/success/pathTerminationA.dhall b/tests/parser/success/pathTerminationA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/pathTerminationA.dhall @@ -0,0 +1,3 @@ +-- Verify that certain punctuation marks terminate paths correctly + λ(x : ./example) +→ ./example[./example, ./example{bar = ./example, qux = ./example}, ./example] diff --git a/tests/parser/success/pathTerminationB.dhall b/tests/parser/success/pathTerminationB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/pathTerminationB.dhall @@ -0,0 +1,67 @@ +[ + 1, + "x", + [ + 24, + 3, + "example" + ], + [ + 0, + [ + 24, + 3, + "example" + ], + [ + 4, + null, + [ + 24, + 3, + "example" + ], + [ + 0, + [ + 24, + 3, + "example" + ], + [ + 8, + { + "bar": [ + 0, + [ + 24, + 3, + "example" + ], + [ + 12, + "baz", + [ + 24, + 3, + "example" + ], + {} + ] + ], + "qux": [ + 24, + 3, + "example" + ] + } + ] + ], + [ + 24, + 3, + "example" + ] + ] + ] +] diff --git a/tests/parser/success/pathsA.dhall b/tests/parser/success/pathsA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/pathsA.dhall @@ -0,0 +1,5 @@ +[ /absolute/path +, ./relative/path +, ~/home/anchored/path +, /ipfs/QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx/Prelude +] diff --git a/tests/parser/success/pathsB.dhall b/tests/parser/success/pathsB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/pathsB.dhall @@ -0,0 +1,30 @@ +[ + 4, + null, + [ + 24, + 2, + "absolute", + "path" + ], + [ + 24, + 3, + "relative", + "path" + ], + [ + 24, + 5, + "home", + "anchored", + "path" + ], + [ + 24, + 2, + "ipfs", + "QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx", + "Prelude" + ] +] diff --git a/tests/parser/success/quotedLabelA.dhall b/tests/parser/success/quotedLabelA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/quotedLabelA.dhall @@ -0,0 +1,4 @@ +{ example1 = let `let` = 1 in `let` +, example2 = let `:.` = 1 in `:.` +, example3 = let `$ref` = 1 in `$ref` +} diff --git a/tests/parser/success/quotedLabelB.dhall b/tests/parser/success/quotedLabelB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/quotedLabelB.dhall @@ -0,0 +1,35 @@ +[ + 8, + { + "example1": [ + 25, + "let", + null, + [ + 15, + 1 + ], + "let" + ], + "example2": [ + 25, + ":.", + null, + [ + 15, + 1 + ], + ":." + ], + "example3": [ + 25, + "$ref", + null, + [ + 15, + 1 + ], + "$ref" + ] + } +] diff --git a/tests/parser/success/quotedPathsA.dhall b/tests/parser/success/quotedPathsA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/quotedPathsA.dhall @@ -0,0 +1,3 @@ +{ example0 = /"foo"/bar/"baz qux" +, example1 = https://example.com/foo/"bar?baz"?qux +} diff --git a/tests/parser/success/quotedPathsB.dhall b/tests/parser/success/quotedPathsB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/quotedPathsB.dhall @@ -0,0 +1,21 @@ +[ + 8, + { + "example0": [ + 24, + 2, + "foo", + "bar", + "baz qux" + ], + "example1": [ + 24, + 1, + "example.com", + "foo", + "bar?baz", + "qux", + null + ] + } +] diff --git a/tests/parser/success/recordA.dhall b/tests/parser/success/recordA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/recordA.dhall @@ -0,0 +1,4 @@ +{ foo = 1 +, bar = +2 +, baz = True +} : { foo : Integer, bar : Natural, baz : Bool } diff --git a/tests/parser/success/recordB.dhall b/tests/parser/success/recordB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/recordB.dhall @@ -0,0 +1,25 @@ +[ + 26, + [ + 8, + { + "foo": [ + 15, + 1 + ], + "bar": [ + 16, + 2 + ], + "baz": true + } + ], + [ + 7, + { + "foo": "Integer", + "bar": "Natural", + "baz": "Bool" + } + ] +] diff --git a/tests/parser/success/reservedPrefixA.dhall b/tests/parser/success/reservedPrefixA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/reservedPrefixA.dhall @@ -0,0 +1,1 @@ +let TypeSynonym = Integer in 1 : TypeSynonym diff --git a/tests/parser/success/reservedPrefixB.dhall b/tests/parser/success/reservedPrefixB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/reservedPrefixB.dhall @@ -0,0 +1,14 @@ +[ + 25, + "TypeSynonym", + null, + "Integer", + [ + 26, + [ + 15, + 1 + ], + "TypeSynonym" + ] +] diff --git a/tests/parser/success/singleQuotedStringA.dhall b/tests/parser/success/singleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/singleQuotedStringA.dhall @@ -0,0 +1,4 @@ +'' +ABC +DEF +'' diff --git a/tests/parser/success/singleQuotedStringB.dhall b/tests/parser/success/singleQuotedStringB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/singleQuotedStringB.dhall @@ -0,0 +1,4 @@ +[ + 18, + "ABC\nDEF\n" +] diff --git a/tests/parser/success/sortA.dhall b/tests/parser/success/sortA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/sortA.dhall @@ -0,0 +1,1 @@ +Sort diff --git a/tests/parser/success/sortB.dhall b/tests/parser/success/sortB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/sortB.dhall @@ -0,0 +1,1 @@ +"Sort" diff --git a/tests/parser/success/templateA.dhall b/tests/parser/success/templateA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/templateA.dhall @@ -0,0 +1,13 @@ + \(record : { name : Text + , value : Double + , taxed_value : Double + , in_ca : Bool + } + ) -> '' +Hello ${record.name} +You have just won ${Double/show record.value} dollars! +${ if record.in_ca + then "Well, ${Double/show record.taxed_value} dollars, after taxes" + else "" + } +'' diff --git a/tests/parser/success/templateB.dhall b/tests/parser/success/templateB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/templateB.dhall @@ -0,0 +1,60 @@ +[ + 1, + "record", + [ + 7, + { + "name": "Text", + "value": "Double", + "taxed_value": "Double", + "in_ca": "Bool" + } + ], + [ + 18, + "Hello ", + [ + 9, + "record", + "name" + ], + "\nYou have just won ", + [ + 0, + "Double/show", + [ + 9, + "record", + "value" + ] + ], + " dollars!\n", + [ + 14, + [ + 9, + "record", + "in_ca" + ], + [ + 18, + "Well, ", + [ + 0, + "Double/show", + [ + 9, + "record", + "taxed_value" + ] + ], + " dollars, after taxes" + ], + [ + 18, + "" + ] + ], + "\n" + ] +] diff --git a/tests/parser/success/unicodeCommentA.dhall b/tests/parser/success/unicodeCommentA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/unicodeCommentA.dhall @@ -0,0 +1,3 @@ +{- ∀(a : Type) → a -} + +1 diff --git a/tests/parser/success/unicodeCommentB.dhall b/tests/parser/success/unicodeCommentB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/unicodeCommentB.dhall @@ -0,0 +1,4 @@ +[ + 15, + 1 +] diff --git a/tests/parser/success/unicodeDoubleQuotedStringA.dhall b/tests/parser/success/unicodeDoubleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/unicodeDoubleQuotedStringA.dhall @@ -0,0 +1,1 @@ +"∀(a : Type) → a" diff --git a/tests/parser/success/unicodeDoubleQuotedStringB.dhall b/tests/parser/success/unicodeDoubleQuotedStringB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/unicodeDoubleQuotedStringB.dhall @@ -0,0 +1,4 @@ +[ + 18, + "∀(a : Type) → a" +] diff --git a/tests/parser/success/unionA.dhall b/tests/parser/success/unionA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/unionA.dhall @@ -0,0 +1,4 @@ +< A : { } +| B = { = } +| C : {} +> : < A : {} | B : {} | C : {} > diff --git a/tests/parser/success/unionB.dhall b/tests/parser/success/unionB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/unionB.dhall @@ -0,0 +1,38 @@ +[ + 26, + [ + 12, + "B", + [ + 8, + {} + ], + { + "A": [ + 7, + {} + ], + "C": [ + 7, + {} + ] + } + ], + [ + 11, + { + "A": [ + 7, + {} + ], + "B": [ + 7, + {} + ], + "C": [ + 7, + {} + ] + } + ] +] diff --git a/tests/parser/success/urlsA.dhall b/tests/parser/success/urlsA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/urlsA.dhall @@ -0,0 +1,12 @@ +[ http://example.com/someFile.dhall +, https://john:doe@example.com:8080/foo/bar?qux=0#xyzzy +, http://prelude.dhall-lang.org/package.dhall +, https://ipfs.io/ipfs/QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx/Prelude +, https://raw.githubusercontent.com/dhall-lang/dhall-haskell/18e4e9a18dc53271146df3ccf5b4177c3552236b/examples/True +, https://127.0.0.1/index.dhall +, https://[::]/index.dhall +, https://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]/tutorial.dhall + + -- Yes, this is legal +, https://-._~%2C!$&'()*+,;=:@-._~%2C!$&'()*+,;=:/foo?/-._~%2C!$&'()*+,;=:@/?#/-._~%2C!$&'()*+,;=:@/? +] diff --git a/tests/parser/success/urlsB.dhall b/tests/parser/success/urlsB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/urlsB.dhall @@ -0,0 +1,83 @@ +[ + 4, + null, + [ + 24, + 0, + "example.com", + "someFile.dhall", + null, + null + ], + [ + 24, + 1, + "john:doe@example.com:8080", + "foo", + "bar", + "qux=0", + "xyzzy" + ], + [ + 24, + 0, + "prelude.dhall-lang.org", + "package.dhall", + null, + null + ], + [ + 24, + 1, + "ipfs.io", + "ipfs", + "QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx", + "Prelude", + null, + null + ], + [ + 24, + 1, + "raw.githubusercontent.com", + "dhall-lang", + "dhall-haskell", + "18e4e9a18dc53271146df3ccf5b4177c3552236b", + "examples", + "True", + null, + null + ], + [ + 24, + 1, + "127.0.0.1", + "index.dhall", + null, + null + ], + [ + 24, + 1, + "[::]", + "index.dhall", + null, + null + ], + [ + 24, + 1, + "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", + "tutorial.dhall", + null, + null + ], + [ + 24, + 1, + "-._~%2C!$&'()*+,;=:@-._~%2C!$&'()*+,;=:", + "foo", + "/-._~%2C!$&'()*+,;=:@/?", + "/-._~%2C!$&'()*+,;=:@/?" + ] +] diff --git a/tests/parser/success/whitespaceA.dhall b/tests/parser/success/whitespaceA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/whitespaceA.dhall @@ -0,0 +1,3 @@ + +1 + diff --git a/tests/parser/success/whitespaceB.dhall b/tests/parser/success/whitespaceB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/whitespaceB.dhall @@ -0,0 +1,4 @@ +[ + 15, + 1 +] diff --git a/tests/parser/success/whitespaceBuffetA.dhall b/tests/parser/success/whitespaceBuffetA.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/whitespaceBuffetA.dhall @@ -0,0 +1,9 @@ + -- This + + Natural/even {- + +{- file +-} + has + + -} +2 -- mixed {- line endings -} diff --git a/tests/parser/success/whitespaceBuffetB.dhall b/tests/parser/success/whitespaceBuffetB.dhall new file mode 100644 --- /dev/null +++ b/tests/parser/success/whitespaceBuffetB.dhall @@ -0,0 +1,8 @@ +[ + 0, + "Natural/even", + [ + 16, + 2 + ] +] diff --git a/tests/parser/template.dhall b/tests/parser/template.dhall deleted file mode 100644 --- a/tests/parser/template.dhall +++ /dev/null @@ -1,13 +0,0 @@ - \(record : { name : Text - , value : Double - , taxed_value : Double - , in_ca : Bool - } - ) -> '' -Hello ${record.name} -You have just won ${Double/show record.value} dollars! -${ if record.in_ca - then "Well, ${Double/show record.taxed_value} dollars, after taxes" - else "" - } -'' diff --git a/tests/parser/unicodeComment.dhall b/tests/parser/unicodeComment.dhall deleted file mode 100644 --- a/tests/parser/unicodeComment.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{- ∀(a : Type) → a -} - -1 diff --git a/tests/parser/unicodeDoubleQuotedString.dhall b/tests/parser/unicodeDoubleQuotedString.dhall deleted file mode 100644 --- a/tests/parser/unicodeDoubleQuotedString.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"∀(a : Type) → a" diff --git a/tests/parser/union.dhall b/tests/parser/union.dhall deleted file mode 100644 --- a/tests/parser/union.dhall +++ /dev/null @@ -1,4 +0,0 @@ -< A : { } -| B = { = } -| C : {} -> : < A : {} | B : {} | C : {} > diff --git a/tests/parser/urls.dhall b/tests/parser/urls.dhall deleted file mode 100644 --- a/tests/parser/urls.dhall +++ /dev/null @@ -1,12 +0,0 @@ -[ http://example.com/someFile.dhall -, https://john:doe@example.com:8080/foo/bar?qux=0#xyzzy -, http://prelude.dhall-lang.org/package.dhall -, https://ipfs.io/ipfs/QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx/Prelude -, https://raw.githubusercontent.com/dhall-lang/dhall-haskell/18e4e9a18dc53271146df3ccf5b4177c3552236b/examples/True -, https://127.0.0.1/index.dhall -, https://[::]/index.dhall -, https://[2001:0db8:85a3:0000:0000:8a2e:0370:7334]/tutorial.dhall - - -- Yes, this is legal -, https://-._~%2C!$&'()*+,;=:@-._~%2C!$&'()*+,;=:/foo?/-._~%2C!$&'()*+,;=:@/?#/-._~%2C!$&'()*+,;=:@/? -] diff --git a/tests/parser/whitespace.dhall b/tests/parser/whitespace.dhall deleted file mode 100644 --- a/tests/parser/whitespace.dhall +++ /dev/null @@ -1,3 +0,0 @@ - -1 - diff --git a/tests/parser/whitespaceBuffet.dhall b/tests/parser/whitespaceBuffet.dhall deleted file mode 100644 --- a/tests/parser/whitespaceBuffet.dhall +++ /dev/null @@ -1,9 +0,0 @@ - -- This - - Natural/even {- - -{- file --} - has - - -} +2 -- mixed {- line endings -} diff --git a/tests/typecheck/alternativesAreTypesA.dhall b/tests/typecheck/alternativesAreTypesA.dhall deleted file mode 100644 --- a/tests/typecheck/alternativesAreTypesA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -< Left = List | Right : Type > diff --git a/tests/typecheck/alternativesAreTypesB.dhall b/tests/typecheck/alternativesAreTypesB.dhall deleted file mode 100644 --- a/tests/typecheck/alternativesAreTypesB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -< Left : Type → Type | Right : Type > diff --git a/tests/typecheck/anonymousFunctionsInTypesA.dhall b/tests/typecheck/anonymousFunctionsInTypesA.dhall deleted file mode 100644 --- a/tests/typecheck/anonymousFunctionsInTypesA.dhall +++ /dev/null @@ -1,5 +0,0 @@ - let anonymousFunction = λ(a : Type) → List a - -in λ(HigherOrderType : (Type → Type) → Type) - → λ(x : HigherOrderType anonymousFunction) - → (x : HigherOrderType anonymousFunction) diff --git a/tests/typecheck/anonymousFunctionsInTypesB.dhall b/tests/typecheck/anonymousFunctionsInTypesB.dhall deleted file mode 100644 --- a/tests/typecheck/anonymousFunctionsInTypesB.dhall +++ /dev/null @@ -1,4 +0,0 @@ - ∀(HigherOrderType : (Type → Type) → Type) -→ ∀(x : HigherOrderType (λ(a : Type) → List a)) -→ HigherOrderType (λ(a : Type) → List a) - diff --git a/tests/typecheck/examples/Monoid/00A.dhall b/tests/typecheck/examples/Monoid/00A.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/00A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../Prelude/package.dhall).`Bool`.and diff --git a/tests/typecheck/examples/Monoid/00B.dhall b/tests/typecheck/examples/Monoid/00B.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/00B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/examples/Monoid/01A.dhall b/tests/typecheck/examples/Monoid/01A.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/01A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../Prelude/package.dhall).`Bool`.or diff --git a/tests/typecheck/examples/Monoid/01B.dhall b/tests/typecheck/examples/Monoid/01B.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/01B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/examples/Monoid/02A.dhall b/tests/typecheck/examples/Monoid/02A.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/02A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../Prelude/package.dhall).`Bool`.even diff --git a/tests/typecheck/examples/Monoid/02B.dhall b/tests/typecheck/examples/Monoid/02B.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/02B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/examples/Monoid/03A.dhall b/tests/typecheck/examples/Monoid/03A.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/03A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../Prelude/package.dhall).`Bool`.odd diff --git a/tests/typecheck/examples/Monoid/03B.dhall b/tests/typecheck/examples/Monoid/03B.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/03B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/examples/Monoid/04A.dhall b/tests/typecheck/examples/Monoid/04A.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/04A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../Prelude/package.dhall).`List`.concat diff --git a/tests/typecheck/examples/Monoid/04B.dhall b/tests/typecheck/examples/Monoid/04B.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/04B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(a : Type) → ../../../../Prelude/Monoid (List a) diff --git a/tests/typecheck/examples/Monoid/05A.dhall b/tests/typecheck/examples/Monoid/05A.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/05A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../Prelude/package.dhall).`List`.shifted diff --git a/tests/typecheck/examples/Monoid/05B.dhall b/tests/typecheck/examples/Monoid/05B.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/05B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(a : Type) → ../../../../Prelude/Monoid (List { index : Natural, value : a }) diff --git a/tests/typecheck/examples/Monoid/06A.dhall b/tests/typecheck/examples/Monoid/06A.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/06A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../Prelude/package.dhall).`Natural`.sum diff --git a/tests/typecheck/examples/Monoid/06B.dhall b/tests/typecheck/examples/Monoid/06B.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/06B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../Prelude/Monoid Natural diff --git a/tests/typecheck/examples/Monoid/07A.dhall b/tests/typecheck/examples/Monoid/07A.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/07A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../Prelude/package.dhall).`Natural`.product diff --git a/tests/typecheck/examples/Monoid/07B.dhall b/tests/typecheck/examples/Monoid/07B.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/07B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../Prelude/Monoid Natural diff --git a/tests/typecheck/examples/Monoid/08A.dhall b/tests/typecheck/examples/Monoid/08A.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/08A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../Prelude/package.dhall).`Optional`.head diff --git a/tests/typecheck/examples/Monoid/08B.dhall b/tests/typecheck/examples/Monoid/08B.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/08B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(a : Type) → ../../../../Prelude/Monoid (Optional a) diff --git a/tests/typecheck/examples/Monoid/09A.dhall b/tests/typecheck/examples/Monoid/09A.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/09A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../Prelude/package.dhall).`Optional`.last diff --git a/tests/typecheck/examples/Monoid/09B.dhall b/tests/typecheck/examples/Monoid/09B.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/09B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(a : Type) → ../../../../Prelude/Monoid (Optional a) diff --git a/tests/typecheck/examples/Monoid/10A.dhall b/tests/typecheck/examples/Monoid/10A.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/10A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../Prelude/package.dhall).`Text`.concat diff --git a/tests/typecheck/examples/Monoid/10B.dhall b/tests/typecheck/examples/Monoid/10B.dhall deleted file mode 100644 --- a/tests/typecheck/examples/Monoid/10B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../Prelude/Monoid Text diff --git a/tests/typecheck/failure/hurkensParadox.dhall b/tests/typecheck/failure/hurkensParadox.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/failure/hurkensParadox.dhall @@ -0,0 +1,49 @@ + let bottom : Type = ∀(any : Type) → any + +in let not : Type → Type = λ(p : Type) → p → bottom + +in let pow = λ(X : Kind) → X → Type + +in let U = ∀(X : Kind) → (pow (pow X) → X) → pow (pow X) + +in let tau + : pow (pow U) → U + = λ(t : pow (pow U)) + → λ(X : Kind) + → λ(f : pow (pow X) → X) + → λ(p : pow X) + → t (λ(x : U) → p (f (x X f))) + +in let sigma : U → pow (pow U) = λ(s : U) → s U (λ(t : pow (pow U)) → tau t) + +in let Delta + : pow U + = λ(y : U) → not (∀(p : pow U) → sigma y p → p (tau (sigma y))) + +in let Omega : U = tau (λ(p : pow U) → ∀(x : U) → sigma x p → p x) + +in let Theta : Type = ∀(p : pow U) → (∀(x : U) → sigma x p → p x) → p Omega + +in let D : Type = ∀(p : pow U) → sigma Omega p → p (tau (sigma Omega)) + +in let lem1 + : ∀(p : pow U) → (∀(x : U) → sigma x p → p x) → p Omega + = λ(p : pow U) + → λ(t1 : ∀(x : U) → sigma x p → p x) + → t1 Omega (λ(x : U) → t1 (tau (sigma x))) + +in let lem3 : D = λ(p : pow U) → lem1 (λ(y : U) → p (tau (sigma y))) + +in let lem2 + : not D + = lem1 + Delta + ( λ(x : U) + → λ(H2 : sigma x Delta) + → λ(H3 : ∀(p : pow U) → sigma x p → p (tau (sigma x))) + → H3 Delta H2 (λ(pp : pow U) → H3 (λ(y : U) → pp (tau (sigma y)))) + ) + +in let evidence : bottom = lem2 lem3 + +in evidence diff --git a/tests/typecheck/fieldsAreTypesA.dhall b/tests/typecheck/fieldsAreTypesA.dhall deleted file mode 100644 --- a/tests/typecheck/fieldsAreTypesA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ x = Bool, y = Text, z = List } diff --git a/tests/typecheck/fieldsAreTypesB.dhall b/tests/typecheck/fieldsAreTypesB.dhall deleted file mode 100644 --- a/tests/typecheck/fieldsAreTypesB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ x : Type, y : Type, z : Type → Type } diff --git a/tests/typecheck/kindParameterA.dhall b/tests/typecheck/kindParameterA.dhall deleted file mode 100644 --- a/tests/typecheck/kindParameterA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(k : Kind) → λ(a : k → k → Type) → λ(x : k) → a x diff --git a/tests/typecheck/kindParameterB.dhall b/tests/typecheck/kindParameterB.dhall deleted file mode 100644 --- a/tests/typecheck/kindParameterB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(k : Kind) → (k → k → Type) → k → k → Type diff --git a/tests/typecheck/mergeEquivalenceA.dhall b/tests/typecheck/mergeEquivalenceA.dhall deleted file mode 100644 --- a/tests/typecheck/mergeEquivalenceA.dhall +++ /dev/null @@ -1,6 +0,0 @@ - let Foo = < Bar : {} | Baz : {} > - -in λ(a : Type) - → λ(f : {} → a) - → λ(ts : Foo) - → merge { Bar = λ(a : {}) → f a, Baz = f } ts diff --git a/tests/typecheck/mergeEquivalenceB.dhall b/tests/typecheck/mergeEquivalenceB.dhall deleted file mode 100644 --- a/tests/typecheck/mergeEquivalenceB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(a : Type) → ∀(f : {} → a) → ∀(ts : < Bar : {} | Baz : {} >) → a diff --git a/tests/typecheck/success/accessEncodedTypeA.dhall b/tests/typecheck/success/accessEncodedTypeA.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/accessEncodedTypeA.dhall @@ -0,0 +1,4 @@ + λ ( record + : ∀(k : Kind) → ∀(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k) → k + ) +→ record Type (λ(x : Type) → λ(y : Type → Type) → x) diff --git a/tests/typecheck/success/accessEncodedTypeB.dhall b/tests/typecheck/success/accessEncodedTypeB.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/accessEncodedTypeB.dhall @@ -0,0 +1,4 @@ + ∀ ( record + : ∀(k : Kind) → ∀(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k) → k + ) +→ Type diff --git a/tests/typecheck/success/accessTypeA.dhall b/tests/typecheck/success/accessTypeA.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/accessTypeA.dhall @@ -0,0 +1,1 @@ +λ(record : { x : Type, y : Type → Type }) → record.x diff --git a/tests/typecheck/success/accessTypeB.dhall b/tests/typecheck/success/accessTypeB.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/accessTypeB.dhall @@ -0,0 +1,1 @@ +∀(record : { x : Type, y : Type → Type }) → Type diff --git a/tests/typecheck/success/encodedRecordOfTypesA.dhall b/tests/typecheck/success/encodedRecordOfTypesA.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/encodedRecordOfTypesA.dhall @@ -0,0 +1,3 @@ + λ(k : Kind) +→ λ(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k) +→ makeRecord Text List diff --git a/tests/typecheck/success/encodedRecordOfTypesB.dhall b/tests/typecheck/success/encodedRecordOfTypesB.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/encodedRecordOfTypesB.dhall @@ -0,0 +1,1 @@ +∀(k : Kind) → ∀(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k) → k diff --git a/tests/typecheck/success/prelude/Bool/and/0A.dhall b/tests/typecheck/success/prelude/Bool/and/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/and/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/and [ True, False, True ] diff --git a/tests/typecheck/success/prelude/Bool/and/0B.dhall b/tests/typecheck/success/prelude/Bool/and/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/and/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/and/1A.dhall b/tests/typecheck/success/prelude/Bool/and/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/and/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/and ([] : List Bool) diff --git a/tests/typecheck/success/prelude/Bool/and/1B.dhall b/tests/typecheck/success/prelude/Bool/and/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/and/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/build/0A.dhall b/tests/typecheck/success/prelude/Bool/build/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/build/0A.dhall @@ -0,0 +1,2 @@ +../../../../../../Prelude/Bool/build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → true) diff --git a/tests/typecheck/success/prelude/Bool/build/0B.dhall b/tests/typecheck/success/prelude/Bool/build/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/build/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/build/1A.dhall b/tests/typecheck/success/prelude/Bool/build/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/build/1A.dhall @@ -0,0 +1,2 @@ +../../../../../../Prelude/Bool/build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → false) diff --git a/tests/typecheck/success/prelude/Bool/build/1B.dhall b/tests/typecheck/success/prelude/Bool/build/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/build/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/even/0A.dhall b/tests/typecheck/success/prelude/Bool/even/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/even/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/even [ False, True, False ] diff --git a/tests/typecheck/success/prelude/Bool/even/0B.dhall b/tests/typecheck/success/prelude/Bool/even/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/even/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/even/1A.dhall b/tests/typecheck/success/prelude/Bool/even/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/even/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/even [ False, True ] diff --git a/tests/typecheck/success/prelude/Bool/even/1B.dhall b/tests/typecheck/success/prelude/Bool/even/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/even/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/even/2A.dhall b/tests/typecheck/success/prelude/Bool/even/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/even/2A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/even [ False ] diff --git a/tests/typecheck/success/prelude/Bool/even/2B.dhall b/tests/typecheck/success/prelude/Bool/even/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/even/2B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/even/3A.dhall b/tests/typecheck/success/prelude/Bool/even/3A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/even/3A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/even ([] : List Bool) diff --git a/tests/typecheck/success/prelude/Bool/even/3B.dhall b/tests/typecheck/success/prelude/Bool/even/3B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/even/3B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/fold/0A.dhall b/tests/typecheck/success/prelude/Bool/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/fold/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/fold True Natural 0 1 diff --git a/tests/typecheck/success/prelude/Bool/fold/0B.dhall b/tests/typecheck/success/prelude/Bool/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/fold/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Bool/fold/1A.dhall b/tests/typecheck/success/prelude/Bool/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/fold/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/fold False Natural 0 1 diff --git a/tests/typecheck/success/prelude/Bool/fold/1B.dhall b/tests/typecheck/success/prelude/Bool/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/fold/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Bool/not/0A.dhall b/tests/typecheck/success/prelude/Bool/not/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/not/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/not True diff --git a/tests/typecheck/success/prelude/Bool/not/0B.dhall b/tests/typecheck/success/prelude/Bool/not/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/not/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/not/1A.dhall b/tests/typecheck/success/prelude/Bool/not/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/not/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/not False diff --git a/tests/typecheck/success/prelude/Bool/not/1B.dhall b/tests/typecheck/success/prelude/Bool/not/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/not/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/odd/0A.dhall b/tests/typecheck/success/prelude/Bool/odd/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/odd/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/odd [ True, False, True ] diff --git a/tests/typecheck/success/prelude/Bool/odd/0B.dhall b/tests/typecheck/success/prelude/Bool/odd/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/odd/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/odd/1A.dhall b/tests/typecheck/success/prelude/Bool/odd/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/odd/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/odd [ True, False ] diff --git a/tests/typecheck/success/prelude/Bool/odd/1B.dhall b/tests/typecheck/success/prelude/Bool/odd/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/odd/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/odd/2A.dhall b/tests/typecheck/success/prelude/Bool/odd/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/odd/2A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/odd [ True ] diff --git a/tests/typecheck/success/prelude/Bool/odd/2B.dhall b/tests/typecheck/success/prelude/Bool/odd/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/odd/2B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/odd/3A.dhall b/tests/typecheck/success/prelude/Bool/odd/3A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/odd/3A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/odd ([] : List Bool) diff --git a/tests/typecheck/success/prelude/Bool/odd/3B.dhall b/tests/typecheck/success/prelude/Bool/odd/3B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/odd/3B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/or/0A.dhall b/tests/typecheck/success/prelude/Bool/or/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/or/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/or [ True, False, True ] diff --git a/tests/typecheck/success/prelude/Bool/or/0B.dhall b/tests/typecheck/success/prelude/Bool/or/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/or/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/or/1A.dhall b/tests/typecheck/success/prelude/Bool/or/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/or/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/or ([] : List Bool) diff --git a/tests/typecheck/success/prelude/Bool/or/1B.dhall b/tests/typecheck/success/prelude/Bool/or/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/or/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Bool/show/0A.dhall b/tests/typecheck/success/prelude/Bool/show/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/show/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/show True diff --git a/tests/typecheck/success/prelude/Bool/show/0B.dhall b/tests/typecheck/success/prelude/Bool/show/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/show/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Bool/show/1A.dhall b/tests/typecheck/success/prelude/Bool/show/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/show/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/show False diff --git a/tests/typecheck/success/prelude/Bool/show/1B.dhall b/tests/typecheck/success/prelude/Bool/show/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Bool/show/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Double/show/0A.dhall b/tests/typecheck/success/prelude/Double/show/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Double/show/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Double/show -3.1 diff --git a/tests/typecheck/success/prelude/Double/show/0B.dhall b/tests/typecheck/success/prelude/Double/show/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Double/show/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Double/show/1A.dhall b/tests/typecheck/success/prelude/Double/show/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Double/show/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Double/show 0.4 diff --git a/tests/typecheck/success/prelude/Double/show/1B.dhall b/tests/typecheck/success/prelude/Double/show/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Double/show/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Integer/show/0A.dhall b/tests/typecheck/success/prelude/Integer/show/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Integer/show/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Integer/show -3 diff --git a/tests/typecheck/success/prelude/Integer/show/0B.dhall b/tests/typecheck/success/prelude/Integer/show/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Integer/show/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Integer/show/1A.dhall b/tests/typecheck/success/prelude/Integer/show/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Integer/show/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Integer/show +0 diff --git a/tests/typecheck/success/prelude/Integer/show/1B.dhall b/tests/typecheck/success/prelude/Integer/show/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Integer/show/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Integer/toDouble/0A.dhall b/tests/typecheck/success/prelude/Integer/toDouble/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Integer/toDouble/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Integer/toDouble -3 diff --git a/tests/typecheck/success/prelude/Integer/toDouble/0B.dhall b/tests/typecheck/success/prelude/Integer/toDouble/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Integer/toDouble/0B.dhall @@ -0,0 +1,1 @@ +Double diff --git a/tests/typecheck/success/prelude/Integer/toDouble/1A.dhall b/tests/typecheck/success/prelude/Integer/toDouble/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Integer/toDouble/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Integer/toDouble +2 diff --git a/tests/typecheck/success/prelude/Integer/toDouble/1B.dhall b/tests/typecheck/success/prelude/Integer/toDouble/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Integer/toDouble/1B.dhall @@ -0,0 +1,1 @@ +Double diff --git a/tests/typecheck/success/prelude/List/all/0A.dhall b/tests/typecheck/success/prelude/List/all/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/all/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/all Natural Natural/even [ 2, 3, 5 ] diff --git a/tests/typecheck/success/prelude/List/all/0B.dhall b/tests/typecheck/success/prelude/List/all/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/all/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/List/all/1A.dhall b/tests/typecheck/success/prelude/List/all/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/all/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/all Natural Natural/even ([] : List Natural) diff --git a/tests/typecheck/success/prelude/List/all/1B.dhall b/tests/typecheck/success/prelude/List/all/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/all/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/List/any/0A.dhall b/tests/typecheck/success/prelude/List/any/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/any/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/any Natural Natural/even [ 2, 3, 5 ] diff --git a/tests/typecheck/success/prelude/List/any/0B.dhall b/tests/typecheck/success/prelude/List/any/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/any/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/List/any/1A.dhall b/tests/typecheck/success/prelude/List/any/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/any/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/any Natural Natural/even ([] : List Natural) diff --git a/tests/typecheck/success/prelude/List/any/1B.dhall b/tests/typecheck/success/prelude/List/any/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/any/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/List/build/0A.dhall b/tests/typecheck/success/prelude/List/build/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/build/0A.dhall @@ -0,0 +1,7 @@ +../../../../../../Prelude/List/build +Text +( λ(list : Type) +→ λ(cons : Text → list → list) +→ λ(nil : list) +→ cons "ABC" (cons "DEF" nil) +) diff --git a/tests/typecheck/success/prelude/List/build/0B.dhall b/tests/typecheck/success/prelude/List/build/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/build/0B.dhall @@ -0,0 +1,1 @@ +List Text diff --git a/tests/typecheck/success/prelude/List/build/1A.dhall b/tests/typecheck/success/prelude/List/build/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/build/1A.dhall @@ -0,0 +1,7 @@ +../../../../../../Prelude/List/build +Text +( λ(list : Type) +→ λ(cons : Text → list → list) +→ λ(nil : list) +→ nil +) diff --git a/tests/typecheck/success/prelude/List/build/1B.dhall b/tests/typecheck/success/prelude/List/build/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/build/1B.dhall @@ -0,0 +1,1 @@ +List Text diff --git a/tests/typecheck/success/prelude/List/concat/0A.dhall b/tests/typecheck/success/prelude/List/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/concat/0A.dhall @@ -0,0 +1,5 @@ +../../../../../../Prelude/List/concat Natural +[ [ 0, 1, 2 ] +, [ 3, 4 ] +, [ 5, 6, 7, 8 ] +] diff --git a/tests/typecheck/success/prelude/List/concat/0B.dhall b/tests/typecheck/success/prelude/List/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/concat/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/concat/1A.dhall b/tests/typecheck/success/prelude/List/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/concat/1A.dhall @@ -0,0 +1,5 @@ +../../../../../../Prelude/List/concat Natural +[ [] : List Natural +, [] : List Natural +, [] : List Natural +] diff --git a/tests/typecheck/success/prelude/List/concat/1B.dhall b/tests/typecheck/success/prelude/List/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/concat/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/concatMap/0A.dhall b/tests/typecheck/success/prelude/List/concatMap/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/concatMap/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/concatMap Natural Natural (λ(n : Natural) → [ n, n ]) [ 2, 3, 5 ] diff --git a/tests/typecheck/success/prelude/List/concatMap/0B.dhall b/tests/typecheck/success/prelude/List/concatMap/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/concatMap/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/concatMap/1A.dhall b/tests/typecheck/success/prelude/List/concatMap/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/concatMap/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/concatMap Natural Natural (λ(n : Natural) → [ n, n ]) ([] : List Natural) diff --git a/tests/typecheck/success/prelude/List/concatMap/1B.dhall b/tests/typecheck/success/prelude/List/concatMap/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/concatMap/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/filter/0A.dhall b/tests/typecheck/success/prelude/List/filter/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/filter/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/filter Natural Natural/even [ 2, 3, 5 ] diff --git a/tests/typecheck/success/prelude/List/filter/0B.dhall b/tests/typecheck/success/prelude/List/filter/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/filter/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/filter/1A.dhall b/tests/typecheck/success/prelude/List/filter/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/filter/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/filter Natural Natural/odd [ 2, 3, 5 ] diff --git a/tests/typecheck/success/prelude/List/filter/1B.dhall b/tests/typecheck/success/prelude/List/filter/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/filter/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/fold/0A.dhall b/tests/typecheck/success/prelude/List/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/fold/0A.dhall @@ -0,0 +1,6 @@ +../../../../../../Prelude/List/fold +Natural +[ 2, 3, 5 ] +Natural +(λ(x : Natural) → λ(y : Natural) → x + y) +0 diff --git a/tests/typecheck/success/prelude/List/fold/0B.dhall b/tests/typecheck/success/prelude/List/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/fold/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/List/fold/1A.dhall b/tests/typecheck/success/prelude/List/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/fold/1A.dhall @@ -0,0 +1,7 @@ + λ(nil : Natural) +→ ../../../../../../Prelude/List/fold + Natural + [ 2, 3, 5 ] + Natural + (λ(x : Natural) → λ(y : Natural) → x + y) + nil diff --git a/tests/typecheck/success/prelude/List/fold/1B.dhall b/tests/typecheck/success/prelude/List/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/fold/1B.dhall @@ -0,0 +1,1 @@ +∀(nil : Natural) → Natural diff --git a/tests/typecheck/success/prelude/List/fold/2A.dhall b/tests/typecheck/success/prelude/List/fold/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/fold/2A.dhall @@ -0,0 +1,4 @@ + λ(list : Type) +→ λ(cons : Natural → list → list) +→ λ(nil : list) +→ ../../../../../../Prelude/List/fold Natural [ 2, 3, 5 ] list cons nil diff --git a/tests/typecheck/success/prelude/List/fold/2B.dhall b/tests/typecheck/success/prelude/List/fold/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/fold/2B.dhall @@ -0,0 +1,1 @@ +∀(list : Type) → ∀(cons : Natural → list → list) → ∀(nil : list) → list diff --git a/tests/typecheck/success/prelude/List/generate/0A.dhall b/tests/typecheck/success/prelude/List/generate/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/generate/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/generate 5 Bool Natural/even diff --git a/tests/typecheck/success/prelude/List/generate/0B.dhall b/tests/typecheck/success/prelude/List/generate/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/generate/0B.dhall @@ -0,0 +1,1 @@ +List Bool diff --git a/tests/typecheck/success/prelude/List/generate/1A.dhall b/tests/typecheck/success/prelude/List/generate/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/generate/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/generate 0 Bool Natural/even diff --git a/tests/typecheck/success/prelude/List/generate/1B.dhall b/tests/typecheck/success/prelude/List/generate/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/generate/1B.dhall @@ -0,0 +1,1 @@ +List Bool diff --git a/tests/typecheck/success/prelude/List/head/0A.dhall b/tests/typecheck/success/prelude/List/head/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/head/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/head Natural [ 0, 1, 2 ] diff --git a/tests/typecheck/success/prelude/List/head/0B.dhall b/tests/typecheck/success/prelude/List/head/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/head/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/List/head/1A.dhall b/tests/typecheck/success/prelude/List/head/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/head/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/head Natural ([] : List Natural) diff --git a/tests/typecheck/success/prelude/List/head/1B.dhall b/tests/typecheck/success/prelude/List/head/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/head/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/List/indexed/0A.dhall b/tests/typecheck/success/prelude/List/indexed/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/indexed/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/indexed Bool [ True, False, True ] diff --git a/tests/typecheck/success/prelude/List/indexed/0B.dhall b/tests/typecheck/success/prelude/List/indexed/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/indexed/0B.dhall @@ -0,0 +1,1 @@ +List { index : Natural, value : Bool } diff --git a/tests/typecheck/success/prelude/List/indexed/1A.dhall b/tests/typecheck/success/prelude/List/indexed/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/indexed/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/indexed Bool ([] : List Bool) diff --git a/tests/typecheck/success/prelude/List/indexed/1B.dhall b/tests/typecheck/success/prelude/List/indexed/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/indexed/1B.dhall @@ -0,0 +1,1 @@ +List { index : Natural, value : Bool } diff --git a/tests/typecheck/success/prelude/List/iterate/0A.dhall b/tests/typecheck/success/prelude/List/iterate/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/iterate/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/iterate 10 Natural (λ(x : Natural) → x * 2) 1 diff --git a/tests/typecheck/success/prelude/List/iterate/0B.dhall b/tests/typecheck/success/prelude/List/iterate/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/iterate/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/iterate/1A.dhall b/tests/typecheck/success/prelude/List/iterate/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/iterate/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/iterate 0 Natural (λ(x : Natural) → x * 2) 1 diff --git a/tests/typecheck/success/prelude/List/iterate/1B.dhall b/tests/typecheck/success/prelude/List/iterate/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/iterate/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/last/0A.dhall b/tests/typecheck/success/prelude/List/last/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/last/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/last Natural [ 0, 1, 2 ] diff --git a/tests/typecheck/success/prelude/List/last/0B.dhall b/tests/typecheck/success/prelude/List/last/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/last/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/List/last/1A.dhall b/tests/typecheck/success/prelude/List/last/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/last/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/last Natural ([] : List Natural) diff --git a/tests/typecheck/success/prelude/List/last/1B.dhall b/tests/typecheck/success/prelude/List/last/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/last/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/List/length/0A.dhall b/tests/typecheck/success/prelude/List/length/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/length/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/length Natural [ 0, 1, 2 ] diff --git a/tests/typecheck/success/prelude/List/length/0B.dhall b/tests/typecheck/success/prelude/List/length/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/length/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/List/length/1A.dhall b/tests/typecheck/success/prelude/List/length/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/length/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/length Natural ([] : List Natural) diff --git a/tests/typecheck/success/prelude/List/length/1B.dhall b/tests/typecheck/success/prelude/List/length/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/length/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/List/map/0A.dhall b/tests/typecheck/success/prelude/List/map/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/map/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/map Natural Bool Natural/even [ 2, 3, 5 ] diff --git a/tests/typecheck/success/prelude/List/map/0B.dhall b/tests/typecheck/success/prelude/List/map/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/map/0B.dhall @@ -0,0 +1,1 @@ +List Bool diff --git a/tests/typecheck/success/prelude/List/map/1A.dhall b/tests/typecheck/success/prelude/List/map/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/map/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/map Natural Bool Natural/even ([] : List Natural) diff --git a/tests/typecheck/success/prelude/List/map/1B.dhall b/tests/typecheck/success/prelude/List/map/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/map/1B.dhall @@ -0,0 +1,1 @@ +List Bool diff --git a/tests/typecheck/success/prelude/List/null/0A.dhall b/tests/typecheck/success/prelude/List/null/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/null/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/null Natural [ 0, 1, 2 ] diff --git a/tests/typecheck/success/prelude/List/null/0B.dhall b/tests/typecheck/success/prelude/List/null/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/null/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/List/null/1A.dhall b/tests/typecheck/success/prelude/List/null/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/null/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/null Natural ([] : List Natural) diff --git a/tests/typecheck/success/prelude/List/null/1B.dhall b/tests/typecheck/success/prelude/List/null/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/null/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/List/replicate/0A.dhall b/tests/typecheck/success/prelude/List/replicate/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/replicate/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/replicate 9 Natural 1 diff --git a/tests/typecheck/success/prelude/List/replicate/0B.dhall b/tests/typecheck/success/prelude/List/replicate/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/replicate/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/replicate/1A.dhall b/tests/typecheck/success/prelude/List/replicate/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/replicate/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/replicate 0 Natural 1 diff --git a/tests/typecheck/success/prelude/List/replicate/1B.dhall b/tests/typecheck/success/prelude/List/replicate/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/replicate/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/reverse/0A.dhall b/tests/typecheck/success/prelude/List/reverse/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/reverse/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/reverse Natural [ 0, 1, 2 ] diff --git a/tests/typecheck/success/prelude/List/reverse/0B.dhall b/tests/typecheck/success/prelude/List/reverse/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/reverse/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/reverse/1A.dhall b/tests/typecheck/success/prelude/List/reverse/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/reverse/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/reverse Natural ([] : List Natural) diff --git a/tests/typecheck/success/prelude/List/reverse/1B.dhall b/tests/typecheck/success/prelude/List/reverse/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/reverse/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/List/shifted/0A.dhall b/tests/typecheck/success/prelude/List/shifted/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/shifted/0A.dhall @@ -0,0 +1,15 @@ +../../../../../../Prelude/List/shifted +Bool +[ [ { index = 0, value = True } + , { index = 1, value = True } + , { index = 2, value = False } + ] +, [ { index = 0, value = False } + , { index = 1, value = False } + ] +, [ { index = 0, value = True } + , { index = 1, value = True } + , { index = 2, value = True } + , { index = 3, value = True } + ] +] diff --git a/tests/typecheck/success/prelude/List/shifted/0B.dhall b/tests/typecheck/success/prelude/List/shifted/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/shifted/0B.dhall @@ -0,0 +1,1 @@ +List { index : Natural, value : Bool } diff --git a/tests/typecheck/success/prelude/List/shifted/1A.dhall b/tests/typecheck/success/prelude/List/shifted/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/shifted/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/shifted Bool ([] : List (List { index : Natural, value : Bool })) diff --git a/tests/typecheck/success/prelude/List/shifted/1B.dhall b/tests/typecheck/success/prelude/List/shifted/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/shifted/1B.dhall @@ -0,0 +1,1 @@ +List { index : Natural, value : Bool } diff --git a/tests/typecheck/success/prelude/List/unzip/0A.dhall b/tests/typecheck/success/prelude/List/unzip/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/unzip/0A.dhall @@ -0,0 +1,7 @@ +../../../../../../Prelude/List/unzip +Text +Bool +[ { _1 = "ABC", _2 = True } +, { _1 = "DEF", _2 = False } +, { _1 = "GHI", _2 = True } +] diff --git a/tests/typecheck/success/prelude/List/unzip/0B.dhall b/tests/typecheck/success/prelude/List/unzip/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/unzip/0B.dhall @@ -0,0 +1,1 @@ +{ _1 : List Text, _2 : List Bool } diff --git a/tests/typecheck/success/prelude/List/unzip/1A.dhall b/tests/typecheck/success/prelude/List/unzip/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/unzip/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/unzip Text Bool ([] : List { _1 : Text, _2 : Bool }) diff --git a/tests/typecheck/success/prelude/List/unzip/1B.dhall b/tests/typecheck/success/prelude/List/unzip/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/List/unzip/1B.dhall @@ -0,0 +1,1 @@ +{ _1 : List Text, _2 : List Bool } diff --git a/tests/typecheck/success/prelude/Monoid/00A.dhall b/tests/typecheck/success/prelude/Monoid/00A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/00A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Bool`.and diff --git a/tests/typecheck/success/prelude/Monoid/00B.dhall b/tests/typecheck/success/prelude/Monoid/00B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/00B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/success/prelude/Monoid/01A.dhall b/tests/typecheck/success/prelude/Monoid/01A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/01A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Bool`.or diff --git a/tests/typecheck/success/prelude/Monoid/01B.dhall b/tests/typecheck/success/prelude/Monoid/01B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/01B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/success/prelude/Monoid/02A.dhall b/tests/typecheck/success/prelude/Monoid/02A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/02A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Bool`.even diff --git a/tests/typecheck/success/prelude/Monoid/02B.dhall b/tests/typecheck/success/prelude/Monoid/02B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/02B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/success/prelude/Monoid/03A.dhall b/tests/typecheck/success/prelude/Monoid/03A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/03A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Bool`.odd diff --git a/tests/typecheck/success/prelude/Monoid/03B.dhall b/tests/typecheck/success/prelude/Monoid/03B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/03B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/success/prelude/Monoid/04A.dhall b/tests/typecheck/success/prelude/Monoid/04A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/04A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`List`.concat diff --git a/tests/typecheck/success/prelude/Monoid/04B.dhall b/tests/typecheck/success/prelude/Monoid/04B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/04B.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → ../../../../../Prelude/Monoid (List a) diff --git a/tests/typecheck/success/prelude/Monoid/05A.dhall b/tests/typecheck/success/prelude/Monoid/05A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/05A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`List`.shifted diff --git a/tests/typecheck/success/prelude/Monoid/05B.dhall b/tests/typecheck/success/prelude/Monoid/05B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/05B.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → ../../../../../Prelude/Monoid (List { index : Natural, value : a }) diff --git a/tests/typecheck/success/prelude/Monoid/06A.dhall b/tests/typecheck/success/prelude/Monoid/06A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/06A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Natural`.sum diff --git a/tests/typecheck/success/prelude/Monoid/06B.dhall b/tests/typecheck/success/prelude/Monoid/06B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/06B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Natural diff --git a/tests/typecheck/success/prelude/Monoid/07A.dhall b/tests/typecheck/success/prelude/Monoid/07A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/07A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Natural`.product diff --git a/tests/typecheck/success/prelude/Monoid/07B.dhall b/tests/typecheck/success/prelude/Monoid/07B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/07B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Natural diff --git a/tests/typecheck/success/prelude/Monoid/08A.dhall b/tests/typecheck/success/prelude/Monoid/08A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/08A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Optional`.head diff --git a/tests/typecheck/success/prelude/Monoid/08B.dhall b/tests/typecheck/success/prelude/Monoid/08B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/08B.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → ../../../../../Prelude/Monoid (Optional a) diff --git a/tests/typecheck/success/prelude/Monoid/09A.dhall b/tests/typecheck/success/prelude/Monoid/09A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/09A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Optional`.last diff --git a/tests/typecheck/success/prelude/Monoid/09B.dhall b/tests/typecheck/success/prelude/Monoid/09B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/09B.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → ../../../../../Prelude/Monoid (Optional a) diff --git a/tests/typecheck/success/prelude/Monoid/10A.dhall b/tests/typecheck/success/prelude/Monoid/10A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/10A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Text`.concat diff --git a/tests/typecheck/success/prelude/Monoid/10B.dhall b/tests/typecheck/success/prelude/Monoid/10B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Monoid/10B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Text diff --git a/tests/typecheck/success/prelude/Natural/build/0A.dhall b/tests/typecheck/success/prelude/Natural/build/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/build/0A.dhall @@ -0,0 +1,6 @@ +../../../../../../Prelude/Natural/build +( λ(natural : Type) +→ λ(succ : natural → natural) +→ λ(zero : natural) +→ succ (succ (succ zero)) +) diff --git a/tests/typecheck/success/prelude/Natural/build/0B.dhall b/tests/typecheck/success/prelude/Natural/build/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/build/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Natural/build/1A.dhall b/tests/typecheck/success/prelude/Natural/build/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/build/1A.dhall @@ -0,0 +1,6 @@ +../../../../../../Prelude/Natural/build +( λ(natural : Type) +→ λ(succ : natural → natural) +→ λ(zero : natural) +→ zero +) diff --git a/tests/typecheck/success/prelude/Natural/build/1B.dhall b/tests/typecheck/success/prelude/Natural/build/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/build/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Natural/enumerate/0A.dhall b/tests/typecheck/success/prelude/Natural/enumerate/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/enumerate/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/enumerate 10 diff --git a/tests/typecheck/success/prelude/Natural/enumerate/0B.dhall b/tests/typecheck/success/prelude/Natural/enumerate/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/enumerate/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/Natural/enumerate/1A.dhall b/tests/typecheck/success/prelude/Natural/enumerate/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/enumerate/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/enumerate 0 diff --git a/tests/typecheck/success/prelude/Natural/enumerate/1B.dhall b/tests/typecheck/success/prelude/Natural/enumerate/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/enumerate/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/Natural/even/0A.dhall b/tests/typecheck/success/prelude/Natural/even/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/even/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/even 3 diff --git a/tests/typecheck/success/prelude/Natural/even/0B.dhall b/tests/typecheck/success/prelude/Natural/even/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/even/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Natural/even/1A.dhall b/tests/typecheck/success/prelude/Natural/even/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/even/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/even 0 diff --git a/tests/typecheck/success/prelude/Natural/even/1B.dhall b/tests/typecheck/success/prelude/Natural/even/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/even/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Natural/fold/0A.dhall b/tests/typecheck/success/prelude/Natural/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/fold/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/fold 3 Natural (λ(x : Natural) → 5 * x) 1 diff --git a/tests/typecheck/success/prelude/Natural/fold/0B.dhall b/tests/typecheck/success/prelude/Natural/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/fold/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Natural/fold/1A.dhall b/tests/typecheck/success/prelude/Natural/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/fold/1A.dhall @@ -0,0 +1,1 @@ +λ(zero : Natural) → ../../../../../../Prelude/Natural/fold 3 Natural (λ(x : Natural) → 5 * x) zero diff --git a/tests/typecheck/success/prelude/Natural/fold/1B.dhall b/tests/typecheck/success/prelude/Natural/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/fold/1B.dhall @@ -0,0 +1,1 @@ +∀(zero : Natural) → Natural diff --git a/tests/typecheck/success/prelude/Natural/fold/2A.dhall b/tests/typecheck/success/prelude/Natural/fold/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/fold/2A.dhall @@ -0,0 +1,4 @@ + λ(natural : Type) +→ λ(succ : natural → natural) +→ λ(zero : natural) +→ ../../../../../../Prelude/Natural/fold 3 natural succ zero diff --git a/tests/typecheck/success/prelude/Natural/fold/2B.dhall b/tests/typecheck/success/prelude/Natural/fold/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/fold/2B.dhall @@ -0,0 +1,1 @@ +∀(natural : Type) → ∀(succ : natural → natural) → ∀(zero : natural) → natural diff --git a/tests/typecheck/success/prelude/Natural/isZero/0A.dhall b/tests/typecheck/success/prelude/Natural/isZero/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/isZero/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/isZero 2 diff --git a/tests/typecheck/success/prelude/Natural/isZero/0B.dhall b/tests/typecheck/success/prelude/Natural/isZero/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/isZero/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Natural/isZero/1A.dhall b/tests/typecheck/success/prelude/Natural/isZero/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/isZero/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/isZero 0 diff --git a/tests/typecheck/success/prelude/Natural/isZero/1B.dhall b/tests/typecheck/success/prelude/Natural/isZero/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/isZero/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Natural/odd/0A.dhall b/tests/typecheck/success/prelude/Natural/odd/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/odd/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/odd 3 diff --git a/tests/typecheck/success/prelude/Natural/odd/0B.dhall b/tests/typecheck/success/prelude/Natural/odd/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/odd/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Natural/odd/1A.dhall b/tests/typecheck/success/prelude/Natural/odd/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/odd/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/odd 0 diff --git a/tests/typecheck/success/prelude/Natural/odd/1B.dhall b/tests/typecheck/success/prelude/Natural/odd/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/odd/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Natural/product/0A.dhall b/tests/typecheck/success/prelude/Natural/product/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/product/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/product [ 2, 3, 5 ] diff --git a/tests/typecheck/success/prelude/Natural/product/0B.dhall b/tests/typecheck/success/prelude/Natural/product/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/product/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Natural/product/1A.dhall b/tests/typecheck/success/prelude/Natural/product/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/product/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/product ([] : List Natural) diff --git a/tests/typecheck/success/prelude/Natural/product/1B.dhall b/tests/typecheck/success/prelude/Natural/product/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/product/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Natural/show/0A.dhall b/tests/typecheck/success/prelude/Natural/show/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/show/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/show 3 diff --git a/tests/typecheck/success/prelude/Natural/show/0B.dhall b/tests/typecheck/success/prelude/Natural/show/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/show/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Natural/show/1A.dhall b/tests/typecheck/success/prelude/Natural/show/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/show/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/show 0 diff --git a/tests/typecheck/success/prelude/Natural/show/1B.dhall b/tests/typecheck/success/prelude/Natural/show/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/show/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Natural/sum/0A.dhall b/tests/typecheck/success/prelude/Natural/sum/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/sum/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/sum [ 2, 3, 5 ] diff --git a/tests/typecheck/success/prelude/Natural/sum/0B.dhall b/tests/typecheck/success/prelude/Natural/sum/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/sum/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Natural/sum/1A.dhall b/tests/typecheck/success/prelude/Natural/sum/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/sum/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/sum ([] : List Natural) diff --git a/tests/typecheck/success/prelude/Natural/sum/1B.dhall b/tests/typecheck/success/prelude/Natural/sum/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/sum/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Natural/toDouble/0A.dhall b/tests/typecheck/success/prelude/Natural/toDouble/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/toDouble/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/toDouble 3 diff --git a/tests/typecheck/success/prelude/Natural/toDouble/0B.dhall b/tests/typecheck/success/prelude/Natural/toDouble/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/toDouble/0B.dhall @@ -0,0 +1,1 @@ +Double diff --git a/tests/typecheck/success/prelude/Natural/toDouble/1A.dhall b/tests/typecheck/success/prelude/Natural/toDouble/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/toDouble/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/toDouble 0 diff --git a/tests/typecheck/success/prelude/Natural/toDouble/1B.dhall b/tests/typecheck/success/prelude/Natural/toDouble/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/toDouble/1B.dhall @@ -0,0 +1,1 @@ +Double diff --git a/tests/typecheck/success/prelude/Natural/toInteger/0A.dhall b/tests/typecheck/success/prelude/Natural/toInteger/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/toInteger/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/toInteger 3 diff --git a/tests/typecheck/success/prelude/Natural/toInteger/0B.dhall b/tests/typecheck/success/prelude/Natural/toInteger/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/toInteger/0B.dhall @@ -0,0 +1,1 @@ +Integer diff --git a/tests/typecheck/success/prelude/Natural/toInteger/1A.dhall b/tests/typecheck/success/prelude/Natural/toInteger/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/toInteger/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/toInteger 0 diff --git a/tests/typecheck/success/prelude/Natural/toInteger/1B.dhall b/tests/typecheck/success/prelude/Natural/toInteger/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Natural/toInteger/1B.dhall @@ -0,0 +1,1 @@ +Integer diff --git a/tests/typecheck/success/prelude/Optional/all/0A.dhall b/tests/typecheck/success/prelude/Optional/all/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/all/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/all Natural Natural/even (Some 3) diff --git a/tests/typecheck/success/prelude/Optional/all/0B.dhall b/tests/typecheck/success/prelude/Optional/all/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/all/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Optional/all/1A.dhall b/tests/typecheck/success/prelude/Optional/all/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/all/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/all Natural Natural/even (None Natural) diff --git a/tests/typecheck/success/prelude/Optional/all/1B.dhall b/tests/typecheck/success/prelude/Optional/all/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/all/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Optional/any/0A.dhall b/tests/typecheck/success/prelude/Optional/any/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/any/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/any Natural Natural/even (Some 2) diff --git a/tests/typecheck/success/prelude/Optional/any/0B.dhall b/tests/typecheck/success/prelude/Optional/any/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/any/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Optional/any/1A.dhall b/tests/typecheck/success/prelude/Optional/any/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/any/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/any Natural Natural/even (None Natural) diff --git a/tests/typecheck/success/prelude/Optional/any/1B.dhall b/tests/typecheck/success/prelude/Optional/any/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/any/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Optional/build/0A.dhall b/tests/typecheck/success/prelude/Optional/build/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/build/0A.dhall @@ -0,0 +1,7 @@ +../../../../../../Prelude/Optional/build +Natural +( λ(optional : Type) +→ λ(some : Natural → optional) +→ λ(none : optional) +→ some 1 +) diff --git a/tests/typecheck/success/prelude/Optional/build/0B.dhall b/tests/typecheck/success/prelude/Optional/build/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/build/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/build/1A.dhall b/tests/typecheck/success/prelude/Optional/build/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/build/1A.dhall @@ -0,0 +1,7 @@ +../../../../../../Prelude/Optional/build +Natural +( λ(optional : Type) +→ λ(some : Natural → optional) +→ λ(none : optional) +→ none +) diff --git a/tests/typecheck/success/prelude/Optional/build/1B.dhall b/tests/typecheck/success/prelude/Optional/build/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/build/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/concat/0A.dhall b/tests/typecheck/success/prelude/Optional/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/concat/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/concat Natural (Some (Some 1)) diff --git a/tests/typecheck/success/prelude/Optional/concat/0B.dhall b/tests/typecheck/success/prelude/Optional/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/concat/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/concat/1A.dhall b/tests/typecheck/success/prelude/Optional/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/concat/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/concat Natural (Some (None Natural)) diff --git a/tests/typecheck/success/prelude/Optional/concat/1B.dhall b/tests/typecheck/success/prelude/Optional/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/concat/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/concat/2A.dhall b/tests/typecheck/success/prelude/Optional/concat/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/concat/2A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/concat Natural (None (Optional Natural)) diff --git a/tests/typecheck/success/prelude/Optional/concat/2B.dhall b/tests/typecheck/success/prelude/Optional/concat/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/concat/2B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/filter/0A.dhall b/tests/typecheck/success/prelude/Optional/filter/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/filter/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/filter Natural Natural/even (Some 2) diff --git a/tests/typecheck/success/prelude/Optional/filter/0B.dhall b/tests/typecheck/success/prelude/Optional/filter/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/filter/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/filter/1A.dhall b/tests/typecheck/success/prelude/Optional/filter/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/filter/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/filter Natural Natural/odd (Some 2) diff --git a/tests/typecheck/success/prelude/Optional/filter/1B.dhall b/tests/typecheck/success/prelude/Optional/filter/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/filter/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/fold/0A.dhall b/tests/typecheck/success/prelude/Optional/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/fold/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/fold Natural (Some 2) Natural (λ(x : Natural) → x) 0 diff --git a/tests/typecheck/success/prelude/Optional/fold/0B.dhall b/tests/typecheck/success/prelude/Optional/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/fold/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Optional/fold/1A.dhall b/tests/typecheck/success/prelude/Optional/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/fold/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/fold Natural (None Natural) Natural (λ(x : Natural) → x) 0 diff --git a/tests/typecheck/success/prelude/Optional/fold/1B.dhall b/tests/typecheck/success/prelude/Optional/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/fold/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Optional/head/0A.dhall b/tests/typecheck/success/prelude/Optional/head/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/head/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/head Natural [ None Natural, Some 1, Some 2 ] diff --git a/tests/typecheck/success/prelude/Optional/head/0B.dhall b/tests/typecheck/success/prelude/Optional/head/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/head/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/head/1A.dhall b/tests/typecheck/success/prelude/Optional/head/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/head/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/head Natural [ None Natural, None Natural ] diff --git a/tests/typecheck/success/prelude/Optional/head/1B.dhall b/tests/typecheck/success/prelude/Optional/head/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/head/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/head/2A.dhall b/tests/typecheck/success/prelude/Optional/head/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/head/2A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/head Natural ([] : List (Optional Natural)) diff --git a/tests/typecheck/success/prelude/Optional/head/2B.dhall b/tests/typecheck/success/prelude/Optional/head/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/head/2B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/last/0A.dhall b/tests/typecheck/success/prelude/Optional/last/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/last/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/last Natural [ None Natural, Some 1, Some 2 ] diff --git a/tests/typecheck/success/prelude/Optional/last/0B.dhall b/tests/typecheck/success/prelude/Optional/last/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/last/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/last/1A.dhall b/tests/typecheck/success/prelude/Optional/last/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/last/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/last Natural [ None Natural, None Natural ] diff --git a/tests/typecheck/success/prelude/Optional/last/1B.dhall b/tests/typecheck/success/prelude/Optional/last/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/last/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/last/2A.dhall b/tests/typecheck/success/prelude/Optional/last/2A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/last/2A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/last Natural ([] : List (Optional Natural)) diff --git a/tests/typecheck/success/prelude/Optional/last/2B.dhall b/tests/typecheck/success/prelude/Optional/last/2B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/last/2B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/length/0A.dhall b/tests/typecheck/success/prelude/Optional/length/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/length/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/length Natural (Some 2) diff --git a/tests/typecheck/success/prelude/Optional/length/0B.dhall b/tests/typecheck/success/prelude/Optional/length/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/length/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Optional/length/1A.dhall b/tests/typecheck/success/prelude/Optional/length/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/length/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/length Natural (None Natural) diff --git a/tests/typecheck/success/prelude/Optional/length/1B.dhall b/tests/typecheck/success/prelude/Optional/length/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/length/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/tests/typecheck/success/prelude/Optional/map/0A.dhall b/tests/typecheck/success/prelude/Optional/map/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/map/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/map Natural Bool Natural/even (Some 3) diff --git a/tests/typecheck/success/prelude/Optional/map/0B.dhall b/tests/typecheck/success/prelude/Optional/map/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/map/0B.dhall @@ -0,0 +1,1 @@ +Optional Bool diff --git a/tests/typecheck/success/prelude/Optional/map/1A.dhall b/tests/typecheck/success/prelude/Optional/map/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/map/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/map Natural Bool Natural/even (None Natural) diff --git a/tests/typecheck/success/prelude/Optional/map/1B.dhall b/tests/typecheck/success/prelude/Optional/map/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/map/1B.dhall @@ -0,0 +1,1 @@ +Optional Bool diff --git a/tests/typecheck/success/prelude/Optional/null/0A.dhall b/tests/typecheck/success/prelude/Optional/null/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/null/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/null Natural (Some 2) diff --git a/tests/typecheck/success/prelude/Optional/null/0B.dhall b/tests/typecheck/success/prelude/Optional/null/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/null/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Optional/null/1A.dhall b/tests/typecheck/success/prelude/Optional/null/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/null/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/null Natural (None Natural) diff --git a/tests/typecheck/success/prelude/Optional/null/1B.dhall b/tests/typecheck/success/prelude/Optional/null/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/null/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/tests/typecheck/success/prelude/Optional/toList/0A.dhall b/tests/typecheck/success/prelude/Optional/toList/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/toList/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/toList Natural (Some 1) diff --git a/tests/typecheck/success/prelude/Optional/toList/0B.dhall b/tests/typecheck/success/prelude/Optional/toList/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/toList/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/Optional/toList/1A.dhall b/tests/typecheck/success/prelude/Optional/toList/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/toList/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/toList Natural (None Natural) diff --git a/tests/typecheck/success/prelude/Optional/toList/1B.dhall b/tests/typecheck/success/prelude/Optional/toList/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/toList/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/tests/typecheck/success/prelude/Optional/unzip/0A.dhall b/tests/typecheck/success/prelude/Optional/unzip/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/unzip/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/unzip Text Bool (Some { _1 = "ABC", _2 = True }) diff --git a/tests/typecheck/success/prelude/Optional/unzip/0B.dhall b/tests/typecheck/success/prelude/Optional/unzip/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/unzip/0B.dhall @@ -0,0 +1,1 @@ +{ _1 : Optional Text, _2 : Optional Bool } diff --git a/tests/typecheck/success/prelude/Optional/unzip/1A.dhall b/tests/typecheck/success/prelude/Optional/unzip/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/unzip/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/unzip Text Bool (None { _1 : Text, _2 : Bool }) diff --git a/tests/typecheck/success/prelude/Optional/unzip/1B.dhall b/tests/typecheck/success/prelude/Optional/unzip/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Optional/unzip/1B.dhall @@ -0,0 +1,1 @@ +{ _1 : Optional Text, _2 : Optional Bool } diff --git a/tests/typecheck/success/prelude/Text/concat/0A.dhall b/tests/typecheck/success/prelude/Text/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concat/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concat [ "ABC", "DEF", "GHI" ] diff --git a/tests/typecheck/success/prelude/Text/concat/0B.dhall b/tests/typecheck/success/prelude/Text/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concat/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Text/concat/1A.dhall b/tests/typecheck/success/prelude/Text/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concat/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concat ([] : List Text) diff --git a/tests/typecheck/success/prelude/Text/concat/1B.dhall b/tests/typecheck/success/prelude/Text/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concat/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Text/concatMap/0A.dhall b/tests/typecheck/success/prelude/Text/concatMap/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatMap/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concatMap Natural (λ(n : Natural) → "${Natural/show n} ") [ 0, 1, 2 ] diff --git a/tests/typecheck/success/prelude/Text/concatMap/0B.dhall b/tests/typecheck/success/prelude/Text/concatMap/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatMap/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Text/concatMap/1A.dhall b/tests/typecheck/success/prelude/Text/concatMap/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatMap/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concatMap Natural (λ(n : Natural) → "${Natural/show n} ") ([] : List Natural) diff --git a/tests/typecheck/success/prelude/Text/concatMap/1B.dhall b/tests/typecheck/success/prelude/Text/concatMap/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatMap/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall b/tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concatMapSep ", " Natural Natural/show [ 0, 1, 2 ] diff --git a/tests/typecheck/success/prelude/Text/concatMapSep/0B.dhall b/tests/typecheck/success/prelude/Text/concatMapSep/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatMapSep/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall b/tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concatMapSep ", " Natural Natural/show ([] : List Natural) diff --git a/tests/typecheck/success/prelude/Text/concatMapSep/1B.dhall b/tests/typecheck/success/prelude/Text/concatMapSep/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatMapSep/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Text/concatSep/0A.dhall b/tests/typecheck/success/prelude/Text/concatSep/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatSep/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concatSep ", " [ "ABC", "DEF", "GHI" ] diff --git a/tests/typecheck/success/prelude/Text/concatSep/0B.dhall b/tests/typecheck/success/prelude/Text/concatSep/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatSep/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/prelude/Text/concatSep/1A.dhall b/tests/typecheck/success/prelude/Text/concatSep/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatSep/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concatSep ", " ([] : List Text) diff --git a/tests/typecheck/success/prelude/Text/concatSep/1B.dhall b/tests/typecheck/success/prelude/Text/concatSep/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/prelude/Text/concatSep/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/tests/typecheck/success/recordOfTypesA.dhall b/tests/typecheck/success/recordOfTypesA.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/recordOfTypesA.dhall @@ -0,0 +1,1 @@ +{ x = Text, y = List } diff --git a/tests/typecheck/success/recordOfTypesB.dhall b/tests/typecheck/success/recordOfTypesB.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/recordOfTypesB.dhall @@ -0,0 +1,1 @@ +{ x : Type, y : Type → Type } diff --git a/tests/typecheck/success/simple/access/0A.dhall b/tests/typecheck/success/simple/access/0A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/access/0A.dhall @@ -0,0 +1,1 @@ +{ x = Text }.x diff --git a/tests/typecheck/success/simple/access/0B.dhall b/tests/typecheck/success/simple/access/0B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/access/0B.dhall @@ -0,0 +1,1 @@ +Type diff --git a/tests/typecheck/success/simple/access/1A.dhall b/tests/typecheck/success/simple/access/1A.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/access/1A.dhall @@ -0,0 +1,1 @@ +< Foo : Text | Bar : Natural >.Foo diff --git a/tests/typecheck/success/simple/access/1B.dhall b/tests/typecheck/success/simple/access/1B.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/access/1B.dhall @@ -0,0 +1,1 @@ +∀(Foo : Text) → < Bar : Natural | Foo : Text > diff --git a/tests/typecheck/success/simple/alternativesAreTypesA.dhall b/tests/typecheck/success/simple/alternativesAreTypesA.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/alternativesAreTypesA.dhall @@ -0,0 +1,1 @@ +< Left = List | Right : Type > diff --git a/tests/typecheck/success/simple/alternativesAreTypesB.dhall b/tests/typecheck/success/simple/alternativesAreTypesB.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/alternativesAreTypesB.dhall @@ -0,0 +1,1 @@ +< Left : Type → Type | Right : Type > diff --git a/tests/typecheck/success/simple/anonymousFunctionsInTypesA.dhall b/tests/typecheck/success/simple/anonymousFunctionsInTypesA.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/anonymousFunctionsInTypesA.dhall @@ -0,0 +1,5 @@ + let anonymousFunction = λ(a : Type) → List a + +in λ(HigherOrderType : (Type → Type) → Type) + → λ(x : HigherOrderType anonymousFunction) + → (x : HigherOrderType anonymousFunction) diff --git a/tests/typecheck/success/simple/anonymousFunctionsInTypesB.dhall b/tests/typecheck/success/simple/anonymousFunctionsInTypesB.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/anonymousFunctionsInTypesB.dhall @@ -0,0 +1,4 @@ + ∀(HigherOrderType : (Type → Type) → Type) +→ ∀(x : HigherOrderType (λ(a : Type) → List a)) +→ HigherOrderType (λ(a : Type) → List a) + diff --git a/tests/typecheck/success/simple/fieldsAreTypesA.dhall b/tests/typecheck/success/simple/fieldsAreTypesA.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/fieldsAreTypesA.dhall @@ -0,0 +1,1 @@ +{ x = Bool, y = Text, z = List } diff --git a/tests/typecheck/success/simple/fieldsAreTypesB.dhall b/tests/typecheck/success/simple/fieldsAreTypesB.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/fieldsAreTypesB.dhall @@ -0,0 +1,1 @@ +{ x : Type, y : Type, z : Type → Type } diff --git a/tests/typecheck/success/simple/kindParameterA.dhall b/tests/typecheck/success/simple/kindParameterA.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/kindParameterA.dhall @@ -0,0 +1,1 @@ +λ(k : Kind) → λ(a : k → k → Type) → λ(x : k) → a x diff --git a/tests/typecheck/success/simple/kindParameterB.dhall b/tests/typecheck/success/simple/kindParameterB.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/kindParameterB.dhall @@ -0,0 +1,1 @@ +∀(k : Kind) → (k → k → Type) → k → k → Type diff --git a/tests/typecheck/success/simple/mergeEquivalenceA.dhall b/tests/typecheck/success/simple/mergeEquivalenceA.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/mergeEquivalenceA.dhall @@ -0,0 +1,6 @@ + let Foo = < Bar : {} | Baz : {} > + +in λ(a : Type) + → λ(f : {} → a) + → λ(ts : Foo) + → merge { Bar = λ(a : {}) → f a, Baz = f } ts diff --git a/tests/typecheck/success/simple/mergeEquivalenceB.dhall b/tests/typecheck/success/simple/mergeEquivalenceB.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/mergeEquivalenceB.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → ∀(f : {} → a) → ∀(ts : < Bar : {} | Baz : {} >) → a diff --git a/tests/typecheck/success/simple/mixedFieldAccessA.dhall b/tests/typecheck/success/simple/mixedFieldAccessA.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/mixedFieldAccessA.dhall @@ -0,0 +1,7 @@ +-- Verify that users can use `.` to both access a record field and a union +-- constructor within the same expression. This is a common idiom if a user +-- provides a types package. + +let Scope = < Public : {} | Private : {} > +let types = { Scope = Scope } +in types.Scope.Public {=} diff --git a/tests/typecheck/success/simple/mixedFieldAccessB.dhall b/tests/typecheck/success/simple/mixedFieldAccessB.dhall new file mode 100644 --- /dev/null +++ b/tests/typecheck/success/simple/mixedFieldAccessB.dhall @@ -0,0 +1,1 @@ +< Private : {} | Public : {} >