diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,105 @@ +1.21.0 + +* Supports version 6.0.0 of the language standard + * See: https://github.com/dhall-lang/dhall-lang/releases/tag/v6.0.0 +* BREAKING CHANGE: Remove the `constructors` keyword + * ... as standardized in version 6.0.0 of the language standard + * The deprecation cycle is over, so the keyword is no longer supported + * For more details, see: https://github.com/dhall-lang/dhall-lang/wiki/Migration%3A-Deprecation-of-constructors-keyword + * See: https://github.com/dhall-lang/dhall-haskell/pull/829 +* BREAKING CHANGE: CBOR-encode only special `Double`s as half-floats + * ... as standardized in version 6.0.0 of the language standard + * CBOR `Double`s except `Infinity`/`-Infinity`/`NaN`/`0.0` are now encoded in at + least 32 bits + * See: https://github.com/dhall-lang/dhall-haskell/pull/822 +* BREAKING CHANGE: Sort record and union fields when CBOR-encoding + * Fields and alternatives are now sorted when serialized + * This does not affect semantic integrity checks, which already sorted these + fields/alternatives before hashing expressions + * This does affect the serialization of expressions that have not been + normalized (e.g. uninterpreted expressions transmitted over the wire) + * See: https://github.com/dhall-lang/dhall-haskell/pull/835 +* BUG FIX: Fix non-exhaustive pattern match in `dhall lint` + * This fixes: `Irrefutable pattern failed for pattern Let (l' :| ls') d'` + * This bug would cause `dhall lint` to fail on some nested `let`/`in` + expressions + * See: https://github.com/dhall-lang/dhall-haskell/pull/780 + * See: https://github.com/dhall-lang/dhall-haskell/pull/784 +* BUG FIX: Don't fail if `$HOME` environment variable is unset + * The interpreter was incorrectly throwing an exception if `HOME` was unset + * The standard requires that implementations should handle the `HOME` + environment variable being missing + * See: https://github.com/dhall-lang/dhall-haskell/pull/789 +* Feature: Remove version tag from semantic integrity check + * ... as standardized in version 6.0.0 of the language standard + * This is not a breaking change because this change also includes + backwards-compatible support for semantic integrity checks produced by + older versions of the interpreter +* Feature: Support Unicode path components + * ... as standardized in version 6.0.0 of the language standard + * You can now use Unicode in path components if they are quoted + * i.e. `./families/"禺.dhall"` is now legal +* Feature: Add `Text/show` built-in + * ... as standardized in version 6.0.0 of the language standard + * You can now convert a `Text` literal to its equivalent Dhall source code + (which is itself a `Text` literal) + * This comes in handy when using Dhall code to generate JSON or Dhall code + * See: https://github.com/dhall-lang/dhall-haskell/pull/811 +* Feature: Add `--immediate-dependencies`/`--transitive-dependencies` flags for + `dhall resolve` + * You can now retrieve all of your immediate or transitive dependencies as a + textual list + * This simplifies integration with other command-line tools (such as file + watchers) + * See: https://github.com/dhall-lang/dhall-haskell/pull/795 + * See: https://github.com/dhall-lang/dhall-haskell/pull/803 +* Feature: `dhall freeze` now only freezes remote imports by default + * `dhall freeze` used to freeze all imports (including local imports and + environment variables) + * Now `dhall freeze` only freezes remote imports by default, which is what + most users want + * You can install freeze all imports using the `--all` flag + * See: https://github.com/dhall-lang/dhall-haskell/pull/808 +* Feature: `:save` and `:load` REPL state + * `:save` with no arguments now saves the REPL state to a `.dhall-repl-N` + file + * The file format is a list of `dhall repl` commands + * You can use `:load` to load the saved state back into the REPL + * See: https://github.com/dhall-lang/dhall-haskell/pull/807 +* Feature: Add `:hash` command to `dhall repl` + * This lets you conveniently hash expressions within the `dhall repl` + * See: https://github.com/dhall-lang/dhall-haskell/pull/806 +* Feature: Add `--check` flag to `dhall format` + * Use this to check if the input is already formatted + * Useful for continuous integration when you want to ensure that all code + under version control remains formatted + * See: https://github.com/dhall-lang/dhall-haskell/pull/810 +* Feature: Add `UnionInputType` builder for `InputType`s + * This is the union analog of `RecordInputType`, letting you build a + record explicitly instead of deriving the instance using GHC generics + * See: https://github.com/dhall-lang/dhall-haskell/pull/775 +* Feature: Add `:set`/`:unset` commands to `dhall repl` + * You can use these commands to set or unset command-line options + * Currently only setting/unsetting `--explain` is supported +* Standards-compliance fixes: + * See: https://github.com/dhall-lang/dhall-haskell/pull/779 + * See: https://github.com/dhall-lang/dhall-haskell/pull/804 + * See: https://github.com/dhall-lang/dhall-haskell/pull/833 +* Documentation fixes: + * See: https://github.com/dhall-lang/dhall-haskell/pull/792 + * See: https://github.com/dhall-lang/dhall-haskell/pull/825 +* Test fixes: + * See: https://github.com/dhall-lang/dhall-haskell/pull/782 + * See: https://github.com/dhall-lang/dhall-haskell/pull/836 +* Improved error messages: + * See: https://github.com/dhall-lang/dhall-haskell/pull/812 + * See: https://github.com/dhall-lang/dhall-haskell/pull/815 + * See: https://github.com/dhall-lang/dhall-haskell/pull/824 +* Formatting fixes: + * See: https://github.com/dhall-lang/dhall-haskell/pull/831 +* REPL fixes: + * See: https://github.com/dhall-lang/dhall-haskell/pull/837 + 1.20.1 * BUG FIX: Fix binary encoding to use correct standard version diff --git a/Prelude/Monoid b/Prelude/Monoid deleted file mode 100644 --- a/Prelude/Monoid +++ /dev/null @@ -1,1 +0,0 @@ -https://raw.githubusercontent.com/dhall-lang/Prelude/a22da69657b9316a3c51ba0bf80c9d4024db3fce/Monoid sha256:b306524b2f7fedd7dad0d328990e0b6271d93d6f2fbe7156474b757f5d8de187 diff --git a/Prelude/package.dhall b/Prelude/package.dhall deleted file mode 100644 --- a/Prelude/package.dhall +++ /dev/null @@ -1,1 +0,0 @@ -https://raw.githubusercontent.com/dhall-lang/Prelude/e9c90396c02f9eb0fe66c00c544615cbfa068f34/package.dhall sha256:26e13b153cb428366610110d4d8f0c135e22b20179d5478bb16b1b83b3f2ca13 diff --git a/benchmark/parser/Main.hs b/benchmark/parser/Main.hs --- a/benchmark/parser/Main.hs +++ b/benchmark/parser/Main.hs @@ -72,7 +72,7 @@ term <- case Codec.Serialise.deserialiseOrFail bytes of Left _ -> Nothing Right term -> return term - case Dhall.Binary.decodeWithVersion term of + case Dhall.Binary.decode term of Left _ -> Nothing Right expression -> return expression diff --git a/dhall-lang/Prelude/Bool/and b/dhall-lang/Prelude/Bool/and new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Bool/and @@ -0,0 +1,18 @@ +{- +The `and` function returns `False` if there are any `False` elements in the +`List` and returns `True` otherwise + +Examples: + +``` +./and [ True, False, True ] = False + +./and ([] : List Bool) = True +``` +-} + let and + : List Bool → Bool + = λ(xs : List Bool) + → List/fold Bool xs Bool (λ(l : Bool) → λ(r : Bool) → l && r) True + +in and diff --git a/dhall-lang/Prelude/Bool/build b/dhall-lang/Prelude/Bool/build new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Bool/build @@ -0,0 +1,17 @@ +{- +`build` is the inverse of `fold` + +Examples: + +``` +./build (λ(bool : Type) → λ(true : bool) → λ(false : bool) → true) = True + +./build (λ(bool : Type) → λ(true : bool) → λ(false : bool) → false) = False +``` +-} + let build + : (∀(bool : Type) → ∀(true : bool) → ∀(false : bool) → bool) → Bool + = λ(f : ∀(bool : Type) → ∀(true : bool) → ∀(false : bool) → bool) + → f Bool True False + +in build diff --git a/dhall-lang/Prelude/Bool/even b/dhall-lang/Prelude/Bool/even new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Bool/even @@ -0,0 +1,22 @@ +{- +Returns `True` if there are an even number of `False` elements in the list and +returns `False` otherwise + +Examples: + +``` +./even [ False, True, False ] = True + +./even [ False, True ] = False + +./even [ False ] = False + +./even ([] : List Bool) = True +``` +-} + let even + : List Bool → Bool + = λ(xs : List Bool) + → List/fold Bool xs Bool (λ(x : Bool) → λ(y : Bool) → x == y) True + +in even diff --git a/dhall-lang/Prelude/Bool/fold b/dhall-lang/Prelude/Bool/fold new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Bool/fold @@ -0,0 +1,20 @@ +{- +`fold` is essentially the same as `if`/`then`/else` except as a function + +Examples: + +``` +./fold True Natural 0 1 = 0 + +./fold False Natural 0 1 = 1 +``` +-} + let fold + : ∀(b : Bool) → ∀(bool : Type) → ∀(true : bool) → ∀(false : bool) → bool + = λ(b : Bool) + → λ(bool : Type) + → λ(true : bool) + → λ(false : bool) + → if b then true else false + +in fold diff --git a/dhall-lang/Prelude/Bool/not b/dhall-lang/Prelude/Bool/not new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Bool/not @@ -0,0 +1,12 @@ +{- +Flip the value of a `Bool` + +Examples: + +``` +./not True = False + +./not False = True +``` +-} +let not : Bool → Bool = λ(b : Bool) → b == False in not diff --git a/dhall-lang/Prelude/Bool/odd b/dhall-lang/Prelude/Bool/odd new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Bool/odd @@ -0,0 +1,22 @@ +{- +Returns `True` if there are an odd number of `True` elements in the list and +returns `False` otherwise + +Examples: + +``` +./odd [ True, False, True ] = False + +./odd [ True, False ] = True + +./odd [ True ] = True + +./odd ([] : List Bool) = False +``` +-} + let odd + : List Bool → Bool + = λ(xs : List Bool) + → List/fold Bool xs Bool (λ(x : Bool) → λ(y : Bool) → x != y) False + +in odd diff --git a/dhall-lang/Prelude/Bool/or b/dhall-lang/Prelude/Bool/or new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Bool/or @@ -0,0 +1,18 @@ +{- +The `or` function returns `True` if there are any `True` elements in the `List` +and returns `False` otherwise + +Examples: + +``` +./or [ True, False, True ] = True + +./or ([] : List Bool) = False +``` +-} + let or + : List Bool → Bool + = λ(xs : List Bool) + → List/fold Bool xs Bool (λ(l : Bool) → λ(r : Bool) → l || r) False + +in or diff --git a/dhall-lang/Prelude/Bool/package.dhall b/dhall-lang/Prelude/Bool/package.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Bool/package.dhall @@ -0,0 +1,17 @@ +{ and = + ./and +, build = + ./build +, even = + ./even +, fold = + ./fold +, not = + ./not +, odd = + ./odd +, or = + ./or +, show = + ./show +} diff --git a/dhall-lang/Prelude/Bool/show b/dhall-lang/Prelude/Bool/show new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Bool/show @@ -0,0 +1,13 @@ +{- +Render a `Bool` as `Text` using the same representation as Dhall source code +(i.e. beginning with a capital letter) + +Examples: + +``` +./show True = "True" + +./show False = "False" +``` +-} +let show : Bool → Text = λ(b : Bool) → if b then "True" else "False" in show diff --git a/dhall-lang/Prelude/Double/package.dhall b/dhall-lang/Prelude/Double/package.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Double/package.dhall @@ -0,0 +1,1 @@ +{ show = ./show } diff --git a/dhall-lang/Prelude/Double/show b/dhall-lang/Prelude/Double/show new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Double/show @@ -0,0 +1,13 @@ +{- +Render a `Double` as `Text` using the same representation as Dhall source +code (i.e. a decimal floating point number with a leading `-` sign if negative) + +Examples: + +``` +./show -3.1 = "-3.1" + +./show 0.4 = "0.4" +``` +-} +let show : Double → Text = Double/show in show diff --git a/dhall-lang/Prelude/Function/compose b/dhall-lang/Prelude/Function/compose new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Function/compose @@ -0,0 +1,21 @@ +{- +Compose two functions into one. + +Examples: + +``` +./compose Natural Natural Bool (λ(n : Natural) → n + n) ../Natural/even 3 += True +``` +-} + let compose + : ∀(a : Type) → ∀(b : Type) → ∀(c : Type) → (a → b) → (b → c) → a → c + = λ(A : Type) + → λ(B : Type) + → λ(C : Type) + → λ(f : A → B) + → λ(g : B → C) + → λ(x : A) + → g (f x) + +in compose diff --git a/dhall-lang/Prelude/Function/package.dhall b/dhall-lang/Prelude/Function/package.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Function/package.dhall @@ -0,0 +1,1 @@ +{ compose = ./compose } diff --git a/dhall-lang/Prelude/Integer/package.dhall b/dhall-lang/Prelude/Integer/package.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Integer/package.dhall @@ -0,0 +1,1 @@ +{ show = ./show, toDouble = ./toDouble } diff --git a/dhall-lang/Prelude/Integer/show b/dhall-lang/Prelude/Integer/show new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Integer/show @@ -0,0 +1,14 @@ +{- +Render an `Integer` as `Text` using the same representation as Dhall source +code (i.e. a decimal number with a leading `-` sign if negative and a leading +`+` sign if non-negative) + +Examples: + +``` +./show -3 = "-3" + +./show +0 = "+0" +``` +-} +let show : Integer → Text = Integer/show in show diff --git a/dhall-lang/Prelude/Integer/toDouble b/dhall-lang/Prelude/Integer/toDouble new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Integer/toDouble @@ -0,0 +1,12 @@ +{- +Convert an `Integer` to the corresponding `Double` + +Examples: + +``` +./toDouble -3 = -3.0 + +./toDouble +2 = 2.0 +``` +-} +let toDouble : Integer → Double = Integer/toDouble in toDouble diff --git a/dhall-lang/Prelude/JSON/Nesting b/dhall-lang/Prelude/JSON/Nesting new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/JSON/Nesting @@ -0,0 +1,32 @@ +{- +This type is used as part of `dhall-json`'s support for preserving alternative +names + +For example, this Dhall code: + +``` + let Example = < Left : { foo : Natural } | Right : { bar : Bool } > + +in let example = constructors Example + +in let Nesting = < Inline : {} | Nested : Text > + +in let nesting = constructors Nesting + +in { field = "name" + , nesting = nesting.Inline {=} + , contents = example.Left { foo = 2 } + } +``` + +... generates this JSON: + +``` +{ + "foo": 2, + "name": "Left" + } +``` + +-} +let Nesting : Type = < Inline : {} | Nested : Text > in Nesting diff --git a/dhall-lang/Prelude/JSON/Tagged b/dhall-lang/Prelude/JSON/Tagged new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/JSON/Tagged @@ -0,0 +1,69 @@ +{- +This is a convenient type-level function when using `dhall-to-json`'s support +for preserving alternative names + +For example, this code: + +``` + let map = ../List/map + +in let Provisioner = + < shell : + { inline : List Text } + | file : + { source : Text, destination : Text } + > + +in let provisioner = constructors Provisioner + +in let Tagged = ./Tagged + +in let nesting = constructors ./Nesting + +in let wrap + : Provisioner → Tagged Provisioner + = λ(x : Provisioner) + → { field = "type", nesting = nesting.Nested "params", contents = x } + +in { provisioners = + map + Provisioner + (Tagged Provisioner) + wrap + [ provisioner.shell { inline = [ "echo foo" ] } + , provisioner.file + { source = "app.tar.gz", destination = "/tmp/app.tar.gz" } + ] + } +``` + +... produces this JSON: + +``` +{ + "provisioners": [ + { + "params": { + "inline": [ + "echo foo" + ] + }, + "type": "shell" + }, + { + "params": { + "destination": "/tmp/app.tar.gz", + "source": "app.tar.gz" + }, + "type": "file" + } + ] +} +``` + +-} + let Tagged + : Type → Type + = λ(a : Type) → { field : Text, nesting : ./Nesting, contents : a } + +in Tagged diff --git a/dhall-lang/Prelude/JSON/keyText b/dhall-lang/Prelude/JSON/keyText new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/JSON/keyText @@ -0,0 +1,17 @@ +{- +Builds a key-value record such that a List of them will be converted to a +homogeneous record by dhall-to-json and dhall-to-yaml. +Both key and value are fixed to Text. +Take a look at `Record/keyValue` for a polymorphic version. + +Example: + +``` +./keyText "foo" "bar" = { mapKey = "foo", mapValue = "bar" } +``` +-} + + let keyText = + λ(key : Text) → λ(value : Text) → { mapKey = key, mapValue = value } + +in keyText diff --git a/dhall-lang/Prelude/JSON/keyValue b/dhall-lang/Prelude/JSON/keyValue new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/JSON/keyValue @@ -0,0 +1,20 @@ +{- +Builds a key-value record such that a List of them will be converted to a +homogeneous record by dhall-to-json and dhall-to-yaml. + +Examples: + +``` +./keyValue Natural "foo" 2 = { mapKey = "foo", mapValue = 2 } + +./keyValue Text "bar" "baz" = { mapKey = "bar", mapValue = "baz" } +``` +-} + + let keyValue = + λ(v : Type) + → λ(key : Text) + → λ(value : v) + → { mapKey = key, mapValue = value } + +in keyValue diff --git a/dhall-lang/Prelude/JSON/package.dhall b/dhall-lang/Prelude/JSON/package.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/JSON/package.dhall @@ -0,0 +1,1 @@ +{ keyText = ./keyText, keyValue = ./keyValue } diff --git a/dhall-lang/Prelude/List/all b/dhall-lang/Prelude/List/all new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/all @@ -0,0 +1,20 @@ +{- +Returns `True` if the supplied function returns `True` for all elements in the +`List` + +Examples: + +``` +./all Natural Natural/even [ 2, 3, 5 ] = False + +./all Natural Natural/even ([] : List Natural) = True +``` +-} + let all + : ∀(a : Type) → (a → Bool) → List a → Bool + = λ(a : Type) + → λ(f : a → Bool) + → λ(xs : List a) + → List/fold a xs Bool (λ(x : a) → λ(r : Bool) → f x && r) True + +in all diff --git a/dhall-lang/Prelude/List/any b/dhall-lang/Prelude/List/any new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/any @@ -0,0 +1,20 @@ +{- +Returns `True` if the supplied function returns `True` for any element in the +`List` + +Examples: + +``` +./any Natural Natural/even [ 2, 3, 5 ] = True + +./any Natural Natural/even ([] : List Natural) = False +``` +-} + let any + : ∀(a : Type) → (a → Bool) → List a → Bool + = λ(a : Type) + → λ(f : a → Bool) + → λ(xs : List a) + → List/fold a xs Bool (λ(x : a) → λ(r : Bool) → f x || r) False + +in any diff --git a/dhall-lang/Prelude/List/build b/dhall-lang/Prelude/List/build new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/build @@ -0,0 +1,32 @@ +{- +`build` is the inverse of `fold` + +Examples: + +``` +./build +Text +( λ(list : Type) +→ λ(cons : Text → list → list) +→ λ(nil : list) +→ cons "ABC" (cons "DEF" nil) +) += [ "ABC", "DEF" ] + +./build +Text +( λ(list : Type) +→ λ(cons : Text → list → list) +→ λ(nil : list) +→ nil +) += [] : List Text +``` +-} + let build + : ∀(a : Type) + → (∀(list : Type) → ∀(cons : a → list → list) → ∀(nil : list) → list) + → List a + = List/build + +in build diff --git a/dhall-lang/Prelude/List/concat b/dhall-lang/Prelude/List/concat new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/concat @@ -0,0 +1,42 @@ +{- +Concatenate a `List` of `List`s into a single `List` + +Examples: + +``` +./concat Natural +[ [0, 1, 2] +, [3, 4] +, [5, 6, 7, 8] +] += [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ] + +./concat Natural +( [ [] : List Natural + , [] : List Natural + , [] : List Natural + ] +) += [] : List Natural + +./concat Natural ([] : List (List Natural)) = [] : List Natural +``` +-} + let concat + : ∀(a : Type) → List (List a) → List a + = λ(a : Type) + → λ(xss : List (List a)) + → List/build + a + ( λ(list : Type) + → λ(cons : a → list → list) + → λ(nil : list) + → List/fold + (List a) + xss + list + (λ(xs : List a) → λ(ys : list) → List/fold a xs list cons ys) + nil + ) + +in concat diff --git a/dhall-lang/Prelude/List/concatMap b/dhall-lang/Prelude/List/concatMap new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/concatMap @@ -0,0 +1,28 @@ +{- +Transform a list by applying a function to each element and flattening the +results + +Examples: + +``` +./concatMap Natural Natural (λ(n : Natural) → [n, n]) [2, 3, 5] += [ 2, 2, 3, 3, 5, 5 ] + +./concatMap Natural Natural (λ(n : Natural) → [n, n]) ([] : List Natural) += [] : List Natural +``` +-} + let concatMap + : ∀(a : Type) → ∀(b : Type) → (a → List b) → List a → List b + = λ(a : Type) + → λ(b : Type) + → λ(f : a → List b) + → λ(xs : List a) + → List/build + b + ( λ(list : Type) + → λ(cons : b → list → list) + → List/fold a xs list (λ(x : a) → List/fold b (f x) list cons) + ) + +in concatMap diff --git a/dhall-lang/Prelude/List/filter b/dhall-lang/Prelude/List/filter new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/filter @@ -0,0 +1,30 @@ +{- +Only keep elements of the list where the supplied function returns `True` + +Examples: + +``` +./filter Natural Natural/even [ 2, 3, 5 ] += [ 2 ] + +./filter Natural Natural/odd [ 2, 3, 5 ] += [ 3, 5 ] +``` +-} + let filter + : ∀(a : Type) → (a → Bool) → List a → List a + = λ(a : Type) + → λ(f : a → Bool) + → λ(xs : List a) + → List/build + a + ( λ(list : Type) + → λ(cons : a → list → list) + → List/fold + a + xs + list + (λ(x : a) → λ(xs : list) → if f x then cons x xs else xs) + ) + +in filter diff --git a/dhall-lang/Prelude/List/fold b/dhall-lang/Prelude/List/fold new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/fold @@ -0,0 +1,46 @@ +{- +`fold` is the primitive function for consuming `List`s + +If you treat the list `[ x, y, z ]` as `cons x (cons y (cons z nil))`, then a +`fold` just replaces each `cons` and `nil` with something else + +Examples: + +``` + ./fold + Natural + [ 2, 3, 5 ] + Natural + (λ(x : Natural) → λ(y : Natural) → x + y) + 0 += 10 + + λ(nil : Natural) +→ ./fold + Natural + [ 2, 3, 5 ] + Natural + (λ(x : Natural) → λ(y : Natural) → x + y) + nil += λ(nil : Natural) → 2 + (3 + (5 + nil)) + + λ(list : Type) +→ λ(cons : Natural → list → list) +→ λ(nil : list) +→ ./fold Natural [ 2, 3, 5 ] list cons nil += λ(list : Type) +→ λ(cons : Natural → list → list) +→ λ(nil : list) +→ cons 2 (cons 3 (cons 5 nil)) +``` +-} + let fold + : ∀(a : Type) + → List a + → ∀(list : Type) + → ∀(cons : a → list → list) + → ∀(nil : list) + → list + = List/fold + +in fold diff --git a/dhall-lang/Prelude/List/generate b/dhall-lang/Prelude/List/generate new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/generate @@ -0,0 +1,38 @@ +{- +Build a list by calling the supplied function on all `Natural` numbers from `0` +up to but not including the supplied `Natural` number + +Examples: + +``` +./generate 5 Bool Natural/even = [ True, False, True, False, True ] + +./generate 0 Bool Natural/even = [] : List Bool +``` +-} + let generate + : Natural → ∀(a : Type) → (Natural → a) → List a + = λ(n : Natural) + → λ(a : Type) + → λ(f : Natural → a) + → List/build + a + ( λ(list : Type) + → λ(cons : a → list → list) + → List/fold + { index : Natural, value : {} } + ( List/indexed + {} + ( List/build + {} + ( λ(list : Type) + → λ(cons : {} → list → list) + → Natural/fold n list (cons {=}) + ) + ) + ) + list + (λ(x : { index : Natural, value : {} }) → cons (f x.index)) + ) + +in generate diff --git a/dhall-lang/Prelude/List/head b/dhall-lang/Prelude/List/head new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/head @@ -0,0 +1,12 @@ +{- +Retrieve the first element of the list + +Examples: + +``` +./head Natural [ 0, 1, 2 ] = Some 0 + +./head Natural ([] : List Natural) = None Natural +``` +-} +let head : ∀(a : Type) → List a → Optional a = List/head in head diff --git a/dhall-lang/Prelude/List/indexed b/dhall-lang/Prelude/List/indexed new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/indexed @@ -0,0 +1,21 @@ +{- +Tag each element of the list with its index + +Examples: + +``` +./indexed Bool [ True, False, True ] += [ { index = 0, value = True } + , { index = 1, value = False } + , { index = 2, value = True } + ] : List { index : Natural, value : Bool } + +./indexed Bool ([] : List Bool) += [] : List { index : Natural, value : Bool } +``` +-} + let indexed + : ∀(a : Type) → List a → List { index : Natural, value : a } + = List/indexed + +in indexed diff --git a/dhall-lang/Prelude/List/iterate b/dhall-lang/Prelude/List/iterate new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/iterate @@ -0,0 +1,43 @@ +{- +Generate a list of the specified length given a seed value and transition +function + +Examples: + +``` +./iterate 10 Natural (λ(x : Natural) → x * 2) 1 += [ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 ] + +./iterate 0 Natural (λ(x : Natural) → x * 2) 1 += [] : List Natural +``` +-} + let iterate + : Natural → ∀(a : Type) → (a → a) → a → List a + = λ(n : Natural) + → λ(a : Type) + → λ(f : a → a) + → λ(x : a) + → List/build + a + ( λ(list : Type) + → λ(cons : a → list → list) + → List/fold + { index : Natural, value : {} } + ( List/indexed + {} + ( List/build + {} + ( λ(list : Type) + → λ(cons : {} → list → list) + → Natural/fold n list (cons {=}) + ) + ) + ) + list + ( λ(y : { index : Natural, value : {} }) + → cons (Natural/fold y.index a f x) + ) + ) + +in iterate diff --git a/dhall-lang/Prelude/List/last b/dhall-lang/Prelude/List/last new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/last @@ -0,0 +1,12 @@ +{- +Retrieve the last element of the list + +Examples: + +``` +./last Natural [ 0, 1, 2 ] = Some 2 + +./last Natural ([] : List Natural) = None Natural +``` +-} +let last : ∀(a : Type) → List a → Optional a = List/last in last diff --git a/dhall-lang/Prelude/List/length b/dhall-lang/Prelude/List/length new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/length @@ -0,0 +1,12 @@ +{- +Returns the number of elements in a list + +Examples: + +``` +./length Natural [ 0, 1, 2 ] = 3 + +./length Natural ([] : List Natural) = 0 +``` +-} +let length : ∀(a : Type) → List a → Natural = List/length in length diff --git a/dhall-lang/Prelude/List/map b/dhall-lang/Prelude/List/map new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/map @@ -0,0 +1,27 @@ +{- +Transform a list by applying a function to each element + +Examples: + +``` +./map Natural Bool Natural/even [ 2, 3, 5 ] += [ True, False, False ] + +./map Natural Bool Natural/even ([] : List Natural) += [] : List Bool +``` +-} + let map + : ∀(a : Type) → ∀(b : Type) → (a → b) → List a → List b + = λ(a : Type) + → λ(b : Type) + → λ(f : a → b) + → λ(xs : List a) + → List/build + b + ( λ(list : Type) + → λ(cons : b → list → list) + → List/fold a xs list (λ(x : a) → cons (f x)) + ) + +in map diff --git a/dhall-lang/Prelude/List/null b/dhall-lang/Prelude/List/null new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/null @@ -0,0 +1,16 @@ +{- +Returns `True` if the `List` is empty and `False` otherwise + +Examples: + +``` +./null Natural [ 0, 1, 2 ] = False + +./null Natural ([] : List Natural) = True +``` +-} + let null + : ∀(a : Type) → List a → Bool + = λ(a : Type) → λ(xs : List a) → Natural/isZero (List/length a xs) + +in null diff --git a/dhall-lang/Prelude/List/package.dhall b/dhall-lang/Prelude/List/package.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/package.dhall @@ -0,0 +1,39 @@ +{ all = + ./all +, any = + ./any +, build = + ./build +, concat = + ./concat +, concatMap = + ./concatMap +, filter = + ./filter +, fold = + ./fold +, generate = + ./generate +, head = + ./head +, indexed = + ./indexed +, iterate = + ./iterate +, last = + ./last +, length = + ./length +, map = + ./map +, null = + ./null +, replicate = + ./replicate +, reverse = + ./reverse +, shifted = + ./shifted +, unzip = + ./unzip +} diff --git a/dhall-lang/Prelude/List/replicate b/dhall-lang/Prelude/List/replicate new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/replicate @@ -0,0 +1,24 @@ +{- +Build a list by copying the given element the specified number of times + +Examples: + +``` +./replicate 9 Natural 1 = [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ] + +./replicate 0 Natural 1 = [] : List Natural +``` +-} + let replicate + : Natural → ∀(a : Type) → a → List a + = λ(n : Natural) + → λ(a : Type) + → λ(x : a) + → List/build + a + ( λ(list : Type) + → λ(cons : a → list → list) + → Natural/fold n list (cons x) + ) + +in replicate diff --git a/dhall-lang/Prelude/List/reverse b/dhall-lang/Prelude/List/reverse new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/reverse @@ -0,0 +1,12 @@ +{- +Reverse a list + +Examples: + +``` +./reverse Natural [ 0, 1, 2 ] = [ 2, 1, 0 ] : List Natural + +./reverse Natural ([] : List Natural) = [] : List Natural +``` +-} +let reverse : ∀(a : Type) → List a → List a = List/reverse in reverse diff --git a/dhall-lang/Prelude/List/shifted b/dhall-lang/Prelude/List/shifted new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/shifted @@ -0,0 +1,90 @@ +{- +Combine a `List` of `List`s, offsetting the `index` of each element by the +number of elements in preceding lists + +Examples: + +``` +./shifted +Bool +[ [ { index = 0, value = True } + , { index = 1, value = True } + , { index = 2, value = True } + ] +, [ { index = 0, value = False } + , { index = 1, value = False } + ] +, [ { index = 0, value = True } + , { index = 1, value = True } + , { index = 2, value = True } + , { index = 3, value = True } + ] +] += [ { index = 0, value = True } + , { index = 1, value = True } + , { index = 2, value = True } + , { index = 3, value = False } + , { index = 4, value = False } + , { index = 5, value = True } + , { index = 6, value = True } + , { index = 7, value = True } + , { index = 8, value = True } + ] + +./shifted Bool ([] : List (List { index : Natural, value : Bool })) += [] : List { index : Natural, value : Bool } +``` +-} + let shifted + : ∀(a : Type) + → List (List { index : Natural, value : a }) + → List { index : Natural, value : a } + = λ(a : Type) + → λ(kvss : List (List { index : Natural, value : a })) + → List/build + { index : Natural, value : a } + ( λ(list : Type) + → λ(cons : { index : Natural, value : a } → list → list) + → λ(nil : list) + → let result = + List/fold + (List { index : Natural, value : a }) + kvss + { count : Natural, diff : Natural → list } + ( λ(kvs : List { index : Natural, value : a }) + → λ(y : { count : Natural, diff : Natural → list }) + → let length = + List/length + { index : Natural, value : a } + kvs + + in { count = + y.count + length + , diff = + λ(n : Natural) + → List/fold + { index : Natural, value : a } + kvs + list + ( λ ( kvOld + : { index : Natural, value : a } + ) + → λ(z : list) + → let kvNew = + { index = + kvOld.index + n + , value = + kvOld.value + } + + in cons kvNew z + ) + (y.diff (n + length)) + } + ) + { count = 0, diff = λ(_ : Natural) → nil } + + in result.diff 0 + ) + +in shifted diff --git a/dhall-lang/Prelude/List/unzip b/dhall-lang/Prelude/List/unzip new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/List/unzip @@ -0,0 +1,55 @@ +{- +Unzip a `List` into two separate `List`s + +Examples: + +``` +./unzip +Text +Bool +( [ { _1 = "ABC", _2 = True } + , { _1 = "DEF", _2 = False } + , { _1 = "GHI", _2 = True } + ] +) += { _1 = [ "ABC", "DEF", "GHI" ] + , _2 = [ True, False, True ] + } + +./unzip Text Bool ([] : List { _1 : Text, _2 : Bool }) += { _1 = [] : List Text, _2 = [] : List Bool } +``` +-} + let unzip + : ∀(a : Type) + → ∀(b : Type) + → List { _1 : a, _2 : b } + → { _1 : List a, _2 : List b } + = λ(a : Type) + → λ(b : Type) + → λ(xs : List { _1 : a, _2 : b }) + → { _1 = + List/build + a + ( λ(list : Type) + → λ(cons : a → list → list) + → List/fold + { _1 : a, _2 : b } + xs + list + (λ(x : { _1 : a, _2 : b }) → cons x._1) + ) + , _2 = + List/build + b + ( λ(list : Type) + → λ(cons : b → list → list) + → List/fold + { _1 : a, _2 : b } + xs + list + (λ(x : { _1 : a, _2 : b }) → cons x._2) + ) + } + +in unzip diff --git a/dhall-lang/Prelude/Monoid b/dhall-lang/Prelude/Monoid new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Monoid @@ -0,0 +1,39 @@ +{- +Any function `f` that is a `Monoid` must satisfy the following law: + +``` +t : Type +f : ./Monoid t +xs : List (List t) + +f (./List/concat t xs) = f (./map (List t) t f xs) +``` + +Examples: + +``` +./Bool/and + : ./Monoid Bool +./Bool/or + : ./Monoid Bool +./Bool/even + : ./Monoid Bool +./Bool/odd + : ./Monoid Bool +./List/concat + : ∀(a : Type) → ./Monoid (List a) +./List/shifted + : ∀(a : Type) → ./Monoid (List { index : Natural, value : a }) +./Natural/sum + : ./Monoid Natural +./Natural/product + : ./Monoid Natural +./Optional/head + : ∀(a : Type) → ./Monoid (Optional a) +./Optional/last + : ∀(a : Type) → ./Monoid (Optional a) +./Text/concat + : ./Monoid Text +``` +-} +let Monoid : ∀(m : Type) → Type = λ(m : Type) → List m → m in Monoid diff --git a/dhall-lang/Prelude/Natural/build b/dhall-lang/Prelude/Natural/build new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/build @@ -0,0 +1,33 @@ +{- +`build` is the inverse of `fold` + +Examples: + +``` +./build +( λ(natural : Type) +→ λ(succ : natural → natural) +→ λ(zero : natural) +→ succ (succ (succ zero)) +) += 3 + +./build +( λ(natural : Type) +→ λ(succ : natural → natural) +→ λ(zero : natural) +→ zero +) += 0 +``` +-} + let build + : ( ∀(natural : Type) + → ∀(succ : natural → natural) + → ∀(zero : natural) + → natural + ) + → Natural + = Natural/build + +in build diff --git a/dhall-lang/Prelude/Natural/enumerate b/dhall-lang/Prelude/Natural/enumerate new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/enumerate @@ -0,0 +1,36 @@ +{- +Generate a list of numbers from `0` up to but not including the specified +number + +Examples: + +``` +./enumerate 10 = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ] + +./enumerate 0 = [] : List Natural +``` +-} + let enumerate + : Natural → List Natural + = λ(n : Natural) + → List/build + Natural + ( λ(list : Type) + → λ(cons : Natural → list → list) + → List/fold + { index : Natural, value : {} } + ( List/indexed + {} + ( List/build + {} + ( λ(list : Type) + → λ(cons : {} → list → list) + → Natural/fold n list (cons {=}) + ) + ) + ) + list + (λ(x : { index : Natural, value : {} }) → cons x.index) + ) + +in enumerate diff --git a/dhall-lang/Prelude/Natural/even b/dhall-lang/Prelude/Natural/even new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/even @@ -0,0 +1,12 @@ +{- +Returns `True` if a number if even and returns `False` otherwise + +Examples: + +``` +./even 3 = False + +./even 0 = True +``` +-} +let even : Natural → Bool = Natural/even in even diff --git a/dhall-lang/Prelude/Natural/fold b/dhall-lang/Prelude/Natural/fold new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/fold @@ -0,0 +1,33 @@ +{- +`fold` is the primitive function for consuming `Natural` numbers + +If you treat the number `3` as `succ (succ (succ zero))` then a `fold` just +replaces each `succ` and `zero` with something else + +Examples: + +``` +./fold 3 Natural (λ(x : Natural) → 5 * x) 1 = 125 + +λ(zero : Natural) → ./fold 3 Natural (λ(x : Natural) → 5 * x) zero += λ(zero : Natural) → 5 * (5 * (5 * zero)) + + λ(natural : Type) +→ λ(succ : natural → natural) +→ λ(zero : natural) +→ ./fold 3 natural succ zero += λ(natural : Type) +→ λ(succ : natural → natural) +→ λ(zero : natural) +→ succ (succ (succ zero)) +``` +-} + let fold + : Natural + → ∀(natural : Type) + → ∀(succ : natural → natural) + → ∀(zero : natural) + → natural + = Natural/fold + +in fold diff --git a/dhall-lang/Prelude/Natural/isZero b/dhall-lang/Prelude/Natural/isZero new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/isZero @@ -0,0 +1,12 @@ +{- +Returns `True` if a number is `0` and returns `False` otherwise + +Examples: + +``` +./isZero 2 = False + +./isZero 0 = True +``` +-} +let isZero : Natural → Bool = Natural/isZero in isZero diff --git a/dhall-lang/Prelude/Natural/odd b/dhall-lang/Prelude/Natural/odd new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/odd @@ -0,0 +1,12 @@ +{- +Returns `True` if a number is odd and returns `False` otherwise + +Examples: + +``` +./odd 3 = True + +./odd 0 = False +``` +-} +let odd : Natural → Bool = Natural/odd in odd diff --git a/dhall-lang/Prelude/Natural/package.dhall b/dhall-lang/Prelude/Natural/package.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/package.dhall @@ -0,0 +1,23 @@ +{ build = + ./build +, enumerate = + ./enumerate +, even = + ./even +, fold = + ./fold +, isZero = + ./isZero +, odd = + ./odd +, product = + ./product +, sum = + ./sum +, show = + ./show +, toDouble = + ./toDouble +, toInteger = + ./toInteger +} diff --git a/dhall-lang/Prelude/Natural/product b/dhall-lang/Prelude/Natural/product new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/product @@ -0,0 +1,22 @@ +{- +Multiply all the numbers in a `List` + +Examples: + +``` +./product [ 2, 3, 5 ] = 30 + +./product ([] : List Natural) = 1 +``` +-} + let product + : List Natural → Natural + = λ(xs : List Natural) + → List/fold + Natural + xs + Natural + (λ(l : Natural) → λ(r : Natural) → l * r) + 1 + +in product diff --git a/dhall-lang/Prelude/Natural/show b/dhall-lang/Prelude/Natural/show new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/show @@ -0,0 +1,13 @@ +{- +Render a `Natural` number as `Text` using the same representation as Dhall +source code (i.e. a decimal number) + +Examples: + +``` +./show 3 = "3" + +./show 0 = "0" +``` +-} +let show : Natural → Text = Natural/show in show diff --git a/dhall-lang/Prelude/Natural/sum b/dhall-lang/Prelude/Natural/sum new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/sum @@ -0,0 +1,22 @@ +{- +Add all the numbers in a `List` + +Examples: + +``` +./sum [ 2, 3, 5 ] = 10 + +./sum ([] : List Natural) = 0 +``` +-} + let sum + : List Natural → Natural + = λ(xs : List Natural) + → List/fold + Natural + xs + Natural + (λ(l : Natural) → λ(r : Natural) → l + r) + 0 + +in sum diff --git a/dhall-lang/Prelude/Natural/toDouble b/dhall-lang/Prelude/Natural/toDouble new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/toDouble @@ -0,0 +1,16 @@ +{- +Convert a `Natural` number to the corresponding `Double` + +Examples: + +``` +./toDouble 3 = 3.0 + +./toDouble 0 = 0.0 +``` +-} + let toDouble + : Natural → Double + = λ(n : Natural) → Integer/toDouble (Natural/toInteger n) + +in toDouble diff --git a/dhall-lang/Prelude/Natural/toInteger b/dhall-lang/Prelude/Natural/toInteger new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Natural/toInteger @@ -0,0 +1,12 @@ +{- +Convert a `Natural` number to the corresponding `Integer` + +Examples: + +``` +./toInteger 3 = +3 + +./toInteger 0 = +0 +``` +-} +let toInteger : Natural → Integer = Natural/toInteger in toInteger diff --git a/dhall-lang/Prelude/Optional/all b/dhall-lang/Prelude/Optional/all new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/all @@ -0,0 +1,20 @@ +{- +Returns `False` if the supplied function returns `False` for a present element +and `True` otherwise: + +Examples: + +``` +./all Natural Natural/even (Some 3) = False + +./all Natural Natural/even (None Natural) = True +``` +-} + let all + : ∀(a : Type) → (a → Bool) → Optional a → Bool + = λ(a : Type) + → λ(f : a → Bool) + → λ(xs : Optional a) + → Optional/fold a xs Bool f True + +in all diff --git a/dhall-lang/Prelude/Optional/any b/dhall-lang/Prelude/Optional/any new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/any @@ -0,0 +1,20 @@ +{- +Returns `True` if the supplied function returns `True` for a present element and +`False` otherwise + +Examples: + +``` +./any Natural Natural/even (Some 2) = True + +./any Natural Natural/even (None Natural) = False +``` +-} + let any + : ∀(a : Type) → (a → Bool) → Optional a → Bool + = λ(a : Type) + → λ(f : a → Bool) + → λ(xs : Optional a) + → Optional/fold a xs Bool f False + +in any diff --git a/dhall-lang/Prelude/Optional/build b/dhall-lang/Prelude/Optional/build new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/build @@ -0,0 +1,36 @@ +{- +`build` is the inverse of `fold` + +Examples: + +``` +./build +Natural +( λ(optional : Type) +→ λ(some : Natural → optional) +→ λ(none : optional) +→ some 1 +) += Some 1 + +./build +Natural +( λ(optional : Type) +→ λ(some : Natural → optional) +→ λ(none : optional) +→ none +) += None Natural +``` +-} + let build + : ∀(a : Type) + → ( ∀(optional : Type) + → ∀(some : a → optional) + → ∀(none : optional) + → optional + ) + → Optional a + = Optional/build + +in build diff --git a/dhall-lang/Prelude/Optional/concat b/dhall-lang/Prelude/Optional/concat new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/concat @@ -0,0 +1,28 @@ +{- +Flatten two `Optional` layers into a single `Optional` layer + +Examples: + +``` +./concat Natural (Some (Some 1)) += Some 1 + +./concat Natural (Some (None Natural)) += None Natural + +./concat Natural (None (Optional Natural)) += None Natural +``` +-} + let concat + : ∀(a : Type) → Optional (Optional a) → Optional a + = λ(a : Type) + → λ(x : Optional (Optional a)) + → Optional/fold + (Optional a) + x + (Optional a) + (λ(y : Optional a) → y) + (None a) + +in concat diff --git a/dhall-lang/Prelude/Optional/filter b/dhall-lang/Prelude/Optional/filter new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/filter @@ -0,0 +1,32 @@ +{- +Only keep an `Optional` element if the supplied function returns `True` + +Examples: + +``` +./filter Natural Natural/even (Some 2) += Some 2 + +./filter Natural Natural/odd (Some 2) += None Natural +``` +-} + let filter + : ∀(a : Type) → (a → Bool) → Optional a → Optional a + = λ(a : Type) + → λ(f : a → Bool) + → λ(xs : Optional a) + → Optional/build + a + ( λ(optional : Type) + → λ(some : a → optional) + → λ(none : optional) + → Optional/fold + a + xs + optional + (λ(x : a) → if f x then some x else none) + none + ) + +in filter diff --git a/dhall-lang/Prelude/Optional/fold b/dhall-lang/Prelude/Optional/fold new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/fold @@ -0,0 +1,21 @@ +{- +`fold` is the primitive function for consuming `Optional` values + +Examples: + +``` +./fold Natural (Some 2) Natural (λ(x : Natural) → x) 0 = 2 + +./fold Natural (None Natural) Natural (λ(x : Natural) → x) 0 = 0 +``` +-} + let fold + : ∀(a : Type) + → Optional a + → ∀(optional : Type) + → ∀(some : a → optional) + → ∀(none : optional) + → optional + = Optional/fold + +in fold diff --git a/dhall-lang/Prelude/Optional/head b/dhall-lang/Prelude/Optional/head new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/head @@ -0,0 +1,28 @@ +{- +Returns the first non-empty `Optional` value in a `List` + +Examples: + +``` +./head Natural [ None Natural, Some 1, Some 2 ] = Some 1 + +./head Natural [ None Natural, None Natural ] = None Natural + +./head Natural ([] : List (Optional Natural)) = None Natural +``` +-} + let head + : ∀(a : Type) → List (Optional a) → Optional a + = λ(a : Type) + → λ(xs : List (Optional a)) + → List/fold + (Optional a) + xs + (Optional a) + ( λ(l : Optional a) + → λ(r : Optional a) + → Optional/fold a l (Optional a) (λ(x : a) → Some x) r + ) + (None a) + +in head diff --git a/dhall-lang/Prelude/Optional/last b/dhall-lang/Prelude/Optional/last new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/last @@ -0,0 +1,28 @@ +{- +Returns the last non-empty `Optional` value in a `List` + +Examples: + +``` +./last Natural [ None Natural, Some 1, Some 2 ] = Some 2 + +./last Natural [ None Natural, None Natural ] = None Natural + +./last Natural ([] : List (Optional Natural)) = None Natural +``` +-} + let last + : ∀(a : Type) → List (Optional a) → Optional a + = λ(a : Type) + → λ(xs : List (Optional a)) + → List/fold + (Optional a) + xs + (Optional a) + ( λ(l : Optional a) + → λ(r : Optional a) + → Optional/fold a r (Optional a) (λ(x : a) → Some x) l + ) + (None a) + +in last diff --git a/dhall-lang/Prelude/Optional/length b/dhall-lang/Prelude/Optional/length new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/length @@ -0,0 +1,18 @@ +{- +Returns `1` if the `Optional` value is present and `0` if the value is absent + +Examples: + +``` +./length Natural (Some 2) = 1 + +./length Natural (None Natural) = 0 +``` +-} + let length + : ∀(a : Type) → Optional a → Natural + = λ(a : Type) + → λ(xs : Optional a) + → Optional/fold a xs Natural (λ(_ : a) → 1) 0 + +in length diff --git a/dhall-lang/Prelude/Optional/map b/dhall-lang/Prelude/Optional/map new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/map @@ -0,0 +1,20 @@ +{- +Transform an `Optional` value with a function + +Examples: + +``` +./map Natural Bool Natural/even (Some 3) = Some False + +./map Natural Bool Natural/even (None Natural) = None Bool +``` +-} + let map + : ∀(a : Type) → ∀(b : Type) → (a → b) → Optional a → Optional b + = λ(a : Type) + → λ(b : Type) + → λ(f : a → b) + → λ(o : Optional a) + → Optional/fold a o (Optional b) (λ(x : a) → Some (f x)) (None b) + +in map diff --git a/dhall-lang/Prelude/Optional/null b/dhall-lang/Prelude/Optional/null new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/null @@ -0,0 +1,18 @@ +{- +Returns `True` if the `Optional` value is absent and `False` if present + +Examples: + +``` +./null Natural (Some 2) = False + +./null Natural (None Natural) = True +``` +-} + let null + : ∀(a : Type) → Optional a → Bool + = λ(a : Type) + → λ(xs : Optional a) + → Optional/fold a xs Bool (λ(_ : a) → False) True + +in null diff --git a/dhall-lang/Prelude/Optional/package.dhall b/dhall-lang/Prelude/Optional/package.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/package.dhall @@ -0,0 +1,27 @@ +{ all = + ./all +, any = + ./any +, build = + ./build +, concat = + ./concat +, filter = + ./filter +, fold = + ./fold +, head = + ./head +, last = + ./last +, length = + ./length +, map = + ./map +, null = + ./null +, toList = + ./toList +, unzip = + ./unzip +} diff --git a/dhall-lang/Prelude/Optional/toList b/dhall-lang/Prelude/Optional/toList new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/toList @@ -0,0 +1,18 @@ +{- +Convert an `Optional` value into the equivalent `List` + +Examples: + +``` +./toList Natural (Some 1) = [ 1 ] + +./toList Natural (None Natural) = [] : List Natural +``` +-} + let toList + : ∀(a : Type) → Optional a → List a + = λ(a : Type) + → λ(o : Optional a) + → Optional/fold a o (List a) (λ(x : a) → [ x ] : List a) ([] : List a) + +in toList diff --git a/dhall-lang/Prelude/Optional/unzip b/dhall-lang/Prelude/Optional/unzip new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Optional/unzip @@ -0,0 +1,38 @@ +{- +Unzip an `Optional` value into two separate `Optional` values + +Examples: + +``` +./unzip Text Bool (Some { _1 = "ABC", _2 = True }) += { _1 = Some "ABC", _2 = Some True } + +./unzip Text Bool (None { _1 : Text, _2 : Bool }) += { _1 = None Text, _2 = None Bool } +``` +-} + let unzip + : ∀(a : Type) + → ∀(b : Type) + → Optional { _1 : a, _2 : b } + → { _1 : Optional a, _2 : Optional b } + = λ(a : Type) + → λ(b : Type) + → λ(xs : Optional { _1 : a, _2 : b }) + → { _1 = + Optional/fold + { _1 : a, _2 : b } + xs + (Optional a) + (λ(x : { _1 : a, _2 : b }) → Some x._1) + (None a) + , _2 = + Optional/fold + { _1 : a, _2 : b } + xs + (Optional b) + (λ(x : { _1 : a, _2 : b }) → Some x._2) + (None b) + } + +in unzip diff --git a/dhall-lang/Prelude/Text/concat b/dhall-lang/Prelude/Text/concat new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Text/concat @@ -0,0 +1,17 @@ +{- +Concatenate all the `Text` values in a `List` + +Examples: + +``` +./concat [ "ABC", "DEF", "GHI" ] = "ABCDEFGHI" + +./concat ([] : List Text) = "" +``` +-} + let concat + : List Text → Text + = λ(xs : List Text) + → List/fold Text xs Text (λ(x : Text) → λ(y : Text) → x ++ y) "" + +in concat diff --git a/dhall-lang/Prelude/Text/concatMap b/dhall-lang/Prelude/Text/concatMap new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Text/concatMap @@ -0,0 +1,21 @@ +{- +Transform each value in a `List` into `Text` and concatenate the result + +Examples: + +``` +./concatMap Natural (λ(n : Natural) → "${Natural/show n} ") [ 0, 1, 2 ] += "0 1 2 " + +./concatMap Natural (λ(n : Natural) → "${Natural/show n} ") ([] : List Natural) += "" +``` +-} + let concatMap + : ∀(a : Type) → (a → Text) → List a → Text + = λ(a : Type) + → λ(f : a → Text) + → λ(xs : List a) + → List/fold a xs Text (λ(x : a) → λ(y : Text) → f x ++ y) "" + +in concatMap diff --git a/dhall-lang/Prelude/Text/concatMapSep b/dhall-lang/Prelude/Text/concatMapSep new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Text/concatMapSep @@ -0,0 +1,47 @@ +{- +Transform each value in a `List` to `Text` and then concatenate them with a +separator in between each value + +Examples: + +``` +./concatMapSep ", " Natural Natural/show [ 0, 1, 2 ] = "0, 1, 2" + +./concatMapSep ", " Natural Natural/show ([] : List Natural) = "" +``` +-} + let concatMapSep + : ∀(separator : Text) → ∀(a : Type) → (a → Text) → List a → Text + = λ(separator : Text) + → λ(a : Type) + → λ(f : a → Text) + → λ(elements : List a) + → let status = + List/fold + a + elements + < Empty : {} | NonEmpty : Text > + ( λ(element : a) + → λ(status : < Empty : {} | NonEmpty : Text >) + → merge + { Empty = + λ(_ : {}) → < NonEmpty = f element | Empty : {} > + , NonEmpty = + λ(result : Text) + → < NonEmpty = + f element ++ separator ++ result + | Empty : + {} + > + } + status + : < Empty : {} | NonEmpty : Text > + ) + < Empty = {=} | NonEmpty : Text > + + in merge + { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } + status + : Text + +in concatMapSep diff --git a/dhall-lang/Prelude/Text/concatSep b/dhall-lang/Prelude/Text/concatSep new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Text/concatSep @@ -0,0 +1,44 @@ +{- +Concatenate a `List` of `Text` values with a separator in between each value + +Examples: + +``` +./concatSep ", " [ "ABC", "DEF", "GHI" ] = "ABC, DEF, GHI" + +./concatSep ", " ([] : List Text) = "" +``` +-} + let concatSep + : ∀(separator : Text) → ∀(elements : List Text) → Text + = λ(separator : Text) + → λ(elements : List Text) + → let status = + List/fold + Text + elements + < Empty : {} | NonEmpty : Text > + ( λ(element : Text) + → λ(status : < Empty : {} | NonEmpty : Text >) + → merge + { Empty = + λ(_ : {}) → < NonEmpty = element | Empty : {} > + , NonEmpty = + λ(result : Text) + → < NonEmpty = + element ++ separator ++ result + | Empty : + {} + > + } + status + : < Empty : {} | NonEmpty : Text > + ) + < Empty = {=} | NonEmpty : Text > + + in merge + { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } + status + : Text + +in concatSep diff --git a/dhall-lang/Prelude/Text/package.dhall b/dhall-lang/Prelude/Text/package.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Text/package.dhall @@ -0,0 +1,11 @@ +{ concat = + ./concat +, concatMap = + ./concatMap +, concatMapSep = + ./concatMapSep +, concatSep = + ./concatSep +, show = + ./show +} diff --git a/dhall-lang/Prelude/Text/show b/dhall-lang/Prelude/Text/show new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/Text/show @@ -0,0 +1,13 @@ +{- +Render a `Text` literal as its own representation as Dhall source code (i.e. a +double-quoted string literal) + +Examples: + +``` +./show "ABC" = "\"ABC\"" + +./show "\u0000 \$ \\ \n \u263a" = "\"\\u0000 \\u0024 \\\\ \\n ☺\"" +``` +-} +let show : Text → Text = Text/show in show diff --git a/dhall-lang/Prelude/package.dhall b/dhall-lang/Prelude/package.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/Prelude/package.dhall @@ -0,0 +1,19 @@ +{ `Bool` = + ./Bool/package.dhall +, `Double` = + ./Double/package.dhall +, Function = + ./Function/package.dhall +, `Integer` = + ./Integer/package.dhall +, `List` = + ./List/package.dhall +, `Natural` = + ./Natural/package.dhall +, `Optional` = + ./Optional/package.dhall +, JSON = + ./JSON/package.dhall +, `Text` = + ./Text/package.dhall +} diff --git a/dhall-lang/tests/import/data/fieldOrder/1.dhall b/dhall-lang/tests/import/data/fieldOrder/1.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/data/fieldOrder/1.dhall @@ -0,0 +1,1 @@ +{ foo = 1, bar = True } diff --git a/dhall-lang/tests/import/data/fieldOrder/2.dhall b/dhall-lang/tests/import/data/fieldOrder/2.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/data/fieldOrder/2.dhall @@ -0,0 +1,1 @@ +{ bar = True, foo = 1 } diff --git a/dhall-lang/tests/import/failure/alternativeEnv.dhall b/dhall-lang/tests/import/failure/alternativeEnv.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/failure/alternativeEnv.dhall @@ -0,0 +1,1 @@ +env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 diff --git a/dhall-lang/tests/import/failure/alternativeEnvMissing.dhall b/dhall-lang/tests/import/failure/alternativeEnvMissing.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/failure/alternativeEnvMissing.dhall @@ -0,0 +1,1 @@ +env:UNSET ? missing diff --git a/dhall-lang/tests/import/failure/cycle.dhall b/dhall-lang/tests/import/failure/cycle.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/failure/cycle.dhall @@ -0,0 +1,1 @@ +../data/cycle.dhall diff --git a/dhall-lang/tests/import/failure/missing.dhall b/dhall-lang/tests/import/failure/missing.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/failure/missing.dhall @@ -0,0 +1,1 @@ +missing diff --git a/dhall-lang/tests/import/failure/referentiallyInsane.dhall b/dhall-lang/tests/import/failure/referentiallyInsane.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/failure/referentiallyInsane.dhall @@ -0,0 +1,13 @@ +{- The following remote import attempts to import an environment variable, which + must be disallowed by the referential sanity check + + One reason for doing this is to protect against remote imports exfiltrating + environment variables (such as via custom headers). Only referentially + opaque imports (i.e. local imports) have permission to refer to other + referentially opaque imports in order to protect against this attack. + + The referential sanity check also ensures that remote imports are + referentially transparent. Or in other words, any import that is globally + addressable must have a meaning that is not context-sensitive. +-} +https://raw.githubusercontent.com/dhall-lang/dhall-lang/master/tests/import/data/referentiallyOpaque.dhall diff --git a/dhall-lang/tests/import/success/alternativeEnvNaturalA.dhall b/dhall-lang/tests/import/success/alternativeEnvNaturalA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/success/alternativeEnvNaturalA.dhall @@ -0,0 +1,1 @@ +env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2 diff --git a/dhall-lang/tests/import/success/alternativeEnvNaturalB.dhall b/dhall-lang/tests/import/success/alternativeEnvNaturalB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/success/alternativeEnvNaturalB.dhall @@ -0,0 +1,1 @@ +2 diff --git a/dhall-lang/tests/import/success/alternativeEnvSimpleA.dhall b/dhall-lang/tests/import/success/alternativeEnvSimpleA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/success/alternativeEnvSimpleA.dhall @@ -0,0 +1,1 @@ +env:UNSET ? 3 diff --git a/dhall-lang/tests/import/success/alternativeEnvSimpleB.dhall b/dhall-lang/tests/import/success/alternativeEnvSimpleB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/success/alternativeEnvSimpleB.dhall @@ -0,0 +1,1 @@ +3 diff --git a/dhall-lang/tests/import/success/alternativeNaturalA.dhall b/dhall-lang/tests/import/success/alternativeNaturalA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/success/alternativeNaturalA.dhall @@ -0,0 +1,1 @@ +4 ? missing diff --git a/dhall-lang/tests/import/success/alternativeNaturalB.dhall b/dhall-lang/tests/import/success/alternativeNaturalB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/success/alternativeNaturalB.dhall @@ -0,0 +1,1 @@ +4 diff --git a/dhall-lang/tests/import/success/asTextA.dhall b/dhall-lang/tests/import/success/asTextA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/success/asTextA.dhall @@ -0,0 +1,1 @@ +../data/example.txt as Text diff --git a/dhall-lang/tests/import/success/asTextB.dhall b/dhall-lang/tests/import/success/asTextB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/success/asTextB.dhall @@ -0,0 +1,3 @@ +'' +Hello, world! +'' diff --git a/dhall-lang/tests/import/success/fieldOrderA.dhall b/dhall-lang/tests/import/success/fieldOrderA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/success/fieldOrderA.dhall @@ -0,0 +1,5 @@ +{ example0 = + ../data/fieldOrder/1.dhall sha256:d8ae15ff5a40ee7973a23ba75cd98f8e39d14aeb6e1e3f18aadb092fcb825194 +, example1 = + ../data/fieldOrder/2.dhall sha256:d8ae15ff5a40ee7973a23ba75cd98f8e39d14aeb6e1e3f18aadb092fcb825194 +} diff --git a/dhall-lang/tests/import/success/fieldOrderB.dhall b/dhall-lang/tests/import/success/fieldOrderB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/import/success/fieldOrderB.dhall @@ -0,0 +1,1 @@ +{ example0 = { bar = True, foo = 1 }, example1 = { bar = True, foo = 1 } } diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/access/0A.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/access/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/access/0A.dhall @@ -0,0 +1,1 @@ +{ x = "foo" }.x diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/access/0B.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/access/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/access/0B.dhall @@ -0,0 +1,1 @@ +"foo" diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/access/1A.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/access/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/access/1A.dhall @@ -0,0 +1,1 @@ +< Foo : Text | Bar : Natural >.Foo diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/access/1B.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/access/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/access/1B.dhall @@ -0,0 +1,1 @@ +λ(Foo : Text) → < Foo = Foo | Bar : Natural > diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/0A.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/0A.dhall @@ -0,0 +1,1 @@ +{ foo : { bar : Text } } ⩓ { foo : { baz : Bool }, qux : Integer } diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/0B.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/0B.dhall @@ -0,0 +1,1 @@ +{ foo : { bar : Text, baz : Bool }, qux : Integer } diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/1A.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/1A.dhall @@ -0,0 +1,1 @@ +{ foo : { bar : Text } } //\\ { foo : { baz : Bool }, qux : Integer } diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/1B.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/1B.dhall @@ -0,0 +1,1 @@ +{ foo : { bar : Text, baz : Bool }, qux : Integer } diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/prefer/0A.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/prefer/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/prefer/0A.dhall @@ -0,0 +1,1 @@ +{ foo = 1, bar = "ABC" } // { baz = True } diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/prefer/0B.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/prefer/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/prefer/0B.dhall @@ -0,0 +1,1 @@ +{ bar = "ABC", baz = True, foo = 1 } diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/projection/0A.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/projection/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/projection/0A.dhall @@ -0,0 +1,1 @@ +{ x = 1, y = True, z = "ABC" }.{ x, y } diff --git a/dhall-lang/tests/normalization/success/haskell-tutorial/projection/0B.dhall b/dhall-lang/tests/normalization/success/haskell-tutorial/projection/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/haskell-tutorial/projection/0B.dhall @@ -0,0 +1,1 @@ +{ x = 1, y = True } diff --git a/dhall-lang/tests/normalization/success/multiline/escapeA.dhall b/dhall-lang/tests/normalization/success/multiline/escapeA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/escapeA.dhall @@ -0,0 +1,9 @@ +-- Verify that an implementation is processing escape sequences correctly + +'' +''${ +''' +$ +" +\ +'' diff --git a/dhall-lang/tests/normalization/success/multiline/escapeB.dhall b/dhall-lang/tests/normalization/success/multiline/escapeB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/escapeB.dhall @@ -0,0 +1,1 @@ +"\${\n''\n\$\n\"\n\\\n" diff --git a/dhall-lang/tests/normalization/success/multiline/hangingIndentA.dhall b/dhall-lang/tests/normalization/success/multiline/hangingIndentA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/hangingIndentA.dhall @@ -0,0 +1,15 @@ +{- The indent is computed as the minimum number of leading spaces over all lines + in a multi-line literal, including the line right before the closing quotes. + In this case, there are three lines: + + * The first line containing " foo" with two leading spaces + * The second line containing " bar" with two leading spaces + * The third line containing " " with two leading spaces + + Therefore we strip two leading spaces from all three lines +-} + +'' + foo + bar + '' diff --git a/dhall-lang/tests/normalization/success/multiline/hangingIndentB.dhall b/dhall-lang/tests/normalization/success/multiline/hangingIndentB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/hangingIndentB.dhall @@ -0,0 +1,1 @@ +"foo\nbar\n" diff --git a/dhall-lang/tests/normalization/success/multiline/interestingA.dhall b/dhall-lang/tests/normalization/success/multiline/interestingA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/interestingA.dhall @@ -0,0 +1,7 @@ +-- Non-trivial example that combines several multi-line literal features + +λ(x : Text) → '' + ${x} baz + bar + foo + '' diff --git a/dhall-lang/tests/normalization/success/multiline/interestingB.dhall b/dhall-lang/tests/normalization/success/multiline/interestingB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/interestingB.dhall @@ -0,0 +1,1 @@ +λ(x : Text) → "${x} baz\n bar\n foo\n " diff --git a/dhall-lang/tests/normalization/success/multiline/interiorIndentA.dhall b/dhall-lang/tests/normalization/success/multiline/interiorIndentA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/interiorIndentA.dhall @@ -0,0 +1,16 @@ +{- The indent is computed as the minimum number of leading spaces over all lines + in a multi-line literal, including the line right before the closing quotes. + In this case, there are three lines: + + * The first line containing " foo" with two leading spaces + * The second line containing " bar" with two leading spaces + * The third line containing "" with zero leading spaces + + Since the last line has zero leading spaces, the minimum number of leading + spaces over all three lines is zero, so we don't strip any spaces. +-} + +'' + foo + bar +'' diff --git a/dhall-lang/tests/normalization/success/multiline/interiorIndentB.dhall b/dhall-lang/tests/normalization/success/multiline/interiorIndentB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/interiorIndentB.dhall @@ -0,0 +1,1 @@ +" foo\n bar\n" diff --git a/dhall-lang/tests/normalization/success/multiline/interpolationA.dhall b/dhall-lang/tests/normalization/success/multiline/interpolationA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/interpolationA.dhall @@ -0,0 +1,9 @@ +{- This example verifies that an implementation is correctly breaking leading + spaces at interpolated expressions. The first line has the fewest number of + leading spaces (2) due to the interruption by the interpolated expression. +-} + +'' +${Natural/show 1} foo + bar +'' diff --git a/dhall-lang/tests/normalization/success/multiline/interpolationB.dhall b/dhall-lang/tests/normalization/success/multiline/interpolationB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/interpolationB.dhall @@ -0,0 +1,1 @@ +"${Natural/show 1} foo\n bar\n" diff --git a/dhall-lang/tests/normalization/success/multiline/preserveCommentA.dhall b/dhall-lang/tests/normalization/success/multiline/preserveCommentA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/preserveCommentA.dhall @@ -0,0 +1,8 @@ +{- A comment within the interior of a multi-line literal counts as part of the + literal +-} + +'' +-- Hello +{- world -} +'' diff --git a/dhall-lang/tests/normalization/success/multiline/preserveCommentB.dhall b/dhall-lang/tests/normalization/success/multiline/preserveCommentB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/preserveCommentB.dhall @@ -0,0 +1,1 @@ +"-- Hello\n{- world -}\n" diff --git a/dhall-lang/tests/normalization/success/multiline/singleLineA.dhall b/dhall-lang/tests/normalization/success/multiline/singleLineA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/singleLineA.dhall @@ -0,0 +1,6 @@ +{- This is how you encode a multi-line literal that contains no newlines + + The leading newline is stripped +-} +'' +foo'' diff --git a/dhall-lang/tests/normalization/success/multiline/singleLineB.dhall b/dhall-lang/tests/normalization/success/multiline/singleLineB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/singleLineB.dhall @@ -0,0 +1,1 @@ +"foo" diff --git a/dhall-lang/tests/normalization/success/multiline/twoLinesA.dhall b/dhall-lang/tests/normalization/success/multiline/twoLinesA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/twoLinesA.dhall @@ -0,0 +1,7 @@ +{- Verify that an implementation is correctly preserving newlines in the + corresponding double-quoted literal +-} + +'' +foo +bar'' diff --git a/dhall-lang/tests/normalization/success/multiline/twoLinesB.dhall b/dhall-lang/tests/normalization/success/multiline/twoLinesB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/multiline/twoLinesB.dhall @@ -0,0 +1,1 @@ +"foo\nbar" diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/and/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/and/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/and/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.and [ True, False, True ] diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/and/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/and/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/and/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/and/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/and/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/and/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.and ([] : List Bool) diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/and/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/and/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/and/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/build/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/build/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Bool/build/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/build/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/build/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/build/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/build/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Bool/build/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/build/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/build/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/even/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/even/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/even/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.even [ False, True, False ] diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/even/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/even/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/even/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/even/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/even/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/even/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.even [ False, True ] diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/even/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/even/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/even/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/even/2A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/even/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/even/2A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.even [ False ] diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/even/2B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/even/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/even/2B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/even/3A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/even/3A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/even/3A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.even ([] : List Bool) diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/even/3B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/even/3B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/even/3B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/fold/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/fold/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.fold True Natural 0 1 diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/fold/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/fold/0B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/fold/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/fold/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.fold False Natural 0 1 diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/fold/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/fold/1B.dhall @@ -0,0 +1,1 @@ +1 diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/not/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/not/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/not/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.not True diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/not/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/not/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/not/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/not/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/not/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/not/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.not False diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/not/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/not/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/not/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/odd/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/odd/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/odd/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.odd [ True, False, True ] diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/odd/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/odd/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/odd/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/odd/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/odd/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/odd/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.odd [ True, False ] diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/odd/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/odd/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/odd/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/odd/2A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/odd/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/odd/2A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.odd [ True ] diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/odd/2B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/odd/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/odd/2B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/odd/3A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/odd/3A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/odd/3A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.odd ([] : List Bool) diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/odd/3B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/odd/3B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/odd/3B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/or/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/or/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/or/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.or [ True, False, True ] diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/or/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/or/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/or/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/or/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/or/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/or/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.or ([] : List Bool) diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/or/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/or/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/or/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/show/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/show/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/show/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.show True diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/show/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/show/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/show/0B.dhall @@ -0,0 +1,1 @@ +"True" diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/show/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/show/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/show/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Bool`.show False diff --git a/dhall-lang/tests/normalization/success/prelude/Bool/show/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Bool/show/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Bool/show/1B.dhall @@ -0,0 +1,1 @@ +"False" diff --git a/dhall-lang/tests/normalization/success/prelude/Double/show/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Double/show/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Double/show/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Double`.show -3.1 diff --git a/dhall-lang/tests/normalization/success/prelude/Double/show/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Double/show/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Double/show/0B.dhall @@ -0,0 +1,1 @@ +"-3.1" diff --git a/dhall-lang/tests/normalization/success/prelude/Double/show/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Double/show/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Double/show/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Double`.show 0.4 diff --git a/dhall-lang/tests/normalization/success/prelude/Double/show/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Double/show/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Double/show/1B.dhall @@ -0,0 +1,1 @@ +"0.4" diff --git a/dhall-lang/tests/normalization/success/prelude/Integer/show/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Integer/show/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Integer/show/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Integer`.show -3 diff --git a/dhall-lang/tests/normalization/success/prelude/Integer/show/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Integer/show/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Integer/show/0B.dhall @@ -0,0 +1,1 @@ +"-3" diff --git a/dhall-lang/tests/normalization/success/prelude/Integer/show/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Integer/show/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Integer/show/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Integer`.show +0 diff --git a/dhall-lang/tests/normalization/success/prelude/Integer/show/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Integer/show/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Integer/show/1B.dhall @@ -0,0 +1,1 @@ +"+0" diff --git a/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Integer`.toDouble -3 diff --git a/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/0B.dhall @@ -0,0 +1,1 @@ +-3.0 diff --git a/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Integer`.toDouble +2 diff --git a/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Integer/toDouble/1B.dhall @@ -0,0 +1,1 @@ +2.0 diff --git a/dhall-lang/tests/normalization/success/prelude/List/all/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/all/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/all/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/all/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/all/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/List/all/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/all/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/all/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/all/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/all/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/List/any/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/any/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/any/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/any/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/any/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/List/any/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/any/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/any/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/any/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/any/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/List/build/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/build/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/build/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/build/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/build/0B.dhall @@ -0,0 +1,1 @@ +[ "ABC", "DEF" ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/build/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/build/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/build/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/build/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/build/1B.dhall @@ -0,0 +1,1 @@ +[] : List Text diff --git a/dhall-lang/tests/normalization/success/prelude/List/concat/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/concat/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/concat/0B.dhall @@ -0,0 +1,1 @@ +[ 0, 1, 2, 3, 4, 5, 6, 7, 8 ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/concat/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/concat/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/concat/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/dhall-lang/tests/normalization/success/prelude/List/concatMap/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/concatMap/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/concatMap/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/concatMap/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/concatMap/0B.dhall @@ -0,0 +1,1 @@ +[ 2, 2, 3, 3, 5, 5 ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/concatMap/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/concatMap/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/concatMap/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/concatMap/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/concatMap/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/dhall-lang/tests/normalization/success/prelude/List/filter/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/filter/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/filter/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/filter/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/filter/0B.dhall @@ -0,0 +1,1 @@ +[ 2 ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/filter/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/filter/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/filter/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/filter/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/filter/1B.dhall @@ -0,0 +1,1 @@ +[ 3, 5 ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/fold/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/fold/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/fold/0B.dhall @@ -0,0 +1,1 @@ +10 diff --git a/dhall-lang/tests/normalization/success/prelude/List/fold/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/fold/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/fold/1B.dhall @@ -0,0 +1,1 @@ +λ(nil : Natural) → 2 + (3 + (5 + nil)) diff --git a/dhall-lang/tests/normalization/success/prelude/List/fold/2A.dhall b/dhall-lang/tests/normalization/success/prelude/List/fold/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/fold/2B.dhall b/dhall-lang/tests/normalization/success/prelude/List/fold/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/generate/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/generate/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/generate/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.generate 5 Bool Natural/even diff --git a/dhall-lang/tests/normalization/success/prelude/List/generate/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/generate/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/generate/0B.dhall @@ -0,0 +1,1 @@ +[ True, False, True, False, True ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/generate/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/generate/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/generate/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.generate 0 Bool Natural/even diff --git a/dhall-lang/tests/normalization/success/prelude/List/generate/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/generate/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/generate/1B.dhall @@ -0,0 +1,1 @@ +[] : List Bool diff --git a/dhall-lang/tests/normalization/success/prelude/List/head/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/head/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/head/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.head Natural [ 0, 1, 2 ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/head/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/head/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/head/0B.dhall @@ -0,0 +1,1 @@ +Some 0 diff --git a/dhall-lang/tests/normalization/success/prelude/List/head/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/head/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/head/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.head Natural ([] : List Natural) diff --git a/dhall-lang/tests/normalization/success/prelude/List/head/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/head/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/head/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/dhall-lang/tests/normalization/success/prelude/List/indexed/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/indexed/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/indexed/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.indexed Bool [ True, False, True ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/indexed/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/indexed/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/indexed/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/indexed/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/indexed/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.indexed Bool ([] : List Bool) diff --git a/dhall-lang/tests/normalization/success/prelude/List/indexed/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/indexed/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/indexed/1B.dhall @@ -0,0 +1,1 @@ +[] : List { index : Natural, value : Bool } diff --git a/dhall-lang/tests/normalization/success/prelude/List/iterate/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/iterate/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/iterate/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/iterate/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/iterate/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/iterate/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/iterate/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/iterate/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/iterate/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/dhall-lang/tests/normalization/success/prelude/List/last/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/last/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/last/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.last Natural [ 0, 1, 2 ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/last/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/last/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/last/0B.dhall @@ -0,0 +1,1 @@ +Some 2 diff --git a/dhall-lang/tests/normalization/success/prelude/List/last/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/last/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/last/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.last Natural ([] : List Natural) diff --git a/dhall-lang/tests/normalization/success/prelude/List/last/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/last/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/last/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/dhall-lang/tests/normalization/success/prelude/List/length/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/length/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/length/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.length Natural [ 0, 1, 2 ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/length/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/length/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/length/0B.dhall @@ -0,0 +1,1 @@ +3 diff --git a/dhall-lang/tests/normalization/success/prelude/List/length/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/length/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/length/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.length Natural ([] : List Natural) diff --git a/dhall-lang/tests/normalization/success/prelude/List/length/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/length/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/length/1B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/dhall-lang/tests/normalization/success/prelude/List/map/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/map/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/map/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/map/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/map/0B.dhall @@ -0,0 +1,1 @@ +[ True, False, False ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/map/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/map/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/map/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/map/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/map/1B.dhall @@ -0,0 +1,1 @@ +[] : List Bool diff --git a/dhall-lang/tests/normalization/success/prelude/List/null/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/null/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/null/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.null Natural [ 0, 1, 2 ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/null/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/null/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/null/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/List/null/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/null/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/null/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.null Natural ([] : List Natural) diff --git a/dhall-lang/tests/normalization/success/prelude/List/null/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/null/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/null/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/List/replicate/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/replicate/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/replicate/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.replicate 9 Natural 1 diff --git a/dhall-lang/tests/normalization/success/prelude/List/replicate/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/replicate/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/replicate/0B.dhall @@ -0,0 +1,1 @@ +[ 1, 1, 1, 1, 1, 1, 1, 1, 1 ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/replicate/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/replicate/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/replicate/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.replicate 0 Natural 1 diff --git a/dhall-lang/tests/normalization/success/prelude/List/replicate/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/replicate/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/replicate/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/dhall-lang/tests/normalization/success/prelude/List/reverse/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/reverse/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/reverse/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.reverse Natural [ 0, 1, 2 ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/reverse/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/reverse/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/reverse/0B.dhall @@ -0,0 +1,1 @@ +[ 2, 1, 0 ] diff --git a/dhall-lang/tests/normalization/success/prelude/List/reverse/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/reverse/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/reverse/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`List`.reverse Natural ([] : List Natural) diff --git a/dhall-lang/tests/normalization/success/prelude/List/reverse/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/reverse/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/reverse/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/dhall-lang/tests/normalization/success/prelude/List/shifted/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/shifted/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/shifted/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/shifted/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/shifted/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/shifted/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/shifted/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/shifted/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/shifted/1B.dhall @@ -0,0 +1,1 @@ +[] : List { index : Natural, value : Bool } diff --git a/dhall-lang/tests/normalization/success/prelude/List/unzip/0A.dhall b/dhall-lang/tests/normalization/success/prelude/List/unzip/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/unzip/0B.dhall b/dhall-lang/tests/normalization/success/prelude/List/unzip/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/unzip/0B.dhall @@ -0,0 +1,1 @@ +{ _1 = [ "ABC", "DEF", "GHI" ], _2 = [ True, False, True ] } diff --git a/dhall-lang/tests/normalization/success/prelude/List/unzip/1A.dhall b/dhall-lang/tests/normalization/success/prelude/List/unzip/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/List/unzip/1B.dhall b/dhall-lang/tests/normalization/success/prelude/List/unzip/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/List/unzip/1B.dhall @@ -0,0 +1,1 @@ +{ _1 = [] : List Text, _2 = [] : List Bool } diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/build/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/build/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Natural/build/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/build/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/build/0B.dhall @@ -0,0 +1,1 @@ +3 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/build/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/build/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Natural/build/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/build/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/build/1B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/enumerate/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/enumerate/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/enumerate/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.enumerate 10 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/enumerate/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/enumerate/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Natural/enumerate/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/enumerate/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/enumerate/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.enumerate 0 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/enumerate/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/enumerate/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/enumerate/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/even/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/even/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/even/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.even 3 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/even/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/even/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/even/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/even/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/even/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/even/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.even 0 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/even/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/even/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/even/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/fold/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Natural/fold/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/fold/0B.dhall @@ -0,0 +1,1 @@ +125 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/fold/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Natural/fold/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/fold/1B.dhall @@ -0,0 +1,1 @@ +λ(zero : Natural) → 5 * (5 * (5 * zero)) diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/fold/2A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/fold/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Natural/fold/2B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/fold/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Natural/isZero/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/isZero/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/isZero/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.isZero 2 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/isZero/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/isZero/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/isZero/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/isZero/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/isZero/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/isZero/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.isZero 0 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/isZero/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/isZero/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/isZero/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/odd/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/odd/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/odd/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.odd 3 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/odd/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/odd/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/odd/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/odd/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/odd/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/odd/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.odd 0 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/odd/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/odd/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/odd/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/product/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/product/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/product/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.product [ 2, 3, 5 ] diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/product/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/product/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/product/0B.dhall @@ -0,0 +1,1 @@ +30 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/product/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/product/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/product/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.product ([] : List Natural) diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/product/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/product/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/product/1B.dhall @@ -0,0 +1,1 @@ +1 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/show/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/show/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/show/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.show 3 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/show/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/show/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/show/0B.dhall @@ -0,0 +1,1 @@ +"3" diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/show/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/show/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/show/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.show 0 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/show/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/show/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/show/1B.dhall @@ -0,0 +1,1 @@ +"0" diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/sum/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/sum/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/sum/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.sum [ 2, 3, 5 ] diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/sum/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/sum/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/sum/0B.dhall @@ -0,0 +1,1 @@ +10 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/sum/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/sum/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/sum/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.sum ([] : List Natural) diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/sum/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/sum/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/sum/1B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.toDouble 3 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/0B.dhall @@ -0,0 +1,1 @@ +3.0 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.toDouble 0 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/toDouble/1B.dhall @@ -0,0 +1,1 @@ +0.0 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.toInteger 3 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/0B.dhall @@ -0,0 +1,1 @@ ++3 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Natural`.toInteger 0 diff --git a/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Natural/toInteger/1B.dhall @@ -0,0 +1,1 @@ ++0 diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/all/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/all/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/all/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/all/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/all/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/all/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/all/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/all/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/all/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/all/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/any/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/any/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/any/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/any/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/any/0B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/any/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/any/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/any/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/any/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/any/1B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/build/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/build/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/build/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/build/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/build/0B.dhall @@ -0,0 +1,1 @@ +Some 1 diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/build/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/build/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/build/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/build/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/build/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/concat/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/concat/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (Some 1)) diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/concat/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/concat/0B.dhall @@ -0,0 +1,1 @@ +Some 1 diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/concat/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/concat/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (None Natural)) diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/concat/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/concat/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/concat/2A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/concat/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/concat/2A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (None (Optional Natural)) diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/concat/2B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/concat/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/concat/2B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/filter/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/filter/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/filter/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/filter/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/filter/0B.dhall @@ -0,0 +1,1 @@ +Some 2 diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/filter/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/filter/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/filter/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/filter/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/filter/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/fold/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/fold/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/fold/0B.dhall @@ -0,0 +1,1 @@ +2 diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/fold/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/fold/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/fold/1B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/head/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/head/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/head/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/head/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/head/0B.dhall @@ -0,0 +1,1 @@ +Some 1 diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/head/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/head/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/head/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/head/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/head/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/head/2A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/head/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/head/2A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.head Natural ([] : List (Optional Natural)) diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/head/2B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/head/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/head/2B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/last/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/last/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/last/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/last/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/last/0B.dhall @@ -0,0 +1,1 @@ +Some 2 diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/last/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/last/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/last/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/last/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/last/1B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/last/2A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/last/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/last/2A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.last Natural ([] : List (Optional Natural)) diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/last/2B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/last/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/last/2B.dhall @@ -0,0 +1,1 @@ +None Natural diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/length/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/length/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/length/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.length Natural (Some 2) diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/length/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/length/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/length/0B.dhall @@ -0,0 +1,1 @@ +1 diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/length/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/length/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/length/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.length Natural (None Natural) diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/length/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/length/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/length/1B.dhall @@ -0,0 +1,1 @@ +0 diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/map/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/map/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/map/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/map/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/map/0B.dhall @@ -0,0 +1,1 @@ +Some False diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/map/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/map/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/map/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/map/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/map/1B.dhall @@ -0,0 +1,1 @@ +None Bool diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/null/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/null/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/null/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.null Natural (Some 2) diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/null/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/null/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/null/0B.dhall @@ -0,0 +1,1 @@ +False diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/null/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/null/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/null/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.null Natural (None Natural) diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/null/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/null/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/null/1B.dhall @@ -0,0 +1,1 @@ +True diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/toList/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/toList/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/toList/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.toList Natural (Some 1) diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/toList/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/toList/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/toList/0B.dhall @@ -0,0 +1,1 @@ +[ 1 ] : List Natural diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/toList/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/toList/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/toList/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Optional`.toList Natural (None Natural) diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/toList/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/toList/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/toList/1B.dhall @@ -0,0 +1,1 @@ +[] : List Natural diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/unzip/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/unzip/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/unzip/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/unzip/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/unzip/0B.dhall @@ -0,0 +1,1 @@ +{ _1 = Some "ABC", _2 = Some True } diff --git a/dhall-lang/tests/normalization/success/prelude/Optional/unzip/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/unzip/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Optional/unzip/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Optional/unzip/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Optional/unzip/1B.dhall @@ -0,0 +1,1 @@ +{ _1 = None Text, _2 = None Bool } diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concat/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concat/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concat [ "ABC", "DEF", "GHI" ] diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concat/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concat/0B.dhall @@ -0,0 +1,1 @@ +"ABCDEFGHI" diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concat/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concat/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concat ([] : List Text) diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concat/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concat/1B.dhall @@ -0,0 +1,1 @@ +"" diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concatMap/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatMap/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Text/concatMap/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatMap/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concatMap/0B.dhall @@ -0,0 +1,1 @@ +"0 1 2 " diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concatMap/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatMap/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Text/concatMap/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatMap/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concatMap/1B.dhall @@ -0,0 +1,1 @@ +"" diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/0B.dhall @@ -0,0 +1,1 @@ +"0, 1, 2" diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/1B.dhall @@ -0,0 +1,1 @@ +"" diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concatSep/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatSep/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concatSep/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concatSep ", " [ "ABC", "DEF", "GHI" ] diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concatSep/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatSep/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concatSep/0B.dhall @@ -0,0 +1,1 @@ +"ABC, DEF, GHI" diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concatSep/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatSep/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concatSep/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.concatSep ", " ([] : List Text) diff --git a/dhall-lang/tests/normalization/success/prelude/Text/concatSep/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Text/concatSep/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/concatSep/1B.dhall @@ -0,0 +1,1 @@ +"" diff --git a/dhall-lang/tests/normalization/success/prelude/Text/show/0A.dhall b/dhall-lang/tests/normalization/success/prelude/Text/show/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/show/0A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.show "ABC" diff --git a/dhall-lang/tests/normalization/success/prelude/Text/show/0B.dhall b/dhall-lang/tests/normalization/success/prelude/Text/show/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/show/0B.dhall @@ -0,0 +1,1 @@ +"\"ABC\"" diff --git a/dhall-lang/tests/normalization/success/prelude/Text/show/1A.dhall b/dhall-lang/tests/normalization/success/prelude/Text/show/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/show/1A.dhall @@ -0,0 +1,1 @@ +(../../../../../../Prelude/package.dhall).`Text`.show "\u0000 \$ \\ \n \u263a" diff --git a/dhall-lang/tests/normalization/success/prelude/Text/show/1B.dhall b/dhall-lang/tests/normalization/success/prelude/Text/show/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/prelude/Text/show/1B.dhall @@ -0,0 +1,1 @@ +"\"\\u0000 \\u0024 \\\\ \\n ☺\"" diff --git a/dhall-lang/tests/normalization/success/remoteSystemsA.dhall b/dhall-lang/tests/normalization/success/remoteSystemsA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/remoteSystemsB.dhall b/dhall-lang/tests/normalization/success/remoteSystemsB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/remoteSystemsB.dhall @@ -0,0 +1,212 @@ + λ ( _ + : 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 + } + _ + Text + ( λ ( _ + : { cores : + Natural + , host : + Text + , key : + Text + , mandatoryFeatures : + List Text + , platforms : + List Text + , speedFactor : + Natural + , supportedFeatures : + List Text + , user : + Optional Text + } + ) + → λ(_ : Text) + → '' + ${Optional/fold + Text + _@1.user + Text + (λ(user : Text) → "${user}@${_@1.host}") + _@1.host} ${merge + { Empty = λ(_ : {}) → "", NonEmpty = λ(_ : Text) → _ } + ( List/fold + Text + _@1.platforms + < Empty : {} | NonEmpty : Text > + ( λ(_ : Text) + → λ(_ : < Empty : {} | NonEmpty : Text >) + → merge + { Empty = + λ(_ : {}) → < NonEmpty = _@2 | Empty : {} > + , NonEmpty = + λ(_ : Text) + → < NonEmpty = _@2 ++ "," ++ _ | Empty : {} > + } + _ + : < Empty : {} | NonEmpty : Text > + ) + < Empty = {=} | NonEmpty : Text > + ) + : Text} ${_@1.key} ${Integer/show + ( Natural/toInteger _@1.cores + )} ${Integer/show + ( Natural/toInteger + _@1.speedFactor + )} ${merge + { Empty = + λ(_ : {}) → "" + , NonEmpty = + λ(_ : Text) → _ + } + ( List/fold + Text + _@1.supportedFeatures + < Empty : + {} + | NonEmpty : + Text + > + ( λ(_ : Text) + → λ ( _ + : < Empty : + {} + | NonEmpty : + Text + > + ) + → merge + { Empty = + λ(_ : {}) + → < NonEmpty = + _@2 + | Empty : + {} + > + , NonEmpty = + λ(_ : Text) + → < NonEmpty = + _@2 + ++ "," + ++ _ + | Empty : + {} + > + } + _ + : < Empty : + {} + | NonEmpty : + Text + > + ) + < Empty = + {=} + | NonEmpty : + Text + > + ) + : Text} ${merge + { Empty = + λ(_ : {}) + → "" + , NonEmpty = + λ ( _ + : Text + ) + → _ + } + ( List/fold + Text + _@1.mandatoryFeatures + < Empty : + {} + | NonEmpty : + Text + > + ( λ ( _ + : Text + ) + → λ ( _ + : < Empty : + {} + | NonEmpty : + Text + > + ) + → merge + { Empty = + λ ( _ + : {} + ) + → < NonEmpty = + _@2 + | Empty : + {} + > + , NonEmpty = + λ ( _ + : Text + ) + → < NonEmpty = + _@2 + ++ "," + ++ _ + | Empty : + {} + > + } + _ + : < Empty : + {} + | NonEmpty : + Text + > + ) + < Empty = + {=} + | NonEmpty : + Text + > + ) + : Text} + '' + ++ _ + ) + "" diff --git a/dhall-lang/tests/normalization/success/simple/doubleShowA.dhall b/dhall-lang/tests/normalization/success/simple/doubleShowA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/doubleShowA.dhall @@ -0,0 +1,6 @@ +{ example0 = Double/show -0.42 +, example1 = Double/show 13.37 +, example2 = Double/show NaN +, example3 = Double/show Infinity +, example4 = Double/show -Infinity +} diff --git a/dhall-lang/tests/normalization/success/simple/doubleShowB.dhall b/dhall-lang/tests/normalization/success/simple/doubleShowB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/doubleShowB.dhall @@ -0,0 +1,6 @@ +{ example0 = "-0.42" +, example1 = "13.37" +, example2 = "NaN" +, example3 = "Infinity" +, example4 = "-Infinity" +} diff --git a/dhall-lang/tests/normalization/success/simple/integerShowA.dhall b/dhall-lang/tests/normalization/success/simple/integerShowA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simple/integerShowB.dhall b/dhall-lang/tests/normalization/success/simple/integerShowB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/integerShowB.dhall @@ -0,0 +1,1 @@ +{ example0 = "+1337", example1 = "-42", example2 = "+0" } diff --git a/dhall-lang/tests/normalization/success/simple/integerToDoubleA.dhall b/dhall-lang/tests/normalization/success/simple/integerToDoubleA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simple/integerToDoubleB.dhall b/dhall-lang/tests/normalization/success/simple/integerToDoubleB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simple/letletA.dhall b/dhall-lang/tests/normalization/success/simple/letletA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simple/letletB.dhall b/dhall-lang/tests/normalization/success/simple/letletB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/letletB.dhall @@ -0,0 +1,1 @@ +1337 diff --git a/dhall-lang/tests/normalization/success/simple/listBuildA.dhall b/dhall-lang/tests/normalization/success/simple/listBuildA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simple/listBuildB.dhall b/dhall-lang/tests/normalization/success/simple/listBuildB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simple/multiLineA.dhall b/dhall-lang/tests/normalization/success/simple/multiLineA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/multiLineA.dhall @@ -0,0 +1,4 @@ +'' + foo +bar +'' diff --git a/dhall-lang/tests/normalization/success/simple/multiLineB.dhall b/dhall-lang/tests/normalization/success/simple/multiLineB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/multiLineB.dhall @@ -0,0 +1,4 @@ +'' + foo +bar +'' diff --git a/dhall-lang/tests/normalization/success/simple/naturalBuildA.dhall b/dhall-lang/tests/normalization/success/simple/naturalBuildA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simple/naturalBuildB.dhall b/dhall-lang/tests/normalization/success/simple/naturalBuildB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simple/naturalPlusA.dhall b/dhall-lang/tests/normalization/success/simple/naturalPlusA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/naturalPlusA.dhall @@ -0,0 +1,1 @@ +1 + 2 diff --git a/dhall-lang/tests/normalization/success/simple/naturalPlusB.dhall b/dhall-lang/tests/normalization/success/simple/naturalPlusB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/naturalPlusB.dhall @@ -0,0 +1,1 @@ +3 diff --git a/dhall-lang/tests/normalization/success/simple/naturalShowA.dhall b/dhall-lang/tests/normalization/success/simple/naturalShowA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/naturalShowA.dhall @@ -0,0 +1,1 @@ +Natural/show 42 diff --git a/dhall-lang/tests/normalization/success/simple/naturalShowB.dhall b/dhall-lang/tests/normalization/success/simple/naturalShowB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/naturalShowB.dhall @@ -0,0 +1,1 @@ +"42" diff --git a/dhall-lang/tests/normalization/success/simple/naturalToIntegerA.dhall b/dhall-lang/tests/normalization/success/simple/naturalToIntegerA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/naturalToIntegerA.dhall @@ -0,0 +1,1 @@ +Natural/toInteger 1 diff --git a/dhall-lang/tests/normalization/success/simple/naturalToIntegerB.dhall b/dhall-lang/tests/normalization/success/simple/naturalToIntegerB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/naturalToIntegerB.dhall @@ -0,0 +1,1 @@ ++1 diff --git a/dhall-lang/tests/normalization/success/simple/optionalBuildA.dhall b/dhall-lang/tests/normalization/success/simple/optionalBuildA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simple/optionalBuildB.dhall b/dhall-lang/tests/normalization/success/simple/optionalBuildB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simple/optionalBuildFoldA.dhall b/dhall-lang/tests/normalization/success/simple/optionalBuildFoldA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/optionalBuildFoldA.dhall @@ -0,0 +1,1 @@ +Optional/build Text (Optional/fold Text ([ "foo" ] : Optional Text)) diff --git a/dhall-lang/tests/normalization/success/simple/optionalBuildFoldB.dhall b/dhall-lang/tests/normalization/success/simple/optionalBuildFoldB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/optionalBuildFoldB.dhall @@ -0,0 +1,1 @@ +[ "foo" ] : Optional Text diff --git a/dhall-lang/tests/normalization/success/simple/optionalFoldA.dhall b/dhall-lang/tests/normalization/success/simple/optionalFoldA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simple/optionalFoldB.dhall b/dhall-lang/tests/normalization/success/simple/optionalFoldB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/optionalFoldB.dhall @@ -0,0 +1,1 @@ +{ example0 = 1, example1 = 2 } diff --git a/dhall-lang/tests/normalization/success/simple/sortOperatorA.dhall b/dhall-lang/tests/normalization/success/simple/sortOperatorA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/sortOperatorA.dhall @@ -0,0 +1,1 @@ +{ b = 2 } // { a = 1 } diff --git a/dhall-lang/tests/normalization/success/simple/sortOperatorB.dhall b/dhall-lang/tests/normalization/success/simple/sortOperatorB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simple/sortOperatorB.dhall @@ -0,0 +1,1 @@ +{ a = 1, b = 2 } diff --git a/dhall-lang/tests/normalization/success/simplifications/andA.dhall b/dhall-lang/tests/normalization/success/simplifications/andA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simplifications/andB.dhall b/dhall-lang/tests/normalization/success/simplifications/andB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simplifications/eqA.dhall b/dhall-lang/tests/normalization/success/simplifications/eqA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simplifications/eqB.dhall b/dhall-lang/tests/normalization/success/simplifications/eqB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simplifications/ifThenElseA.dhall b/dhall-lang/tests/normalization/success/simplifications/ifThenElseA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simplifications/ifThenElseB.dhall b/dhall-lang/tests/normalization/success/simplifications/ifThenElseB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/normalization/success/simplifications/ifThenElseB.dhall @@ -0,0 +1,3 @@ +{ example0 = λ(x : Bool) → x +, example1 = λ(x : Bool) → λ(y : Text) → y +} diff --git a/dhall-lang/tests/normalization/success/simplifications/neA.dhall b/dhall-lang/tests/normalization/success/simplifications/neA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simplifications/neB.dhall b/dhall-lang/tests/normalization/success/simplifications/neB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simplifications/orA.dhall b/dhall-lang/tests/normalization/success/simplifications/orA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/normalization/success/simplifications/orB.dhall b/dhall-lang/tests/normalization/success/simplifications/orB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/parser/failure/annotation.dhall b/dhall-lang/tests/parser/failure/annotation.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/failure/annotation.dhall @@ -0,0 +1,1 @@ +let a:Natural = 1 in a diff --git a/dhall-lang/tests/parser/failure/doubleBoundsNeg.dhall b/dhall-lang/tests/parser/failure/doubleBoundsNeg.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/failure/doubleBoundsNeg.dhall @@ -0,0 +1,1 @@ +-179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0 diff --git a/dhall-lang/tests/parser/failure/doubleBoundsPos.dhall b/dhall-lang/tests/parser/failure/doubleBoundsPos.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/failure/doubleBoundsPos.dhall @@ -0,0 +1,1 @@ +179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0 diff --git a/dhall-lang/tests/parser/failure/importAccess.dhall b/dhall-lang/tests/parser/failure/importAccess.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/failure/importAccess.dhall @@ -0,0 +1,1 @@ +./testImport .hello diff --git a/dhall-lang/tests/parser/failure/incompleteIf.dhall b/dhall-lang/tests/parser/failure/incompleteIf.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/failure/incompleteIf.dhall @@ -0,0 +1,10 @@ +-- This test verifies that an implementation rejects the following expression at +-- parse time (i.e. due to an incomplete `if` expression) rather than at +-- type-checking time (i.e. due to an unbound variable named `if` or `else`) +-- +-- This ensures that implementations are not treating keywords as potential +-- identifier names. In other words, if they fail to parse an incomplete +-- `if` expression they don't try to alternatively parse the expression as +-- function application instead. + +if a then b else diff --git a/dhall-lang/tests/parser/failure/mandatoryNewline.dhall b/dhall-lang/tests/parser/failure/mandatoryNewline.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/failure/mandatoryNewline.dhall @@ -0,0 +1,2 @@ +-- Multi-line literals require a mandatory newline after the opening quotes +''ABC'' diff --git a/dhall-lang/tests/parser/failure/missingSpace.dhall b/dhall-lang/tests/parser/failure/missingSpace.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/failure/missingSpace.dhall @@ -0,0 +1,2 @@ +-- There needs to be a space between a function and its argument +./example.dhall[1] diff --git a/dhall-lang/tests/parser/failure/spaceAfterListAppend.dhall b/dhall-lang/tests/parser/failure/spaceAfterListAppend.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/failure/spaceAfterListAppend.dhall @@ -0,0 +1,2 @@ +-- Some operators require a space after them +[ 1 ]#[ 2 ] diff --git a/dhall-lang/tests/parser/success/annotationsA.dhall b/dhall-lang/tests/parser/success/annotationsA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/annotationsA.dhall @@ -0,0 +1,4 @@ +{ foo = ([] : List Natural) # [1, 2, 3] # ([1, 2, 3] : List Natural) +, bar = [] : Optional Natural +, baz = [1] : Optional Natural +} : { foo : List Natural, bar : Optional Natural, baz : Optional Natural } diff --git a/dhall-lang/tests/parser/success/annotationsB.dhallb b/dhall-lang/tests/parser/success/annotationsB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/annotationsB.dhallb differ diff --git a/dhall-lang/tests/parser/success/asTextA.dhall b/dhall-lang/tests/parser/success/asTextA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/asTextA.dhall @@ -0,0 +1,1 @@ +https://example.com/foo as Text diff --git a/dhall-lang/tests/parser/success/asTextB.dhallb b/dhall-lang/tests/parser/success/asTextB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/asTextB.dhallb @@ -0,0 +1,1 @@ +‰öökexample.comcfooöö diff --git a/dhall-lang/tests/parser/success/blockCommentA.dhall b/dhall-lang/tests/parser/success/blockCommentA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/blockCommentA.dhall @@ -0,0 +1,3 @@ +{- foo -} + +1 diff --git a/dhall-lang/tests/parser/success/blockCommentB.dhallb b/dhall-lang/tests/parser/success/blockCommentB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/blockCommentB.dhallb @@ -0,0 +1,1 @@ +‚ diff --git a/dhall-lang/tests/parser/success/builtinsA.dhall b/dhall-lang/tests/parser/success/builtinsA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/parser/success/builtinsB.dhallb b/dhall-lang/tests/parser/success/builtinsB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/builtinsB.dhallb differ diff --git a/dhall-lang/tests/parser/success/collectionImportTypeA.dhall b/dhall-lang/tests/parser/success/collectionImportTypeA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/collectionImportTypeA.dhall @@ -0,0 +1,3 @@ +{ example0 = [] : Optional ./type.dhall +, example1 = [] : List ./type.dhall +} diff --git a/dhall-lang/tests/parser/success/collectionImportTypeB.dhallb b/dhall-lang/tests/parser/success/collectionImportTypeB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/collectionImportTypeB.dhallb differ diff --git a/dhall-lang/tests/parser/success/doubleA.dhall b/dhall-lang/tests/parser/success/doubleA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/doubleA.dhall @@ -0,0 +1,1 @@ +[ 1.1, -1.1, 1e1, 1.1e1, NaN, Infinity, -Infinity, 0.0 ] diff --git a/dhall-lang/tests/parser/success/doubleB.dhallb b/dhall-lang/tests/parser/success/doubleB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/doubleB.dhallb differ diff --git a/dhall-lang/tests/parser/success/doubleQuotedStringA.dhall b/dhall-lang/tests/parser/success/doubleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/doubleQuotedStringA.dhall @@ -0,0 +1,1 @@ +"ABC" diff --git a/dhall-lang/tests/parser/success/doubleQuotedStringB.dhallb b/dhall-lang/tests/parser/success/doubleQuotedStringB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/doubleQuotedStringB.dhallb @@ -0,0 +1,1 @@ +‚cABC diff --git a/dhall-lang/tests/parser/success/environmentVariablesA.dhall b/dhall-lang/tests/parser/success/environmentVariablesA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/parser/success/environmentVariablesB.dhallb b/dhall-lang/tests/parser/success/environmentVariablesB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/environmentVariablesB.dhallb differ diff --git a/dhall-lang/tests/parser/success/escapedDoubleQuotedStringA.dhall b/dhall-lang/tests/parser/success/escapedDoubleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/escapedDoubleQuotedStringA.dhall @@ -0,0 +1,1 @@ +"\\\"\$\\\/\b\f\n\r\t \u2200(a : Type) \u2192 a" diff --git a/dhall-lang/tests/parser/success/escapedDoubleQuotedStringB.dhallb b/dhall-lang/tests/parser/success/escapedDoubleQuotedStringB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/escapedDoubleQuotedStringB.dhallb @@ -0,0 +1,2 @@ +‚x\"$\/ + ∀(a : Type) → a diff --git a/dhall-lang/tests/parser/success/escapedSingleQuotedStringA.dhall b/dhall-lang/tests/parser/success/escapedSingleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/escapedSingleQuotedStringA.dhall @@ -0,0 +1,4 @@ +'' +''${ +''' +'' diff --git a/dhall-lang/tests/parser/success/escapedSingleQuotedStringB.dhallb b/dhall-lang/tests/parser/success/escapedSingleQuotedStringB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/escapedSingleQuotedStringB.dhallb @@ -0,0 +1,2 @@ +‚f${ +'' diff --git a/dhall-lang/tests/parser/success/fieldsA.dhall b/dhall-lang/tests/parser/success/fieldsA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/fieldsA.dhall @@ -0,0 +1,1 @@ +({ foo = { bar = { baz = 1 } } }).foo. bar .baz diff --git a/dhall-lang/tests/parser/success/fieldsB.dhallb b/dhall-lang/tests/parser/success/fieldsB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/fieldsB.dhallb @@ -0,0 +1,1 @@ +ƒ ƒ ƒ ‚¡cfoo‚¡cbar‚¡cbaz‚cfoocbarcbaz diff --git a/dhall-lang/tests/parser/success/forallA.dhall b/dhall-lang/tests/parser/success/forallA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/forallA.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → forall (b : Type) -> a diff --git a/dhall-lang/tests/parser/success/forallB.dhallb b/dhall-lang/tests/parser/success/forallB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/forallB.dhallb @@ -0,0 +1,1 @@ +„aadType„abdTypeaa diff --git a/dhall-lang/tests/parser/success/functionTypeA.dhall b/dhall-lang/tests/parser/success/functionTypeA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/functionTypeA.dhall @@ -0,0 +1,1 @@ +Bool → Bool -> Bool diff --git a/dhall-lang/tests/parser/success/functionTypeB.dhallb b/dhall-lang/tests/parser/success/functionTypeB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/functionTypeB.dhallb @@ -0,0 +1,1 @@ +ƒdBoolƒdBooldBool diff --git a/dhall-lang/tests/parser/success/identifierA.dhall b/dhall-lang/tests/parser/success/identifierA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/identifierA.dhall @@ -0,0 +1,1 @@ +λ(a : Type) → λ(a : Type) → a@1 diff --git a/dhall-lang/tests/parser/success/identifierB.dhallb b/dhall-lang/tests/parser/success/identifierB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/identifierB.dhallb @@ -0,0 +1,1 @@ +„aadType„aadType‚aa diff --git a/dhall-lang/tests/parser/success/ifThenElseA.dhall b/dhall-lang/tests/parser/success/ifThenElseA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/ifThenElseA.dhall @@ -0,0 +1,1 @@ +if True then 1 else 2 diff --git a/dhall-lang/tests/parser/success/ifThenElseB.dhallb b/dhall-lang/tests/parser/success/ifThenElseB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/ifThenElseB.dhallb @@ -0,0 +1,1 @@ +„õ‚‚ diff --git a/dhall-lang/tests/parser/success/importAltA.dhall b/dhall-lang/tests/parser/success/importAltA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/importAltA.dhall @@ -0,0 +1,1 @@ +env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2 diff --git a/dhall-lang/tests/parser/success/importAltB.dhallb b/dhall-lang/tests/parser/success/importAltB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/importAltB.dhallb differ diff --git a/dhall-lang/tests/parser/success/interpolatedDoubleQuotedStringA.dhall b/dhall-lang/tests/parser/success/interpolatedDoubleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/interpolatedDoubleQuotedStringA.dhall @@ -0,0 +1,1 @@ +"ABC${Natural/show 123}" diff --git a/dhall-lang/tests/parser/success/interpolatedDoubleQuotedStringB.dhallb b/dhall-lang/tests/parser/success/interpolatedDoubleQuotedStringB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/interpolatedDoubleQuotedStringB.dhallb differ diff --git a/dhall-lang/tests/parser/success/interpolatedSingleQuotedStringA.dhall b/dhall-lang/tests/parser/success/interpolatedSingleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/interpolatedSingleQuotedStringA.dhall @@ -0,0 +1,4 @@ +'' +ABC +${Natural/show 123} +'' diff --git a/dhall-lang/tests/parser/success/interpolatedSingleQuotedStringB.dhallb b/dhall-lang/tests/parser/success/interpolatedSingleQuotedStringB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/interpolatedSingleQuotedStringB.dhallb differ diff --git a/dhall-lang/tests/parser/success/labelA.dhall b/dhall-lang/tests/parser/success/labelA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/labelA.dhall @@ -0,0 +1,2 @@ +let _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ = 1 +in _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ diff --git a/dhall-lang/tests/parser/success/labelB.dhallb b/dhall-lang/tests/parser/success/labelB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/labelB.dhallb @@ -0,0 +1,1 @@ +…xA_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ö‚xA_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ diff --git a/dhall-lang/tests/parser/success/lambdaA.dhall b/dhall-lang/tests/parser/success/lambdaA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/lambdaA.dhall @@ -0,0 +1,1 @@ +λ(a : Type) → \(b : Type) -> a diff --git a/dhall-lang/tests/parser/success/lambdaB.dhallb b/dhall-lang/tests/parser/success/lambdaB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/lambdaB.dhallb @@ -0,0 +1,1 @@ +„aadType„abdTypeaa diff --git a/dhall-lang/tests/parser/success/largeExpressionA.dhall b/dhall-lang/tests/parser/success/largeExpressionA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/parser/success/largeExpressionB.dhallb b/dhall-lang/tests/parser/success/largeExpressionB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/largeExpressionB.dhallb differ diff --git a/dhall-lang/tests/parser/success/letA.dhall b/dhall-lang/tests/parser/success/letA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/letA.dhall @@ -0,0 +1,3 @@ + let x = 1 +in let y : Natural = 2 +in x diff --git a/dhall-lang/tests/parser/success/letB.dhallb b/dhall-lang/tests/parser/success/letB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/letB.dhallb @@ -0,0 +1,1 @@ +…axö‚…aygNatural‚ax diff --git a/dhall-lang/tests/parser/success/lineCommentA.dhall b/dhall-lang/tests/parser/success/lineCommentA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/lineCommentA.dhall @@ -0,0 +1,3 @@ +-- foo + +1 diff --git a/dhall-lang/tests/parser/success/lineCommentB.dhallb b/dhall-lang/tests/parser/success/lineCommentB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/lineCommentB.dhallb @@ -0,0 +1,1 @@ +‚ diff --git a/dhall-lang/tests/parser/success/listA.dhall b/dhall-lang/tests/parser/success/listA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/listA.dhall @@ -0,0 +1,4 @@ +[ [+1, +2, +3] +, [+1, +2, +3] : List Integer +, [] : List Integer +] diff --git a/dhall-lang/tests/parser/success/listB.dhallb b/dhall-lang/tests/parser/success/listB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/listB.dhallb differ diff --git a/dhall-lang/tests/parser/success/mergeA.dhall b/dhall-lang/tests/parser/success/mergeA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/parser/success/mergeB.dhallb b/dhall-lang/tests/parser/success/mergeB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/mergeB.dhallb @@ -0,0 +1,1 @@ +„ax‚  ‚¢cbar„‚ axgIntegercfooƒ‚¢dLeft„abdBoolabeRightlNatural/even„ dLeftõ¡eRightgNatural diff --git a/dhall-lang/tests/parser/success/multiletA.dhall b/dhall-lang/tests/parser/success/multiletA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/multiletA.dhall @@ -0,0 +1,3 @@ +let a = 1 +let b = 2 +in a + b diff --git a/dhall-lang/tests/parser/success/multiletB.dhallb b/dhall-lang/tests/parser/success/multiletB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/multiletB.dhallb @@ -0,0 +1,1 @@ +ˆaaö‚abö‚„aaab diff --git a/dhall-lang/tests/parser/success/naturalA.dhall b/dhall-lang/tests/parser/success/naturalA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/naturalA.dhall @@ -0,0 +1,1 @@ +[ 0, 1, 01, 10 ] diff --git a/dhall-lang/tests/parser/success/naturalB.dhallb b/dhall-lang/tests/parser/success/naturalB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/naturalB.dhallb differ diff --git a/dhall-lang/tests/parser/success/nestedBlockCommentA.dhall b/dhall-lang/tests/parser/success/nestedBlockCommentA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/nestedBlockCommentA.dhall @@ -0,0 +1,3 @@ +{- foo {- bar -} baz -} + +1 diff --git a/dhall-lang/tests/parser/success/nestedBlockCommentB.dhallb b/dhall-lang/tests/parser/success/nestedBlockCommentB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/nestedBlockCommentB.dhallb @@ -0,0 +1,1 @@ +‚ diff --git a/dhall-lang/tests/parser/success/operatorsA.dhall b/dhall-lang/tests/parser/success/operatorsA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/parser/success/operatorsB.dhallb b/dhall-lang/tests/parser/success/operatorsB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/operatorsB.dhallb differ diff --git a/dhall-lang/tests/parser/success/parenthesizeUsingA.dhall b/dhall-lang/tests/parser/success/parenthesizeUsingA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/parser/success/parenthesizeUsingB.dhallb b/dhall-lang/tests/parser/success/parenthesizeUsingB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/parenthesizeUsingB.dhallb differ diff --git a/dhall-lang/tests/parser/success/pathTerminationA.dhall b/dhall-lang/tests/parser/success/pathTerminationA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/pathTerminationA.dhall @@ -0,0 +1,3 @@ +-- Verify that certain punctuation marks terminate paths correctly + λ(x : ./example) +→ [./example, {bar = , qux = ./example}, ./example] diff --git a/dhall-lang/tests/parser/success/pathTerminationB.dhallb b/dhall-lang/tests/parser/success/pathTerminationB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/pathTerminationB.dhallb differ diff --git a/dhall-lang/tests/parser/success/pathsA.dhall b/dhall-lang/tests/parser/success/pathsA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/pathsA.dhall @@ -0,0 +1,5 @@ +[ /absolute/path +, ./relative/path +, ~/home/anchored/path +, /ipfs/QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx/Prelude +] diff --git a/dhall-lang/tests/parser/success/pathsB.dhallb b/dhall-lang/tests/parser/success/pathsB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/pathsB.dhallb differ diff --git a/dhall-lang/tests/parser/success/quotedLabelA.dhall b/dhall-lang/tests/parser/success/quotedLabelA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/parser/success/quotedLabelB.dhallb b/dhall-lang/tests/parser/success/quotedLabelB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/quotedLabelB.dhallb @@ -0,0 +1,1 @@ +‚£hexample1…cletö‚clethexample2…b:.ö‚b:.hexample3…d$refö‚d$ref diff --git a/dhall-lang/tests/parser/success/quotedPathsA.dhall b/dhall-lang/tests/parser/success/quotedPathsA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/parser/success/quotedPathsB.dhallb b/dhall-lang/tests/parser/success/quotedPathsB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/quotedPathsB.dhallb differ diff --git a/dhall-lang/tests/parser/success/recordA.dhall b/dhall-lang/tests/parser/success/recordA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/recordA.dhall @@ -0,0 +1,4 @@ +{ foo = +1 +, bar = 2 +, baz = True +} : { foo : Integer, bar : Natural, baz : Bool } diff --git a/dhall-lang/tests/parser/success/recordB.dhallb b/dhall-lang/tests/parser/success/recordB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/recordB.dhallb @@ -0,0 +1,1 @@ +ƒ‚£cbar‚cbazõcfoo‚‚£cbargNaturalcbazdBoolcfoogInteger diff --git a/dhall-lang/tests/parser/success/reservedPrefixA.dhall b/dhall-lang/tests/parser/success/reservedPrefixA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/reservedPrefixA.dhall @@ -0,0 +1,1 @@ +let TypeSynonym = Integer in +1 : TypeSynonym diff --git a/dhall-lang/tests/parser/success/reservedPrefixB.dhallb b/dhall-lang/tests/parser/success/reservedPrefixB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/reservedPrefixB.dhallb @@ -0,0 +1,1 @@ +…kTypeSynonymögIntegerƒ‚kTypeSynonym diff --git a/dhall-lang/tests/parser/success/singleQuotedStringA.dhall b/dhall-lang/tests/parser/success/singleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/singleQuotedStringA.dhall @@ -0,0 +1,4 @@ +'' +ABC +DEF +'' diff --git a/dhall-lang/tests/parser/success/singleQuotedStringB.dhallb b/dhall-lang/tests/parser/success/singleQuotedStringB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/singleQuotedStringB.dhallb @@ -0,0 +1,2 @@ +‚hABC +DEF diff --git a/dhall-lang/tests/parser/success/sortA.dhall b/dhall-lang/tests/parser/success/sortA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/sortA.dhall @@ -0,0 +1,1 @@ +Sort diff --git a/dhall-lang/tests/parser/success/sortB.dhallb b/dhall-lang/tests/parser/success/sortB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/sortB.dhallb @@ -0,0 +1,1 @@ +dSort diff --git a/dhall-lang/tests/parser/success/templateA.dhall b/dhall-lang/tests/parser/success/templateA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/parser/success/templateB.dhallb b/dhall-lang/tests/parser/success/templateB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/templateB.dhallb differ diff --git a/dhall-lang/tests/parser/success/unicodeCommentA.dhall b/dhall-lang/tests/parser/success/unicodeCommentA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/unicodeCommentA.dhall @@ -0,0 +1,3 @@ +{- ∀(a : Type) → a -} + +1 diff --git a/dhall-lang/tests/parser/success/unicodeCommentB.dhallb b/dhall-lang/tests/parser/success/unicodeCommentB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/unicodeCommentB.dhallb @@ -0,0 +1,1 @@ +‚ diff --git a/dhall-lang/tests/parser/success/unicodeDoubleQuotedStringA.dhall b/dhall-lang/tests/parser/success/unicodeDoubleQuotedStringA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/unicodeDoubleQuotedStringA.dhall @@ -0,0 +1,1 @@ +"∀(a : Type) → a" diff --git a/dhall-lang/tests/parser/success/unicodeDoubleQuotedStringB.dhallb b/dhall-lang/tests/parser/success/unicodeDoubleQuotedStringB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/unicodeDoubleQuotedStringB.dhallb @@ -0,0 +1,1 @@ +‚s∀(a : Type) → a diff --git a/dhall-lang/tests/parser/success/unicodePathsA.dhall b/dhall-lang/tests/parser/success/unicodePathsA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/unicodePathsA.dhall @@ -0,0 +1,1 @@ +./families/"禺.dhall" diff --git a/dhall-lang/tests/parser/success/unicodePathsB.dhallb b/dhall-lang/tests/parser/success/unicodePathsB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/unicodePathsB.dhallb differ diff --git a/dhall-lang/tests/parser/success/unionA.dhall b/dhall-lang/tests/parser/success/unionA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/unionA.dhall @@ -0,0 +1,4 @@ +< A : { } +| B = { = } +| C : {} +> : < A : {} | B : {} | C : {} > diff --git a/dhall-lang/tests/parser/success/unionB.dhallb b/dhall-lang/tests/parser/success/unionB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/unionB.dhallb @@ -0,0 +1,1 @@ +ƒ„ aB‚ ¢aA‚ aC‚ ‚ £aA‚ aB‚ aC‚  diff --git a/dhall-lang/tests/parser/success/urlsA.dhall b/dhall-lang/tests/parser/success/urlsA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/parser/success/urlsB.dhallb b/dhall-lang/tests/parser/success/urlsB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/urlsB.dhallb differ diff --git a/dhall-lang/tests/parser/success/whitespaceA.dhall b/dhall-lang/tests/parser/success/whitespaceA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/whitespaceA.dhall @@ -0,0 +1,3 @@ + +1 + diff --git a/dhall-lang/tests/parser/success/whitespaceB.dhallb b/dhall-lang/tests/parser/success/whitespaceB.dhallb new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/whitespaceB.dhallb @@ -0,0 +1,1 @@ +‚ diff --git a/dhall-lang/tests/parser/success/whitespaceBuffetA.dhall b/dhall-lang/tests/parser/success/whitespaceBuffetA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/parser/success/whitespaceBuffetA.dhall @@ -0,0 +1,9 @@ + -- This + + Natural/even {- + +{- file +-} + has + + -} 2 -- mixed {- line endings -} diff --git a/dhall-lang/tests/parser/success/whitespaceBuffetB.dhallb b/dhall-lang/tests/parser/success/whitespaceBuffetB.dhallb new file mode 100644 Binary files /dev/null and b/dhall-lang/tests/parser/success/whitespaceBuffetB.dhallb differ diff --git a/dhall-lang/tests/typecheck/failure/combineMixedRecords.dhall b/dhall-lang/tests/typecheck/failure/combineMixedRecords.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/failure/combineMixedRecords.dhall @@ -0,0 +1,1 @@ +{ foo = 1 } ∧ { bar = Text } diff --git a/dhall-lang/tests/typecheck/failure/duplicateFields.dhall b/dhall-lang/tests/typecheck/failure/duplicateFields.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/failure/duplicateFields.dhall @@ -0,0 +1,1 @@ +{ a = 1, a = 2 } diff --git a/dhall-lang/tests/typecheck/failure/hurkensParadox.dhall b/dhall-lang/tests/typecheck/failure/hurkensParadox.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/failure/mixedUnions.dhall b/dhall-lang/tests/typecheck/failure/mixedUnions.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/failure/mixedUnions.dhall @@ -0,0 +1,1 @@ +< Left : Natural | Right : Type > diff --git a/dhall-lang/tests/typecheck/failure/preferMixedRecords.dhall b/dhall-lang/tests/typecheck/failure/preferMixedRecords.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/failure/preferMixedRecords.dhall @@ -0,0 +1,1 @@ +{ foo = 1 } ⫽ { bar = Text } diff --git a/dhall-lang/tests/typecheck/success/accessEncodedTypeA.dhall b/dhall-lang/tests/typecheck/success/accessEncodedTypeA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/accessEncodedTypeB.dhall b/dhall-lang/tests/typecheck/success/accessEncodedTypeB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/accessEncodedTypeB.dhall @@ -0,0 +1,4 @@ + ∀ ( record + : ∀(k : Kind) → ∀(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k) → k + ) +→ Type diff --git a/dhall-lang/tests/typecheck/success/accessTypeA.dhall b/dhall-lang/tests/typecheck/success/accessTypeA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/accessTypeA.dhall @@ -0,0 +1,1 @@ +λ(record : { x : Type, y : Type → Type }) → record.x diff --git a/dhall-lang/tests/typecheck/success/accessTypeB.dhall b/dhall-lang/tests/typecheck/success/accessTypeB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/accessTypeB.dhall @@ -0,0 +1,1 @@ +∀(record : { x : Type, y : Type → Type }) → Type diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/and/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/and/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/and/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/and [ True, False, True ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/and/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/and/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/and/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/and/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/and/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/and/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/and ([] : List Bool) diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/and/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/and/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/and/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/build/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/build/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Bool/build/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/build/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/build/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/build/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/build/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Bool/build/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/build/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/build/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/even/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/even/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/even/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/even [ False, True, False ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/even/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/even/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/even/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/even/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/even/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/even/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/even [ False, True ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/even/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/even/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/even/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/even/2A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/even/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/even/2A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/even [ False ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/even/2B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/even/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/even/2B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/even/3A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/even/3A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/even/3A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/even ([] : List Bool) diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/even/3B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/even/3B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/even/3B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/fold/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/fold/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/fold True Natural 0 1 diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/fold/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/fold/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/fold/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/fold/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/fold False Natural 0 1 diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/fold/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/fold/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/not/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/not/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/not/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/not True diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/not/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/not/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/not/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/not/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/not/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/not/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/not False diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/not/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/not/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/not/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/odd/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/odd [ True, False, True ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/odd/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/odd/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/odd [ True, False ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/odd/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/odd/2A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/2A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/odd [ True ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/odd/2B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/2B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/odd/3A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/3A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/3A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/odd ([] : List Bool) diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/odd/3B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/3B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/odd/3B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/or/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/or/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/or/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/or [ True, False, True ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/or/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/or/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/or/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/or/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/or/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/or/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/or ([] : List Bool) diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/or/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/or/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/or/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/show/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/show/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/show/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/show True diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/show/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/show/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/show/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/show/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/show/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/show/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Bool/show False diff --git a/dhall-lang/tests/typecheck/success/prelude/Bool/show/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Bool/show/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Bool/show/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Double/show/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Double/show/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Double/show/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Double/show -3.1 diff --git a/dhall-lang/tests/typecheck/success/prelude/Double/show/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Double/show/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Double/show/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Double/show/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Double/show/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Double/show/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Double/show 0.4 diff --git a/dhall-lang/tests/typecheck/success/prelude/Double/show/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Double/show/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Double/show/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Integer/show/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Integer/show/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Integer/show/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Integer/show -3 diff --git a/dhall-lang/tests/typecheck/success/prelude/Integer/show/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Integer/show/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Integer/show/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Integer/show/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Integer/show/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Integer/show/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Integer/show +0 diff --git a/dhall-lang/tests/typecheck/success/prelude/Integer/show/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Integer/show/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Integer/show/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Integer/toDouble -3 diff --git a/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/0B.dhall @@ -0,0 +1,1 @@ +Double diff --git a/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Integer/toDouble +2 diff --git a/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/1B.dhall @@ -0,0 +1,1 @@ +Double diff --git a/dhall-lang/tests/typecheck/success/prelude/List/all/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/all/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/all/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/all Natural Natural/even [ 2, 3, 5 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/List/all/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/all/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/all/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/List/all/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/all/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/all/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/all Natural Natural/even ([] : List Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/List/all/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/all/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/all/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/List/any/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/any/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/any/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/any Natural Natural/even [ 2, 3, 5 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/List/any/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/any/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/any/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/List/any/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/any/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/any/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/any Natural Natural/even ([] : List Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/List/any/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/any/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/any/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/List/build/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/build/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/build/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/build/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/build/0B.dhall @@ -0,0 +1,1 @@ +List Text diff --git a/dhall-lang/tests/typecheck/success/prelude/List/build/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/build/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/build/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/build/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/build/1B.dhall @@ -0,0 +1,1 @@ +List Text diff --git a/dhall-lang/tests/typecheck/success/prelude/List/concat/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/concat/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/concat/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/concat/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/concat/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/concat/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/concatMap/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/concatMap/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/concatMap/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/concatMap/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/concatMap/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/concatMap/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/concatMap/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/concatMap/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/concatMap/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/concatMap/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/filter/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/filter/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/filter/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/filter Natural Natural/even [ 2, 3, 5 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/List/filter/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/filter/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/filter/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/filter/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/filter/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/filter/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/filter Natural Natural/odd [ 2, 3, 5 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/List/filter/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/filter/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/filter/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/fold/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/fold/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/fold/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/fold/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/fold/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/fold/1B.dhall @@ -0,0 +1,1 @@ +∀(nil : Natural) → Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/fold/2A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/fold/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/fold/2B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/fold/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/fold/2B.dhall @@ -0,0 +1,1 @@ +∀(list : Type) → ∀(cons : Natural → list → list) → ∀(nil : list) → list diff --git a/dhall-lang/tests/typecheck/success/prelude/List/generate/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/generate/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/generate/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/generate 5 Bool Natural/even diff --git a/dhall-lang/tests/typecheck/success/prelude/List/generate/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/generate/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/generate/0B.dhall @@ -0,0 +1,1 @@ +List Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/List/generate/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/generate/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/generate/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/generate 0 Bool Natural/even diff --git a/dhall-lang/tests/typecheck/success/prelude/List/generate/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/generate/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/generate/1B.dhall @@ -0,0 +1,1 @@ +List Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/List/head/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/head/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/head/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/head Natural [ 0, 1, 2 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/List/head/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/head/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/head/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/head/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/head/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/head/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/head Natural ([] : List Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/List/head/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/head/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/head/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/indexed/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/indexed/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/indexed/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/indexed Bool [ True, False, True ] diff --git a/dhall-lang/tests/typecheck/success/prelude/List/indexed/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/indexed/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/indexed/0B.dhall @@ -0,0 +1,1 @@ +List { index : Natural, value : Bool } diff --git a/dhall-lang/tests/typecheck/success/prelude/List/indexed/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/indexed/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/indexed/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/indexed Bool ([] : List Bool) diff --git a/dhall-lang/tests/typecheck/success/prelude/List/indexed/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/indexed/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/indexed/1B.dhall @@ -0,0 +1,1 @@ +List { index : Natural, value : Bool } diff --git a/dhall-lang/tests/typecheck/success/prelude/List/iterate/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/iterate/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/iterate/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/iterate/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/iterate/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/iterate/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/iterate/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/iterate/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/iterate/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/iterate/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/last/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/last/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/last/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/last Natural [ 0, 1, 2 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/List/last/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/last/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/last/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/last/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/last/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/last/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/last Natural ([] : List Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/List/last/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/last/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/last/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/length/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/length/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/length/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/length Natural [ 0, 1, 2 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/List/length/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/length/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/length/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/length/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/length/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/length/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/length Natural ([] : List Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/List/length/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/length/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/length/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/map/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/map/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/map/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/map/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/map/0B.dhall @@ -0,0 +1,1 @@ +List Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/List/map/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/map/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/map/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/map Natural Bool Natural/even ([] : List Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/List/map/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/map/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/map/1B.dhall @@ -0,0 +1,1 @@ +List Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/List/null/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/null/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/null/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/null Natural [ 0, 1, 2 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/List/null/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/null/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/null/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/List/null/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/null/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/null/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/null Natural ([] : List Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/List/null/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/null/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/null/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/List/replicate/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/replicate/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/replicate/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/replicate 9 Natural 1 diff --git a/dhall-lang/tests/typecheck/success/prelude/List/replicate/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/replicate/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/replicate/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/replicate/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/replicate/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/replicate/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/replicate 0 Natural 1 diff --git a/dhall-lang/tests/typecheck/success/prelude/List/replicate/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/replicate/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/replicate/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/reverse/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/reverse/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/reverse/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/reverse Natural [ 0, 1, 2 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/List/reverse/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/reverse/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/reverse/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/reverse/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/reverse/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/reverse/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/List/reverse Natural ([] : List Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/List/reverse/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/reverse/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/reverse/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/List/shifted/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/shifted/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/shifted/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/shifted/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/shifted/0B.dhall @@ -0,0 +1,1 @@ +List { index : Natural, value : Bool } diff --git a/dhall-lang/tests/typecheck/success/prelude/List/shifted/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/shifted/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/shifted/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/shifted/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/shifted/1B.dhall @@ -0,0 +1,1 @@ +List { index : Natural, value : Bool } diff --git a/dhall-lang/tests/typecheck/success/prelude/List/unzip/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/unzip/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/unzip/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/unzip/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/unzip/0B.dhall @@ -0,0 +1,1 @@ +{ _1 : List Text, _2 : List Bool } diff --git a/dhall-lang/tests/typecheck/success/prelude/List/unzip/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/List/unzip/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/List/unzip/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/List/unzip/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/List/unzip/1B.dhall @@ -0,0 +1,1 @@ +{ _1 : List Text, _2 : List Bool } diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/00A.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/00A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/00A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Bool`.and diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/00B.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/00B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/00B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/01A.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/01A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/01A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Bool`.or diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/01B.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/01B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/01B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/02A.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/02A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/02A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Bool`.even diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/02B.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/02B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/02B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/03A.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/03A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/03A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Bool`.odd diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/03B.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/03B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/03B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/04A.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/04A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/04A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`List`.concat diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/04B.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/04B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/04B.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → ../../../../../Prelude/Monoid (List a) diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/05A.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/05A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/05A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`List`.shifted diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/05B.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/05B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/05B.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → ../../../../../Prelude/Monoid (List { index : Natural, value : a }) diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/06A.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/06A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/06A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Natural`.sum diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/06B.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/06B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/06B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/07A.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/07A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/07A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Natural`.product diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/07B.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/07B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/07B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/08A.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/08A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/08A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Optional`.head diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/08B.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/08B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/08B.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → ../../../../../Prelude/Monoid (Optional a) diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/09A.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/09A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/09A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Optional`.last diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/09B.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/09B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/09B.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → ../../../../../Prelude/Monoid (Optional a) diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/10A.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/10A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/10A.dhall @@ -0,0 +1,1 @@ +(../../../../../Prelude/package.dhall).`Text`.concat diff --git a/dhall-lang/tests/typecheck/success/prelude/Monoid/10B.dhall b/dhall-lang/tests/typecheck/success/prelude/Monoid/10B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Monoid/10B.dhall @@ -0,0 +1,1 @@ +../../../../../Prelude/Monoid Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/build/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/build/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Natural/build/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/build/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/build/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/build/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/build/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Natural/build/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/build/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/build/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/enumerate 10 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/enumerate 0 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/even/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/even/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/even/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/even 3 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/even/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/even/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/even/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/even/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/even/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/even/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/even 0 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/even/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/even/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/even/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/fold/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Natural/fold/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/fold/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/fold/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Natural/fold/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/fold/1B.dhall @@ -0,0 +1,1 @@ +∀(zero : Natural) → Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/fold/2A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/fold/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Natural/fold/2B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/fold/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/fold/2B.dhall @@ -0,0 +1,1 @@ +∀(natural : Type) → ∀(succ : natural → natural) → ∀(zero : natural) → natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/isZero 2 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/isZero 0 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/isZero/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/odd/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/odd/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/odd/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/odd 3 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/odd/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/odd/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/odd/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/odd/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/odd/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/odd/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/odd 0 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/odd/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/odd/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/odd/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/product/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/product/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/product/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/product [ 2, 3, 5 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/product/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/product/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/product/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/product/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/product/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/product/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/product ([] : List Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/product/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/product/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/product/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/show/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/show/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/show/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/show 3 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/show/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/show/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/show/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/show/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/show/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/show/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/show 0 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/show/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/show/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/show/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/sum/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/sum/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/sum/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/sum [ 2, 3, 5 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/sum/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/sum/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/sum/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/sum/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/sum/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/sum/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/sum ([] : List Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/sum/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/sum/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/sum/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/toDouble 3 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/0B.dhall @@ -0,0 +1,1 @@ +Double diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/toDouble 0 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/1B.dhall @@ -0,0 +1,1 @@ +Double diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/toInteger 3 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/0B.dhall @@ -0,0 +1,1 @@ +Integer diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Natural/toInteger 0 diff --git a/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/1B.dhall @@ -0,0 +1,1 @@ +Integer diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/all/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/all/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/all/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/all Natural Natural/even (Some 3) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/all/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/all/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/all/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/all/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/all/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/all/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/all Natural Natural/even (None Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/all/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/all/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/all/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/any/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/any/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/any/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/any Natural Natural/even (Some 2) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/any/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/any/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/any/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/any/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/any/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/any/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/any Natural Natural/even (None Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/any/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/any/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/any/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/build/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/build/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Optional/build/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/build/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/build/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/build/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/build/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Optional/build/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/build/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/build/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/concat/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/concat Natural (Some (Some 1)) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/concat/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/concat/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/concat Natural (Some (None Natural)) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/concat/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/concat/2A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/2A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/concat Natural (None (Optional Natural)) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/concat/2B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/concat/2B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/filter/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/filter/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/filter/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/filter Natural Natural/even (Some 2) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/filter/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/filter/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/filter/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/filter/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/filter/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/filter/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/filter Natural Natural/odd (Some 2) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/filter/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/filter/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/filter/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/fold/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/fold/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Optional/fold/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/fold/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/fold/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/fold/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/fold/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Optional/fold/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/fold/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/fold/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/head/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/head/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Optional/head/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/head/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/head/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/head/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/head/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/head/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/head Natural [ None Natural, None Natural ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/head/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/head/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/head/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/head/2A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/head/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/head/2A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/head Natural ([] : List (Optional Natural)) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/head/2B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/head/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/head/2B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/last/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/last/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Optional/last/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/last/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/last/0B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/last/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/last/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/last/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/last Natural [ None Natural, None Natural ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/last/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/last/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/last/1B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/last/2A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/last/2A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/last/2A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/last Natural ([] : List (Optional Natural)) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/last/2B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/last/2B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/last/2B.dhall @@ -0,0 +1,1 @@ +Optional Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/length/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/length/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/length/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/length Natural (Some 2) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/length/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/length/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/length/0B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/length/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/length/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/length/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/length Natural (None Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/length/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/length/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/length/1B.dhall @@ -0,0 +1,1 @@ +Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/map/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/map/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/map/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/map Natural Bool Natural/even (Some 3) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/map/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/map/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/map/0B.dhall @@ -0,0 +1,1 @@ +Optional Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/map/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/map/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/map/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/map Natural Bool Natural/even (None Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/map/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/map/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/map/1B.dhall @@ -0,0 +1,1 @@ +Optional Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/null/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/null/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/null/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/null Natural (Some 2) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/null/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/null/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/null/0B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/null/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/null/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/null/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/null Natural (None Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/null/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/null/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/null/1B.dhall @@ -0,0 +1,1 @@ +Bool diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/toList/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/toList/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/toList/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/toList Natural (Some 1) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/toList/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/toList/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/toList/0B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/toList/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/toList/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/toList/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Optional/toList Natural (None Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/toList/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/toList/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/toList/1B.dhall @@ -0,0 +1,1 @@ +List Natural diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/unzip/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/unzip/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Optional/unzip/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/unzip/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/unzip/0B.dhall @@ -0,0 +1,1 @@ +{ _1 : Optional Text, _2 : Optional Bool } diff --git a/dhall-lang/tests/typecheck/success/prelude/Optional/unzip/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/unzip/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Optional/unzip/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Optional/unzip/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Optional/unzip/1B.dhall @@ -0,0 +1,1 @@ +{ _1 : Optional Text, _2 : Optional Bool } diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concat/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concat/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concat/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concat [ "ABC", "DEF", "GHI" ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concat/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concat/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concat/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concat/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concat/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concat/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concat ([] : List Text) diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concat/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concat/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concat/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concatMap/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatMap/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Text/concatMap/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatMap/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concatMap/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concatMap/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatMap/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/prelude/Text/concatMap/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatMap/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concatMap/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concatMapSep ", " Natural Natural/show [ 0, 1, 2 ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concatMapSep ", " Natural Natural/show ([] : List Natural) diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/0A.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/0A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concatSep ", " [ "ABC", "DEF", "GHI" ] diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/0B.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/0B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/1A.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/1A.dhall @@ -0,0 +1,1 @@ +../../../../../../Prelude/Text/concatSep ", " ([] : List Text) diff --git a/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/1B.dhall b/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/prelude/Text/concatSep/1B.dhall @@ -0,0 +1,1 @@ +Text diff --git a/dhall-lang/tests/typecheck/success/recordOfRecordOfTypesA.dhall b/dhall-lang/tests/typecheck/success/recordOfRecordOfTypesA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/recordOfRecordOfTypesA.dhall @@ -0,0 +1,3 @@ +let types = { Scopes = < Public : {} | Private : {} >} +let prelude = { types = types } +in prelude.types.Scopes.Public {=} diff --git a/dhall-lang/tests/typecheck/success/recordOfRecordOfTypesB.dhall b/dhall-lang/tests/typecheck/success/recordOfRecordOfTypesB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/recordOfRecordOfTypesB.dhall @@ -0,0 +1,1 @@ +< Public : {} | Private : {} > diff --git a/dhall-lang/tests/typecheck/success/recordOfTypesA.dhall b/dhall-lang/tests/typecheck/success/recordOfTypesA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/recordOfTypesA.dhall @@ -0,0 +1,1 @@ +{ x = Text, y = List } diff --git a/dhall-lang/tests/typecheck/success/recordOfTypesB.dhall b/dhall-lang/tests/typecheck/success/recordOfTypesB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/recordOfTypesB.dhall @@ -0,0 +1,1 @@ +{ x : Type, y : Type → Type } diff --git a/dhall-lang/tests/typecheck/success/simple/access/0A.dhall b/dhall-lang/tests/typecheck/success/simple/access/0A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/access/0A.dhall @@ -0,0 +1,1 @@ +{ x = Text }.x diff --git a/dhall-lang/tests/typecheck/success/simple/access/0B.dhall b/dhall-lang/tests/typecheck/success/simple/access/0B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/access/0B.dhall @@ -0,0 +1,1 @@ +Type diff --git a/dhall-lang/tests/typecheck/success/simple/access/1A.dhall b/dhall-lang/tests/typecheck/success/simple/access/1A.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/access/1A.dhall @@ -0,0 +1,1 @@ +< Foo : Text | Bar : Natural >.Foo diff --git a/dhall-lang/tests/typecheck/success/simple/access/1B.dhall b/dhall-lang/tests/typecheck/success/simple/access/1B.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/access/1B.dhall @@ -0,0 +1,1 @@ +∀(Foo : Text) → < Bar : Natural | Foo : Text > diff --git a/dhall-lang/tests/typecheck/success/simple/alternativesAreTypesA.dhall b/dhall-lang/tests/typecheck/success/simple/alternativesAreTypesA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/alternativesAreTypesA.dhall @@ -0,0 +1,1 @@ +< Left = List | Right : Type > diff --git a/dhall-lang/tests/typecheck/success/simple/alternativesAreTypesB.dhall b/dhall-lang/tests/typecheck/success/simple/alternativesAreTypesB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/alternativesAreTypesB.dhall @@ -0,0 +1,1 @@ +< Left : Type → Type | Right : Type > diff --git a/dhall-lang/tests/typecheck/success/simple/anonymousFunctionsInTypesA.dhall b/dhall-lang/tests/typecheck/success/simple/anonymousFunctionsInTypesA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/simple/anonymousFunctionsInTypesB.dhall b/dhall-lang/tests/typecheck/success/simple/anonymousFunctionsInTypesB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/simple/fieldsAreTypesA.dhall b/dhall-lang/tests/typecheck/success/simple/fieldsAreTypesA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/fieldsAreTypesA.dhall @@ -0,0 +1,1 @@ +{ x = Bool, y = Text, z = List } diff --git a/dhall-lang/tests/typecheck/success/simple/fieldsAreTypesB.dhall b/dhall-lang/tests/typecheck/success/simple/fieldsAreTypesB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/fieldsAreTypesB.dhall @@ -0,0 +1,1 @@ +{ x : Type, y : Type, z : Type → Type } diff --git a/dhall-lang/tests/typecheck/success/simple/kindParameterA.dhall b/dhall-lang/tests/typecheck/success/simple/kindParameterA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/kindParameterA.dhall @@ -0,0 +1,1 @@ +λ(k : Kind) → λ(a : k → k → Type) → λ(x : k) → a x diff --git a/dhall-lang/tests/typecheck/success/simple/kindParameterB.dhall b/dhall-lang/tests/typecheck/success/simple/kindParameterB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/kindParameterB.dhall @@ -0,0 +1,1 @@ +∀(k : Kind) → (k → k → Type) → k → k → Type diff --git a/dhall-lang/tests/typecheck/success/simple/mergeEquivalenceA.dhall b/dhall-lang/tests/typecheck/success/simple/mergeEquivalenceA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/simple/mergeEquivalenceB.dhall b/dhall-lang/tests/typecheck/success/simple/mergeEquivalenceB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/mergeEquivalenceB.dhall @@ -0,0 +1,1 @@ +∀(a : Type) → ∀(f : {} → a) → ∀(ts : < Bar : {} | Baz : {} >) → a diff --git a/dhall-lang/tests/typecheck/success/simple/mixedFieldAccessA.dhall b/dhall-lang/tests/typecheck/success/simple/mixedFieldAccessA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/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/dhall-lang/tests/typecheck/success/simple/mixedFieldAccessB.dhall b/dhall-lang/tests/typecheck/success/simple/mixedFieldAccessB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/mixedFieldAccessB.dhall @@ -0,0 +1,1 @@ +< Private : {} | Public : {} > diff --git a/dhall-lang/tests/typecheck/success/simple/unionsOfTypesA.dhall b/dhall-lang/tests/typecheck/success/simple/unionsOfTypesA.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/unionsOfTypesA.dhall @@ -0,0 +1,1 @@ +< Left = List | Right : Type > diff --git a/dhall-lang/tests/typecheck/success/simple/unionsOfTypesB.dhall b/dhall-lang/tests/typecheck/success/simple/unionsOfTypesB.dhall new file mode 100644 --- /dev/null +++ b/dhall-lang/tests/typecheck/success/simple/unionsOfTypesB.dhall @@ -0,0 +1,1 @@ +< Left : Type → Type | Right : Type > diff --git a/dhall.cabal b/dhall.cabal --- a/dhall.cabal +++ b/dhall.cabal @@ -1,8 +1,8 @@ Name: dhall -Version: 1.20.1 +Version: 1.21.0 Cabal-Version: >=1.10 Build-Type: Simple -Tested-With: GHC == 8.0.1 +Tested-With: GHC == 7.10.3, GHC == 8.4.3, GHC == 8.6.1 License: BSD3 License-File: LICENSE Copyright: 2017 Gabriel Gonzalez @@ -26,263 +26,338 @@ benchmark/deep-nested-large-record/*.dhall benchmark/examples/*.dhall CHANGELOG.md - Prelude/Monoid - Prelude/package.dhall + dhall-lang/Prelude/Bool/and + dhall-lang/Prelude/Bool/build + dhall-lang/Prelude/Bool/even + dhall-lang/Prelude/Bool/fold + dhall-lang/Prelude/Bool/not + dhall-lang/Prelude/Bool/odd + dhall-lang/Prelude/Bool/or + dhall-lang/Prelude/Bool/package.dhall + dhall-lang/Prelude/Bool/show + dhall-lang/Prelude/Double/package.dhall + dhall-lang/Prelude/Double/show + dhall-lang/Prelude/Function/compose + dhall-lang/Prelude/Function/package.dhall + dhall-lang/Prelude/Integer/package.dhall + dhall-lang/Prelude/Integer/show + dhall-lang/Prelude/Integer/toDouble + dhall-lang/Prelude/JSON/keyText + dhall-lang/Prelude/JSON/keyValue + dhall-lang/Prelude/JSON/Nesting + dhall-lang/Prelude/JSON/package.dhall + dhall-lang/Prelude/JSON/Tagged + dhall-lang/Prelude/List/all + dhall-lang/Prelude/List/any + dhall-lang/Prelude/List/build + dhall-lang/Prelude/List/concat + dhall-lang/Prelude/List/concatMap + dhall-lang/Prelude/List/filter + dhall-lang/Prelude/List/fold + dhall-lang/Prelude/List/generate + dhall-lang/Prelude/List/head + dhall-lang/Prelude/List/indexed + dhall-lang/Prelude/List/iterate + dhall-lang/Prelude/List/last + dhall-lang/Prelude/List/length + dhall-lang/Prelude/List/map + dhall-lang/Prelude/List/null + dhall-lang/Prelude/List/package.dhall + dhall-lang/Prelude/List/replicate + dhall-lang/Prelude/List/reverse + dhall-lang/Prelude/List/shifted + dhall-lang/Prelude/List/unzip + dhall-lang/Prelude/Monoid + dhall-lang/Prelude/Natural/build + dhall-lang/Prelude/Natural/enumerate + dhall-lang/Prelude/Natural/even + dhall-lang/Prelude/Natural/fold + dhall-lang/Prelude/Natural/isZero + dhall-lang/Prelude/Natural/odd + dhall-lang/Prelude/Natural/package.dhall + dhall-lang/Prelude/Natural/product + dhall-lang/Prelude/Natural/show + dhall-lang/Prelude/Natural/sum + dhall-lang/Prelude/Natural/toDouble + dhall-lang/Prelude/Natural/toInteger + dhall-lang/Prelude/Optional/all + dhall-lang/Prelude/Optional/any + dhall-lang/Prelude/Optional/build + dhall-lang/Prelude/Optional/concat + dhall-lang/Prelude/Optional/filter + dhall-lang/Prelude/Optional/fold + dhall-lang/Prelude/Optional/head + dhall-lang/Prelude/Optional/last + dhall-lang/Prelude/Optional/length + dhall-lang/Prelude/Optional/map + dhall-lang/Prelude/Optional/null + dhall-lang/Prelude/Optional/package.dhall + dhall-lang/Prelude/Optional/toList + dhall-lang/Prelude/Optional/unzip + dhall-lang/Prelude/package.dhall + dhall-lang/Prelude/Text/concat + dhall-lang/Prelude/Text/concatMap + dhall-lang/Prelude/Text/concatMapSep + dhall-lang/Prelude/Text/concatSep + dhall-lang/Prelude/Text/package.dhall + dhall-lang/Prelude/Text/show + dhall-lang/tests/import/data/fieldOrder/*.dhall + dhall-lang/tests/import/failure/*.dhall + dhall-lang/tests/import/success/*.dhall + dhall-lang/tests/normalization/success/*.dhall + dhall-lang/tests/normalization/success/haskell-tutorial/access/*.dhall + dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/*.dhall + dhall-lang/tests/normalization/success/haskell-tutorial/prefer/*.dhall + dhall-lang/tests/normalization/success/haskell-tutorial/projection/*.dhall + dhall-lang/tests/normalization/success/multiline/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/and/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/and/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/build/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/build/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/even/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/even/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/fold/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/fold/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/not/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/not/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/odd/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/odd/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/or/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/or/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/show/*.dhall + dhall-lang/tests/normalization/success/prelude/Bool/show/*.dhall + dhall-lang/tests/normalization/success/prelude/Double/show/*.dhall + dhall-lang/tests/normalization/success/prelude/Double/show/*.dhall + dhall-lang/tests/normalization/success/prelude/Integer/show/*.dhall + dhall-lang/tests/normalization/success/prelude/Integer/show/*.dhall + dhall-lang/tests/normalization/success/prelude/Integer/toDouble/*.dhall + dhall-lang/tests/normalization/success/prelude/Integer/toDouble/*.dhall + dhall-lang/tests/normalization/success/prelude/List/all/*.dhall + dhall-lang/tests/normalization/success/prelude/List/all/*.dhall + dhall-lang/tests/normalization/success/prelude/List/any/*.dhall + dhall-lang/tests/normalization/success/prelude/List/any/*.dhall + dhall-lang/tests/normalization/success/prelude/List/build/*.dhall + dhall-lang/tests/normalization/success/prelude/List/build/*.dhall + dhall-lang/tests/normalization/success/prelude/List/concat/*.dhall + dhall-lang/tests/normalization/success/prelude/List/concat/*.dhall + dhall-lang/tests/normalization/success/prelude/List/concatMap/*.dhall + dhall-lang/tests/normalization/success/prelude/List/concatMap/*.dhall + dhall-lang/tests/normalization/success/prelude/List/filter/*.dhall + dhall-lang/tests/normalization/success/prelude/List/filter/*.dhall + dhall-lang/tests/normalization/success/prelude/List/fold/*.dhall + dhall-lang/tests/normalization/success/prelude/List/fold/*.dhall + dhall-lang/tests/normalization/success/prelude/List/generate/*.dhall + dhall-lang/tests/normalization/success/prelude/List/generate/*.dhall + dhall-lang/tests/normalization/success/prelude/List/head/*.dhall + dhall-lang/tests/normalization/success/prelude/List/head/*.dhall + dhall-lang/tests/normalization/success/prelude/List/indexed/*.dhall + dhall-lang/tests/normalization/success/prelude/List/indexed/*.dhall + dhall-lang/tests/normalization/success/prelude/List/iterate/*.dhall + dhall-lang/tests/normalization/success/prelude/List/iterate/*.dhall + dhall-lang/tests/normalization/success/prelude/List/last/*.dhall + dhall-lang/tests/normalization/success/prelude/List/last/*.dhall + dhall-lang/tests/normalization/success/prelude/List/length/*.dhall + dhall-lang/tests/normalization/success/prelude/List/length/*.dhall + dhall-lang/tests/normalization/success/prelude/List/map/*.dhall + dhall-lang/tests/normalization/success/prelude/List/map/*.dhall + dhall-lang/tests/normalization/success/prelude/List/null/*.dhall + dhall-lang/tests/normalization/success/prelude/List/null/*.dhall + dhall-lang/tests/normalization/success/prelude/List/replicate/*.dhall + dhall-lang/tests/normalization/success/prelude/List/replicate/*.dhall + dhall-lang/tests/normalization/success/prelude/List/reverse/*.dhall + dhall-lang/tests/normalization/success/prelude/List/reverse/*.dhall + dhall-lang/tests/normalization/success/prelude/List/shifted/*.dhall + dhall-lang/tests/normalization/success/prelude/List/shifted/*.dhall + dhall-lang/tests/normalization/success/prelude/List/unzip/*.dhall + dhall-lang/tests/normalization/success/prelude/List/unzip/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/build/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/build/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/enumerate/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/enumerate/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/even/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/even/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/fold/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/fold/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/isZero/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/isZero/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/odd/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/odd/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/product/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/product/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/show/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/show/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/sum/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/sum/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/toDouble/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/toDouble/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/toInteger/*.dhall + dhall-lang/tests/normalization/success/prelude/Natural/toInteger/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/all/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/all/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/any/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/any/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/build/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/build/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/concat/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/concat/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/filter/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/filter/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/fold/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/fold/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/head/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/head/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/last/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/last/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/length/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/length/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/map/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/map/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/null/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/null/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/toList/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/toList/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/unzip/*.dhall + dhall-lang/tests/normalization/success/prelude/Optional/unzip/*.dhall + dhall-lang/tests/normalization/success/prelude/Text/concat/*.dhall + dhall-lang/tests/normalization/success/prelude/Text/concat/*.dhall + dhall-lang/tests/normalization/success/prelude/Text/concatMap/*.dhall + dhall-lang/tests/normalization/success/prelude/Text/concatMap/*.dhall + dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/*.dhall + dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/*.dhall + dhall-lang/tests/normalization/success/prelude/Text/concatSep/*.dhall + dhall-lang/tests/normalization/success/prelude/Text/concatSep/*.dhall + dhall-lang/tests/normalization/success/prelude/Text/show/*.dhall + dhall-lang/tests/normalization/success/prelude/Text/show/*.dhall + dhall-lang/tests/normalization/success/simple/*.dhall + dhall-lang/tests/normalization/success/simplifications/*.dhall + dhall-lang/tests/parser/failure/*.dhall + dhall-lang/tests/parser/success/*.dhall + dhall-lang/tests/parser/success/*.dhallb + dhall-lang/tests/typecheck/failure/*.dhall + dhall-lang/tests/typecheck/success/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/and/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/and/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/build/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/build/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/even/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/even/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/fold/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/fold/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/not/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/not/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/odd/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/odd/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/or/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/or/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/show/*.dhall + dhall-lang/tests/typecheck/success/prelude/Bool/show/*.dhall + dhall-lang/tests/typecheck/success/prelude/Double/show/*.dhall + dhall-lang/tests/typecheck/success/prelude/Double/show/*.dhall + dhall-lang/tests/typecheck/success/prelude/Integer/show/*.dhall + dhall-lang/tests/typecheck/success/prelude/Integer/show/*.dhall + dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/*.dhall + dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/all/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/all/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/any/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/any/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/build/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/build/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/concat/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/concat/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/concatMap/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/concatMap/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/filter/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/filter/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/fold/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/fold/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/generate/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/generate/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/head/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/head/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/indexed/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/indexed/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/iterate/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/iterate/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/last/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/last/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/length/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/length/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/map/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/map/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/null/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/null/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/replicate/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/replicate/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/reverse/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/reverse/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/shifted/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/shifted/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/unzip/*.dhall + dhall-lang/tests/typecheck/success/prelude/List/unzip/*.dhall + dhall-lang/tests/typecheck/success/prelude/Monoid/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/build/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/build/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/even/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/even/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/fold/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/fold/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/isZero/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/isZero/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/odd/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/odd/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/product/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/product/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/show/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/show/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/sum/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/sum/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/*.dhall + dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/all/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/all/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/any/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/any/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/build/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/build/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/concat/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/concat/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/filter/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/filter/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/fold/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/fold/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/head/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/head/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/last/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/last/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/length/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/length/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/map/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/map/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/null/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/null/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/toList/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/toList/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/unzip/*.dhall + dhall-lang/tests/typecheck/success/prelude/Optional/unzip/*.dhall + dhall-lang/tests/typecheck/success/prelude/Text/concat/*.dhall + dhall-lang/tests/typecheck/success/prelude/Text/concat/*.dhall + dhall-lang/tests/typecheck/success/prelude/Text/concatMap/*.dhall + dhall-lang/tests/typecheck/success/prelude/Text/concatMap/*.dhall + dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/*.dhall + dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/*.dhall + dhall-lang/tests/typecheck/success/prelude/Text/concatSep/*.dhall + dhall-lang/tests/typecheck/success/prelude/Text/concatSep/*.dhall + dhall-lang/tests/typecheck/success/simple/access/*.dhall + dhall-lang/tests/typecheck/success/simple/*.dhall tests/format/*.dhall - tests/import/data/fieldOrder/*.dhall - tests/import/data/foo/bar/*.dhall - tests/import/failure/*.dhall - tests/import/success/*.dhall tests/lint/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/multiline/*.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/failure/*.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 @@ -299,7 +374,7 @@ base >= 4.8.2.0 && < 5 , aeson >= 1.0.0.0 && < 1.5 , aeson-pretty < 0.9 , - ansi-terminal >= 0.6.3.1 && < 0.9 , + ansi-terminal >= 0.6.3.1 && < 0.10, bytestring < 0.11, case-insensitive < 1.3 , cborg >= 0.2.0.0 && < 0.3 , @@ -333,9 +408,9 @@ if flag(with-http) Build-Depends: http-types >= 0.7.0 && < 0.13, - http-client >= 0.4.30 && < 0.6 , + http-client >= 0.4.30 && < 0.7 , http-client-tls >= 0.2.0 && < 0.4 - if !impl(ghc >= 8.0) + if !impl(ghc >= 8.0) && !impl(eta >= 0.8.4) Build-Depends: semigroups == 0.18.* Build-Depends: transformers == 0.4.2.* Build-Depends: fail == 4.9.* @@ -374,7 +449,7 @@ Other-Modules: Dhall.Import.HTTP - GHC-Options: -Wall + GHC-Options: -Wall -fwarn-incomplete-uni-patterns Default-Language: Haskell2010 Executable dhall @@ -390,6 +465,7 @@ Main-Is: Dhall/Test/Main.hs GHC-Options: -Wall Other-Modules: + Dhall.Test.Dhall Dhall.Test.Format Dhall.Test.Import Dhall.Test.Lint @@ -402,6 +478,8 @@ Dhall.Test.Util Build-Depends: base >= 4 && < 5 , + bytestring < 0.11, + cborg >= 0.2.0.0 && < 0.3 , containers , deepseq >= 1.2.0.1 && < 1.5 , dhall , diff --git a/doctest/Main.hs b/doctest/Main.hs --- a/doctest/Main.hs +++ b/doctest/Main.hs @@ -3,12 +3,16 @@ import Data.Monoid ((<>)) import System.FilePath (()) +import qualified GHC.IO.Encoding import qualified System.Directory +import qualified System.IO import qualified Test.Mockery.Directory import qualified Test.DocTest main :: IO () main = do + + GHC.IO.Encoding.setLocaleEncoding System.IO.utf8 pwd <- System.Directory.getCurrentDirectory prefix <- System.Directory.makeAbsolute pwd diff --git a/src/Dhall.hs b/src/Dhall.hs --- a/src/Dhall.hs +++ b/src/Dhall.hs @@ -10,6 +10,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TypeOperators #-} +{-# LANGUAGE TupleSections #-} {-| Please read the "Dhall.Tutorial" module, which contains a tutorial explaining how to use the language, the compiler, and this library @@ -39,6 +40,7 @@ -- * Types , Type(..) , RecordType(..) + , UnionType(..) , InputType(..) , Interpret(..) , InvalidType(..) @@ -62,6 +64,8 @@ , pair , record , field + , union + , constructor , GenericInterpret(..) , GenericInject(..) @@ -71,6 +75,11 @@ , inputFieldWith , inputField , inputRecord + , UnionInputType(..) + , inputConstructorWith + , inputConstructor + , inputUnion + , (>|<) -- * Miscellaneous , rawInput @@ -88,12 +97,15 @@ import Control.Applicative (empty, liftA2, (<|>), Alternative) import Control.Exception (Exception) import Control.Monad.Trans.State.Strict -import Data.Functor.Contravariant (Contravariant(..), (>$<)) +import Control.Monad (guard) +import Data.Coerce (coerce) +import Data.Functor.Contravariant (Contravariant(..), (>$<), Op(..)) import Data.Functor.Contravariant.Divisible (Divisible(..), divided) import Data.Monoid ((<>)) import Data.Scientific (Scientific) import Data.Sequence (Seq) import Data.Text (Text) +import Data.Text.Prettyprint.Doc (Pretty) import Data.Typeable (Typeable) import Data.Vector (Vector) import Data.Word (Word8, Word16, Word32, Word64) @@ -114,6 +126,7 @@ import qualified Data.Foldable import qualified Data.Functor.Compose import qualified Data.Functor.Product +import qualified Data.Semigroup import qualified Data.Scientific import qualified Data.Sequence import qualified Data.Set @@ -129,6 +142,7 @@ import qualified Dhall.Parser import qualified Dhall.Pretty.Internal import qualified Dhall.TypeCheck +import qualified Dhall.Util -- $setup -- >>> :set -XOverloadedStrings @@ -144,19 +158,36 @@ This exception indicates that an invalid `Type` was provided to the `input` function -} -data InvalidType = InvalidType deriving (Typeable) +data InvalidType s a = InvalidType + { invalidTypeExpected :: Expr s a + , invalidTypeExpression :: Expr s a + } + deriving (Typeable) _ERROR :: String _ERROR = "\ESC[1;31mError\ESC[0m" -instance Show InvalidType where - show InvalidType = +instance (Pretty s, Pretty a, Typeable s, Typeable a) => Show (InvalidType s a) where + show InvalidType { .. } = _ERROR <> ": Invalid Dhall.Type \n\ \ \n\ \Every Type must provide an extract function that succeeds if an expression \n\ - \matches the expected type. You provided a Type that disobeys this contract \n" + \matches the expected type. You provided a Type that disobeys this contract \n\ + \ \n\ + \The Type provided has the expected dhall type: \n\ + \ \n\ + \" <> show txt0 <> "\n\ + \ \n\ + \and it couldn't extract a value from the well-typed expression: \n\ + \ \n\ + \" <> show txt1 <> "\n\ + \ \n" + where + txt0 = Dhall.Util.insert invalidTypeExpected + txt1 = Dhall.Util.insert invalidTypeExpression + -instance Exception InvalidType +instance (Pretty s, Pretty a, Typeable s, Typeable a) => Exception (InvalidType s a) -- | @since 1.16 data InputSettings = InputSettings @@ -329,9 +360,14 @@ _ -> Annot expr' expected _ <- throws (Dhall.TypeCheck.typeWith (view startingContext settings) annot) - case extract (Dhall.Core.normalizeWith (Dhall.Core.getReifiedNormalizer (view normalizer settings)) expr') of + let normExpr = Dhall.Core.normalizeWith + (Dhall.Core.getReifiedNormalizer + (view normalizer settings)) + expr' + case extract normExpr of Just x -> return x - Nothing -> Control.Exception.throwIO InvalidType + Nothing -> Control.Exception.throwIO + (InvalidType expected expr') {-| Type-check and evaluate a Dhall program that is read from the file-system. @@ -798,7 +834,9 @@ instance (Inject a, Interpret b) => Interpret (a -> b) where autoWith opts = Type extractOut expectedOut where - extractOut e = Just (\i -> case extractIn (Dhall.Core.normalize (App e (embed i))) of + normalizer_ = Dhall.Core.getReifiedNormalizer (inputNormalizer opts) + + extractOut e = Just (\i -> case extractIn (Dhall.Core.normalizeWith normalizer_ (App e (embed i))) of Just o -> o Nothing -> error "Interpret: You cannot decode a function if it does not have the correct type" ) @@ -835,6 +873,10 @@ , constructorModifier :: Text -> Text -- ^ Function used to transform Haskell constructor names into their -- corresponding Dhall alternative names + , inputNormalizer :: Dhall.Core.ReifiedNormalizer X + -- ^ This is only used by the `Interpret` instance for functions in order + -- to normalize the function input before marshaling the input into a + -- Dhall expression } {-| Default interpret options, which you can tweak or override, like this: @@ -846,6 +888,7 @@ defaultInterpretOptions = InterpretOptions { fieldModifier = id , constructorModifier = id + , inputNormalizer = Dhall.Core.ReifiedNormalizer (const (pure Nothing)) } {-| This is the underlying class that powers the `Interpret` class's support @@ -866,6 +909,35 @@ expected = Union mempty +unsafeExpectUnion :: Text -> Expr Src X -> Dhall.Map.Map Text (Expr Src X) +unsafeExpectUnion _ (Union kts) = + kts +unsafeExpectUnion name expression = + Dhall.Core.internalError + (name <> ": Unexpected constructor: " <> Dhall.Core.pretty expression) + +unsafeExpectRecord :: Text -> Expr Src X -> Dhall.Map.Map Text (Expr Src X) +unsafeExpectRecord _ (Record kts) = + kts +unsafeExpectRecord name expression = + Dhall.Core.internalError + (name <> ": Unexpected constructor: " <> Dhall.Core.pretty expression) + +unsafeExpectUnionLit + :: Text -> Expr Src X -> (Text, Expr Src X, Dhall.Map.Map Text (Expr Src X)) +unsafeExpectUnionLit _ (UnionLit k v kts) = + (k, v, kts) +unsafeExpectUnionLit name expression = + Dhall.Core.internalError + (name <> ": Unexpected constructor: " <> Dhall.Core.pretty expression) + +unsafeExpectRecordLit :: Text -> Expr Src X -> Dhall.Map.Map Text (Expr Src X) +unsafeExpectRecordLit _ (RecordLit kvs) = + kvs +unsafeExpectRecordLit name expression = + Dhall.Core.internalError + (name <> ": Unexpected constructor: " <> Dhall.Core.pretty expression) + instance (Constructor c1, Constructor c2, GenericInterpret f1, GenericInterpret f2) => GenericInterpret (M1 C c1 f1 :+: M1 C c2 f2) where genericAutoWith options@(InterpretOptions {..}) = pure (Type {..}) where @@ -904,11 +976,13 @@ extract _ = Nothing expected = - Union (Dhall.Map.insert name expectedR expectedL) + Union (Dhall.Map.insert name expectedR ktsL) - Type extractL (Union expectedL) = evalState (genericAutoWith options) 1 - Type extractR expectedR = evalState (genericAutoWith options) 1 + Type extractL expectedL = evalState (genericAutoWith options) 1 + Type extractR expectedR = evalState (genericAutoWith options) 1 + ktsL = unsafeExpectUnion "genericAutoWith (:+:)" expectedL + instance (Constructor c, GenericInterpret f, GenericInterpret (g :+: h)) => GenericInterpret (M1 C c f :+: (g :+: h)) where genericAutoWith options@(InterpretOptions {..}) = pure (Type {..}) where @@ -923,21 +997,26 @@ extract _ = Nothing expected = - Union (Dhall.Map.insert name expectedL expectedR) + Union (Dhall.Map.insert name expectedL ktsR) - Type extractL expectedL = evalState (genericAutoWith options) 1 - Type extractR (Union expectedR) = evalState (genericAutoWith options) 1 + Type extractL expectedL = evalState (genericAutoWith options) 1 + Type extractR expectedR = evalState (genericAutoWith options) 1 + ktsR = unsafeExpectUnion "genericAutoWith (:+:)" expectedR + instance (GenericInterpret (f :+: g), GenericInterpret (h :+: i)) => GenericInterpret ((f :+: g) :+: (h :+: i)) where genericAutoWith options = pure (Type {..}) where extract e = fmap L1 (extractL e) <|> fmap R1 (extractR e) - expected = Union (Dhall.Map.union expectedL expectedR) + expected = Union (Dhall.Map.union ktsL ktsR) - Type extractL (Union expectedL) = evalState (genericAutoWith options) 1 - Type extractR (Union expectedR) = evalState (genericAutoWith options) 1 + Type extractL expectedL = evalState (genericAutoWith options) 1 + Type extractR expectedR = evalState (genericAutoWith options) 1 + ktsL = unsafeExpectUnion "genericAutoWith (:+:)" expectedL + ktsR = unsafeExpectUnion "genericAutoWith (:+:)" expectedR + instance GenericInterpret f => GenericInterpret (M1 C c f) where genericAutoWith options = do res <- genericAutoWith options @@ -954,8 +1033,8 @@ genericAutoWith options = do Type extractL expectedL <- genericAutoWith options Type extractR expectedR <- genericAutoWith options - let Record ktsL = expectedL - let Record ktsR = expectedR + let ktsL = unsafeExpectRecord "genericAutoWith (:*:)"expectedL + let ktsR = unsafeExpectRecord "genericAutoWith (:*:)"expectedR pure (Type { extract = liftA2 (liftA2 (:*:)) extractL extractR @@ -1195,7 +1274,8 @@ embed (L1 l) = UnionLit keyL valL (Dhall.Map.insert keyR declaredR ktsL') where - UnionLit keyL valL ktsL' = embedL l + (keyL, valL, ktsL') = + unsafeExpectUnionLit "genericInjectWith (:+:)" (embedL l) embed (R1 (M1 r)) = UnionLit keyR (embedR r) ktsL nR :: M1 i c h a @@ -1205,9 +1285,11 @@ declared = Union (Dhall.Map.insert keyR declaredR ktsL) - InputType embedL (Union ktsL) = evalState (genericInjectWith options) 1 - InputType embedR declaredR = evalState (genericInjectWith options) 1 + InputType embedL declaredL = evalState (genericInjectWith options) 1 + InputType embedR declaredR = evalState (genericInjectWith options) 1 + ktsL = unsafeExpectUnion "genericInjectWith (:+:)" declaredL + instance (Constructor c, GenericInject f, GenericInject (g :+: h)) => GenericInject (M1 C c f :+: (g :+: h)) where genericInjectWith options@(InterpretOptions {..}) = pure (InputType {..}) where @@ -1215,7 +1297,8 @@ embed (R1 r) = UnionLit keyR valR (Dhall.Map.insert keyL declaredL ktsR') where - UnionLit keyR valR ktsR' = embedR r + (keyR, valR, ktsR') = + unsafeExpectUnionLit "genericInjectWith (:+:)" (embedR r) nL :: M1 i c f a nL = undefined @@ -1224,26 +1307,33 @@ declared = Union (Dhall.Map.insert keyL declaredL ktsR) - InputType embedL declaredL = evalState (genericInjectWith options) 1 - InputType embedR (Union ktsR) = evalState (genericInjectWith options) 1 + InputType embedL declaredL = evalState (genericInjectWith options) 1 + InputType embedR declaredR = evalState (genericInjectWith options) 1 + ktsR = unsafeExpectUnion "genericInjectWith (:+:)" declaredR + instance (GenericInject (f :+: g), GenericInject (h :+: i)) => GenericInject ((f :+: g) :+: (h :+: i)) where genericInjectWith options = pure (InputType {..}) where embed (L1 l) = - UnionLit keyL valR (Dhall.Map.union ktsL' ktsR) + UnionLit keyL valL (Dhall.Map.union ktsL' ktsR) where - UnionLit keyL valR ktsL' = embedL l + (keyL, valL, ktsL') = + unsafeExpectUnionLit "genericInjectWith (:+:)" (embedL l) embed (R1 r) = UnionLit keyR valR (Dhall.Map.union ktsL ktsR') where - UnionLit keyR valR ktsR' = embedR r + (keyR, valR, ktsR') = + unsafeExpectUnionLit "genericInjectWith (:+:)" (embedR r) declared = Union (Dhall.Map.union ktsL ktsR) - InputType embedL (Union ktsL) = evalState (genericInjectWith options) 1 - InputType embedR (Union ktsR) = evalState (genericInjectWith options) 1 + InputType embedL declaredL = evalState (genericInjectWith options) 1 + InputType embedR declaredR = evalState (genericInjectWith options) 1 + ktsL = unsafeExpectUnion "genericInjectWith (:+:)" declaredL + ktsR = unsafeExpectUnion "genericInjectWith (:+:)" declaredR + instance (GenericInject f, GenericInject g) => GenericInject (f :*: g) where genericInjectWith options = do InputType embedInL declaredInL <- genericInjectWith options @@ -1252,13 +1342,16 @@ let embed (l :*: r) = RecordLit (Dhall.Map.union mapL mapR) where - RecordLit mapL = embedInL l - RecordLit mapR = embedInR r + mapL = + unsafeExpectRecordLit "genericInjectWith (:*:)" (embedInL l) + mapR = + unsafeExpectRecordLit "genericInjectWith (:*:)" (embedInR r) + let declared = Record (Dhall.Map.union mapL mapR) where - Record mapL = declaredInL - Record mapR = declaredInR + mapL = unsafeExpectRecord "genericInjectWith (:*:)" declaredInL + mapR = unsafeExpectRecord "genericInjectWith (:*:)" declaredInR pure (InputType {..}) @@ -1371,6 +1464,67 @@ ( Data.Functor.Compose.Compose extractBody ) ) +{-| The 'UnionType' monoid allows you to build a 'Type' parser + from a Dhall union + + For example, let's take the following Haskell data type: + +> data Status = Queued Natural +> | Result Text +> | Errored Text + + And assume that we have the following Dhall union that we would like to + parse as a @Status@: + +> < Result = "Finish succesfully" +> | Queued : Natural +> | Errored : Text +> > + + Our parser has type 'Type' @Status@, but we can't build that out of any + smaller parsers, as 'Type's cannot be combined (they are only 'Functor's). + However, we can use a 'UnionType' to build a 'Type' for @Status@: + +> status :: Type Status +> status = +> union +> ( Queued <$> constructor "Queued" natural +> <> Result <$> constructor "Result" string +> <> Errored <$> constructor "Errored" string +> ) + +-} +newtype UnionType a = + UnionType + ( Data.Functor.Compose.Compose (Dhall.Map.Map Text) Type a ) + deriving (Functor) + +instance Data.Semigroup.Semigroup (UnionType a) where + (<>) = coerce ((<>) :: Dhall.Map.Map Text (Type a) -> Dhall.Map.Map Text (Type a) -> Dhall.Map.Map Text (Type a)) + +instance Monoid (UnionType a) where + mempty = coerce (mempty :: Dhall.Map.Map Text (Type a)) + mappend = (Data.Semigroup.<>) + +-- | Run a 'UnionType' parser to build a 'Type' parser. +union :: UnionType a -> Type a +union (UnionType (Data.Functor.Compose.Compose mp)) = Type + { extract = extractF + , expected = Union expect + } + where + expect = Dhall.expected <$> mp + extractF e0 = do + UnionLit fld e1 rest <- Just e0 + t <- Dhall.Map.lookup fld mp + guard $ rest == Dhall.Map.delete fld expect + Dhall.extract t e1 + +-- | Parse a single constructor of a union +constructor :: Text -> Type a -> UnionType a +constructor key valueType = UnionType + ( Data.Functor.Compose.Compose (Dhall.Map.singleton key valueType) ) + {-| The 'RecordInputType' divisible (contravariant) functor allows you to build an 'InputType' injector for a Dhall record. @@ -1453,4 +1607,109 @@ recordType = Record $ declared <$> inputTypeRecord makeRecordLit x = RecordLit $ (($ x) . embed) <$> inputTypeRecord +{-| The 'UnionInputType' monoid allows you to build + an 'InputType' injector for a Dhall record. + For example, let's take the following Haskell data type: + +> data Status = Queued Natural +> | Result Text +> | Errored Text + + And assume that we have the following Dhall union that we would like to + parse as a @Status@: + +> < Result = "Finish succesfully" +> | Queued : Natural +> | Errored : Text +> > + + Our injector has type 'InputType' @Status@, but we can't build that out of any + smaller injectors, as 'InputType's cannot be combined. + However, we can use an 'InputUnionType' to build an 'InputType' for @Status@: + +> injectStatus :: InputType Status +> injectStatus = +> adapt +> >$< inputConstructorWith "Queued" inject +> >|< inputConstructorWith "Result" inject +> >|< inputConstructorWith "Errored" inject +> where +> adapt (Queued n) = Left (Left n) +> adapt (Result t) = Left (Right t) +> adapt (Errored e) = Right e + + Or, since we are simply using the `Inject` instance to inject each branch, we could write + +> injectStatus :: InputType Status +> injectStatus = +> adapt +> >$< inputConstructor "Queued" +> >|< inputConstructor "Result" +> >|< inputConstructor "Errored" +> where +> adapt (Queued n) = Left (Left n) +> adapt (Result t) = Left (Right t) +> adapt (Errored e) = Right e +-} +newtype UnionInputType a = + UnionInputType + ( Data.Functor.Product.Product + ( Control.Applicative.Const + ( Dhall.Map.Map + Text + ( Expr Src X ) + ) + ) + ( Op (Text, Expr Src X) ) + a + ) + deriving (Contravariant) + +-- | Combines two 'UnionInputType' values. See 'UnionInputType' for usage +-- notes. +-- +-- Ideally, this matches 'Data.Functor.Contravariant.Divisible.chosen'; +-- however, this allows 'UnionInputType' to not need a 'Divisible' instance +-- itself (since no instance is possible). +(>|<) :: UnionInputType a -> UnionInputType b -> UnionInputType (Either a b) +UnionInputType (Data.Functor.Product.Pair (Control.Applicative.Const mx) (Op fx)) + >|< UnionInputType (Data.Functor.Product.Pair (Control.Applicative.Const my) (Op fy)) = + UnionInputType + ( Data.Functor.Product.Pair + ( Control.Applicative.Const (mx <> my) ) + ( Op (either fx fy) ) + ) + +infixr 5 >|< + +inputUnion :: UnionInputType a -> InputType a +inputUnion ( UnionInputType ( Data.Functor.Product.Pair ( Control.Applicative.Const fields ) ( Op embedF ) ) ) = + InputType + { embed = \x -> + let (name, y) = embedF x + in UnionLit name y (Dhall.Map.delete name fields) + , declared = + Union fields + } + +inputConstructorWith + :: Text + -> InputType a + -> UnionInputType a +inputConstructorWith name inputType = UnionInputType $ + Data.Functor.Product.Pair + ( Control.Applicative.Const + ( Dhall.Map.singleton + name + ( declared inputType ) + ) + ) + ( Op ( (name,) . embed inputType ) + ) + +inputConstructor + :: Inject a + => Text + -> UnionInputType a +inputConstructor name = inputConstructorWith name inject diff --git a/src/Dhall/Binary.hs b/src/Dhall/Binary.hs --- a/src/Dhall/Binary.hs +++ b/src/Dhall/Binary.hs @@ -11,17 +11,18 @@ StandardVersion(..) , defaultStandardVersion , parseStandardVersion + , renderStandardVersion -- * Encoding and decoding - , encodeWithVersion - , decodeWithVersion + , encode + , decode -- * Exceptions , DecodingFailure(..) ) where import Codec.CBOR.Term (Term(..)) -import Control.Applicative (empty) +import Control.Applicative (empty, (<|>)) import Control.Exception (Exception) import Dhall.Core ( Binding(..) @@ -48,7 +49,6 @@ import Options.Applicative (Parser) import Prelude hiding (exponent) import GHC.Float (double2Float, float2Double) -import Codec.CBOR.Magic (floatToWord16, wordToFloat16) import qualified Crypto.Hash import qualified Data.ByteArray.Encoding @@ -62,11 +62,22 @@ -- | Supported version strings data StandardVersion - = V_5_0_0 + = NoVersion + -- ^ No version string + | V_5_0_0 -- ^ Version "5.0.0" + | V_4_0_0 + -- ^ Version "4.0.0" + | V_3_0_0 + -- ^ Version "3.0.0" + | V_2_0_0 + -- ^ Version "2.0.0" + | V_1_0_0 + -- ^ Version "1.0.0" + deriving (Enum, Bounded) defaultStandardVersion :: StandardVersion -defaultStandardVersion = V_5_0_0 +defaultStandardVersion = NoVersion parseStandardVersion :: Parser StandardVersion parseStandardVersion = @@ -80,9 +91,22 @@ readVersion = do string <- Options.Applicative.str case string :: Text of + "none" -> return NoVersion + "1.0.0" -> return V_1_0_0 + "2.0.0" -> return V_2_0_0 + "3.0.0" -> return V_3_0_0 + "4.0.0" -> return V_4_0_0 "5.0.0" -> return V_5_0_0 _ -> fail "Unsupported version" +renderStandardVersion :: StandardVersion -> Text +renderStandardVersion NoVersion = "none" +renderStandardVersion V_1_0_0 = "1.0.0" +renderStandardVersion V_2_0_0 = "2.0.0" +renderStandardVersion V_3_0_0 = "3.0.0" +renderStandardVersion V_4_0_0 = "4.0.0" +renderStandardVersion V_5_0_0 = "5.0.0" + {-| Convert a function applied to multiple arguments to the base function and the list of arguments -} @@ -96,6 +120,7 @@ ~(baseFunction, diffArguments) = go f go baseFunction = (baseFunction, id) +-- | Encode a Dhall expression to a CBOR `Term` encode :: Expr s Import -> Term encode (Var (V "_" n)) = TInteger n @@ -155,6 +180,8 @@ TString "Double" encode Text = TString "Text" +encode TextShow = + TString "Text/show" encode List = TString "List" encode (Const Type) = @@ -286,7 +313,7 @@ TList [ TInt 7, TMap xTs₁ ] where xTs₁ = do - (x₀, _T₀) <- Dhall.Map.toList xTs₀ + (x₀, _T₀) <- Dhall.Map.toList (Dhall.Map.sort xTs₀) let x₁ = TString x₀ let _T₁ = encode _T₀ return (x₁, _T₁) @@ -294,7 +321,7 @@ TList [ TInt 8, TMap xts₁ ] where xts₁ = do - (x₀, t₀) <- Dhall.Map.toList xts₀ + (x₀, t₀) <- Dhall.Map.toList (Dhall.Map.sort xts₀) let x₁ = TString x₀ let t₁ = encode t₀ return (x₁, t₁) @@ -311,7 +338,7 @@ TList [ TInt 11, TMap xTs₁ ] where xTs₁ = do - (x₀, _T₀) <- Dhall.Map.toList xTs₀ + (x₀, _T₀) <- Dhall.Map.toList (Dhall.Map.sort xTs₀) let x₁ = TString x₀ let _T₁ = encode _T₀ return (x₁, _T₁) @@ -321,14 +348,10 @@ t₁ = encode t₀ yTs₁ = do - (y₀, _T₀) <- Dhall.Map.toList yTs₀ + (y₀, _T₀) <- Dhall.Map.toList (Dhall.Map.sort yTs₀) let y₁ = TString y₀ let _T₁ = encode _T₀ return (y₁, _T₁) -encode (Constructors u₀) = - TList [ TInt 13, u₁ ] - where - u₁ = encode u₀ encode (BoolLit b) = TBool b encode (BoolIf t₀ l₀ r₀) = @@ -349,9 +372,10 @@ | otherwise = TDouble n64 where n32 = double2Float n64 - n16 = floatToWord16 n32 useFloat = n64 == float2Double n32 - useHalf = n64 == (float2Double . wordToFloat16 . fromIntegral) n16 + -- the other three cases for Half-floats are 0.0 and the infinities + useHalf = or $ fmap (n64 ==) [0.0, infinity, -infinity] + infinity = 1/0 :: Double encode (TextLit (Chunks xys₀ z₀)) = TList ([ TInt 18 ] ++ xys₁ ++ [ z₁ ]) where @@ -455,100 +479,102 @@ ImportHashed {..} = importHashed -decode :: Term -> Maybe (Expr s Import) -decode (TInt n) = +decodeMaybe :: Term -> Maybe (Expr s Import) +decodeMaybe (TInt n) = return (Var (V "_" (fromIntegral n))) -decode (TInteger n) = +decodeMaybe (TInteger n) = return (Var (V "_" n)) -decode (TString "Natural/build") = +decodeMaybe (TString "Natural/build") = return NaturalBuild -decode (TString "Natural/fold") = +decodeMaybe (TString "Natural/fold") = return NaturalFold -decode (TString "Natural/isZero") = +decodeMaybe (TString "Natural/isZero") = return NaturalIsZero -decode (TString "Natural/even") = +decodeMaybe (TString "Natural/even") = return NaturalEven -decode (TString "Natural/odd") = +decodeMaybe (TString "Natural/odd") = return NaturalOdd -decode (TString "Natural/toInteger") = +decodeMaybe (TString "Natural/toInteger") = return NaturalToInteger -decode (TString "Natural/show") = +decodeMaybe (TString "Natural/show") = return NaturalShow -decode (TString "Integer/toDouble") = +decodeMaybe (TString "Integer/toDouble") = return IntegerToDouble -decode (TString "Integer/show") = +decodeMaybe (TString "Integer/show") = return IntegerShow -decode (TString "Double/show") = +decodeMaybe (TString "Double/show") = return DoubleShow -decode (TString "List/build") = +decodeMaybe (TString "List/build") = return ListBuild -decode (TString "List/fold") = +decodeMaybe (TString "List/fold") = return ListFold -decode (TString "List/length") = +decodeMaybe (TString "List/length") = return ListLength -decode (TString "List/head") = +decodeMaybe (TString "List/head") = return ListHead -decode (TString "List/last") = +decodeMaybe (TString "List/last") = return ListLast -decode (TString "List/indexed") = +decodeMaybe (TString "List/indexed") = return ListIndexed -decode (TString "List/reverse") = +decodeMaybe (TString "List/reverse") = return ListReverse -decode (TString "Optional/fold") = +decodeMaybe (TString "Optional/fold") = return OptionalFold -decode (TString "Optional/build") = +decodeMaybe (TString "Optional/build") = return OptionalBuild -decode (TString "Bool") = +decodeMaybe (TString "Bool") = return Bool -decode (TString "Optional") = +decodeMaybe (TString "Optional") = return Optional -decode (TString "None") = +decodeMaybe (TString "None") = return None -decode (TString "Natural") = +decodeMaybe (TString "Natural") = return Natural -decode (TString "Integer") = +decodeMaybe (TString "Integer") = return Integer -decode (TString "Double") = +decodeMaybe (TString "Double") = return Double -decode (TString "Text") = +decodeMaybe (TString "Text") = return Text -decode (TString "List") = +decodeMaybe (TString "Text/show") = + return TextShow +decodeMaybe (TString "List") = return List -decode (TString "Type") = +decodeMaybe (TString "Type") = return (Const Type) -decode (TString "Kind") = +decodeMaybe (TString "Kind") = return (Const Kind) -decode (TString "Sort") = +decodeMaybe (TString "Sort") = return (Const Sort) -decode (TString x) = +decodeMaybe (TString x) = return (Var (V x 0)) -decode (TList [ TString x, TInt n ]) = +decodeMaybe (TList [ TString x, TInt n ]) = return (Var (V x (fromIntegral n))) -decode (TList [ TString x, TInteger n ]) = +decodeMaybe (TList [ TString x, TInteger n ]) = return (Var (V x n)) -decode (TList (TInt 0 : f₁ : xs₁)) = do - f₀ <- decode f₁ - xs₀ <- traverse decode xs₁ +decodeMaybe (TList (TInt 0 : f₁ : xs₁)) = do + f₀ <- decodeMaybe f₁ + xs₀ <- traverse decodeMaybe xs₁ return (foldl App f₀ xs₀) -decode (TList [ TInt 1, _A₁, b₁ ]) = do - _A₀ <- decode _A₁ - b₀ <- decode b₁ +decodeMaybe (TList [ TInt 1, _A₁, b₁ ]) = do + _A₀ <- decodeMaybe _A₁ + b₀ <- decodeMaybe b₁ return (Lam "_" _A₀ b₀) -decode (TList [ TInt 1, TString x, _A₁, b₁ ]) = do - _A₀ <- decode _A₁ - b₀ <- decode b₁ +decodeMaybe (TList [ TInt 1, TString x, _A₁, b₁ ]) = do + _A₀ <- decodeMaybe _A₁ + b₀ <- decodeMaybe b₁ return (Lam x _A₀ b₀) -decode (TList [ TInt 2, _A₁, _B₁ ]) = do - _A₀ <- decode _A₁ - _B₀ <- decode _B₁ +decodeMaybe (TList [ TInt 2, _A₁, _B₁ ]) = do + _A₀ <- decodeMaybe _A₁ + _B₀ <- decodeMaybe _B₁ return (Pi "_" _A₀ _B₀) -decode (TList [ TInt 2, TString x, _A₁, _B₁ ]) = do - _A₀ <- decode _A₁ - _B₀ <- decode _B₁ +decodeMaybe (TList [ TInt 2, TString x, _A₁, _B₁ ]) = do + _A₀ <- decodeMaybe _A₁ + _B₀ <- decodeMaybe _B₁ return (Pi x _A₀ _B₀) -decode (TList [ TInt 3, TInt n, l₁, r₁ ]) = do - l₀ <- decode l₁ - r₀ <- decode r₁ +decodeMaybe (TList [ TInt 3, TInt n, l₁, r₁ ]) = do + l₀ <- decodeMaybe l₁ + r₀ <- decodeMaybe r₁ op <- case n of 0 -> return BoolOr 1 -> return BoolAnd @@ -564,34 +590,34 @@ 11 -> return ImportAlt _ -> empty return (op l₀ r₀) -decode (TList [ TInt 4, _T₁ ]) = do - _T₀ <- decode _T₁ +decodeMaybe (TList [ TInt 4, _T₁ ]) = do + _T₀ <- decodeMaybe _T₁ return (ListLit (Just _T₀) empty) -decode (TList (TInt 4 : TNull : xs₁ )) = do - xs₀ <- traverse decode xs₁ +decodeMaybe (TList (TInt 4 : TNull : xs₁ )) = do + xs₀ <- traverse decodeMaybe xs₁ return (ListLit Nothing (Data.Sequence.fromList xs₀)) -decode (TList [ TInt 5, _T₁ ]) = do - _T₀ <- decode _T₁ +decodeMaybe (TList [ TInt 5, _T₁ ]) = do + _T₀ <- decodeMaybe _T₁ return (OptionalLit _T₀ Nothing) -decode (TList [ TInt 5, TNull, t₁ ]) = do - t₀ <- decode t₁ +decodeMaybe (TList [ TInt 5, TNull, t₁ ]) = do + t₀ <- decodeMaybe t₁ return (Some t₀) -decode (TList [ TInt 5, _T₁, t₁ ]) = do - _T₀ <- decode _T₁ - t₀ <- decode t₁ +decodeMaybe (TList [ TInt 5, _T₁, t₁ ]) = do + _T₀ <- decodeMaybe _T₁ + t₀ <- decodeMaybe t₁ return (OptionalLit _T₀ (Just t₀)) -decode (TList [ TInt 6, t₁, u₁ ]) = do - t₀ <- decode t₁ - u₀ <- decode u₁ +decodeMaybe (TList [ TInt 6, t₁, u₁ ]) = do + t₀ <- decodeMaybe t₁ + u₀ <- decodeMaybe u₁ return (Merge t₀ u₀ Nothing) -decode (TList [ TInt 6, t₁, u₁, _T₁ ]) = do - t₀ <- decode t₁ - u₀ <- decode u₁ - _T₀ <- decode _T₁ +decodeMaybe (TList [ TInt 6, t₁, u₁, _T₁ ]) = do + t₀ <- decodeMaybe t₁ + u₀ <- decodeMaybe u₁ + _T₀ <- decodeMaybe _T₁ return (Merge t₀ u₀ (Just _T₀)) -decode (TList [ TInt 7, TMap xTs₁ ]) = do +decodeMaybe (TList [ TInt 7, TMap xTs₁ ]) = do let process (TString x, _T₁) = do - _T₀ <- decode _T₁ + _T₀ <- decodeMaybe _T₁ return (x, _T₀) process _ = @@ -600,9 +626,9 @@ xTs₀ <- traverse process xTs₁ return (Record (Dhall.Map.fromList xTs₀)) -decode (TList [ TInt 8, TMap xts₁ ]) = do +decodeMaybe (TList [ TInt 8, TMap xts₁ ]) = do let process (TString x, t₁) = do - t₀ <- decode t₁ + t₀ <- decodeMaybe t₁ return (x, t₀) process _ = @@ -611,12 +637,12 @@ xts₀ <- traverse process xts₁ return (RecordLit (Dhall.Map.fromList xts₀)) -decode (TList [ TInt 9, t₁, TString x ]) = do - t₀ <- decode t₁ +decodeMaybe (TList [ TInt 9, t₁, TString x ]) = do + t₀ <- decodeMaybe t₁ return (Field t₀ x) -decode (TList (TInt 10 : t₁ : xs₁)) = do - t₀ <- decode t₁ +decodeMaybe (TList (TInt 10 : t₁ : xs₁)) = do + t₀ <- decodeMaybe t₁ let process (TString x) = return x process _ = empty @@ -624,9 +650,9 @@ xs₀ <- traverse process xs₁ return (Project t₀ (Dhall.Set.fromList xs₀)) -decode (TList [ TInt 11, TMap xTs₁ ]) = do +decodeMaybe (TList [ TInt 11, TMap xTs₁ ]) = do let process (TString x, _T₁) = do - _T₀ <- decode _T₁ + _T₀ <- decodeMaybe _T₁ return (x, _T₀) process _ = @@ -635,11 +661,11 @@ xTs₀ <- traverse process xTs₁ return (Union (Dhall.Map.fromList xTs₀)) -decode (TList [ TInt 12, TString x, t₁, TMap yTs₁ ]) = do - t₀ <- decode t₁ +decodeMaybe (TList [ TInt 12, TString x, t₁, TMap yTs₁ ]) = do + t₀ <- decodeMaybe t₁ let process (TString y, _T₁) = do - _T₀ <- decode _T₁ + _T₀ <- decodeMaybe _T₁ return (y, _T₀) process _ = @@ -648,35 +674,31 @@ yTs₀ <- traverse process yTs₁ return (UnionLit x t₀ (Dhall.Map.fromList yTs₀)) -decode (TList [ TInt 13, u₁ ]) = do - u₀ <- decode u₁ - - return (Constructors u₀) -decode (TBool b) = do +decodeMaybe (TBool b) = do return (BoolLit b) -decode (TList [ TInt 14, t₁, l₁, r₁ ]) = do - t₀ <- decode t₁ - l₀ <- decode l₁ - r₀ <- decode r₁ +decodeMaybe (TList [ TInt 14, t₁, l₁, r₁ ]) = do + t₀ <- decodeMaybe t₁ + l₀ <- decodeMaybe l₁ + r₀ <- decodeMaybe r₁ return (BoolIf t₀ l₀ r₀) -decode (TList [ TInt 15, TInt n ]) = do +decodeMaybe (TList [ TInt 15, TInt n ]) = do return (NaturalLit (fromIntegral n)) -decode (TList [ TInt 15, TInteger n ]) = do +decodeMaybe (TList [ TInt 15, TInteger n ]) = do return (NaturalLit (fromInteger n)) -decode (TList [ TInt 16, TInt n ]) = do +decodeMaybe (TList [ TInt 16, TInt n ]) = do return (IntegerLit (fromIntegral n)) -decode (TList [ TInt 16, TInteger n ]) = do +decodeMaybe (TList [ TInt 16, TInteger n ]) = do return (IntegerLit n) -decode (THalf n) = do +decodeMaybe (THalf n) = do return (DoubleLit (float2Double n)) -decode (TFloat n) = do +decodeMaybe (TFloat n) = do return (DoubleLit (float2Double n)) -decode (TDouble n) = do +decodeMaybe (TDouble n) = do return (DoubleLit n) -decode (TList (TInt 18 : xs)) = do +decodeMaybe (TList (TInt 18 : xs)) = do let process (TString x : y₁ : zs) = do - y₀ <- decode y₁ + y₀ <- decodeMaybe y₁ ~(xys, z) <- process zs @@ -689,7 +711,7 @@ (xys, z) <- process xs return (TextLit (Chunks xys z)) -decode (TList (TInt 24 : h : TInt mode : TInt n : xs)) = do +decodeMaybe (TList (TInt 24 : h : TInt mode : TInt n : xs)) = do hash <- case h of TNull -> do return Nothing @@ -733,7 +755,7 @@ headers₁ <- case headers₀ of TNull -> return Nothing _ -> do - Embed (Import { importHashed = headers }) <- decode headers₀ + Embed (Import { importHashed = headers }) <- decodeMaybe headers₀ return (Just headers) (paths, file, query, fragment) <- process ys return (headers₁, authority, paths, file, query, fragment) @@ -783,19 +805,19 @@ let importHashed = ImportHashed {..} return (Embed (Import {..})) -decode (TList (TInt 25 : xs)) = do +decodeMaybe (TList (TInt 25 : xs)) = do let process (TString x : _A₁ : a₁ : ls₁) = do mA₀ <- case _A₁ of TNull -> return Nothing - _ -> fmap Just (decode _A₁) + _ -> fmap Just (decodeMaybe _A₁) - a₀ <- decode a₁ + a₀ <- decodeMaybe a₁ let binding = Binding x mA₀ a₀ case ls₁ of [ b₁ ] -> do - b₀ <- decode b₁ + b₀ <- decodeMaybe b₁ return (Let (binding :| []) b₀) _ -> do @@ -806,47 +828,30 @@ empty process xs -decode (TList [ TInt 26, t₁, _T₁ ]) = do - t₀ <- decode t₁ - _T₀ <- decode _T₁ +decodeMaybe (TList [ TInt 26, t₁, _T₁ ]) = do + t₀ <- decodeMaybe t₁ + _T₀ <- decodeMaybe _T₁ return (Annot t₀ _T₀) -decode _ = +decodeMaybe _ = empty -{-| Decode a Dhall expression - - This auto-detects which standard version to decode based on the included - standard version string in the decoded expression --} -decodeWithVersion :: Term -> Either DecodingFailure (Expr s Import) -decodeWithVersion term = do - (version, subTerm) <- case term of - TList [ TString version, subTerm ] -> - return (version, subTerm) - _ -> - fail ("Cannot decode the version from this decoded CBOR expression: " <> show term) - - case version of - "5.0.0" -> do - return () - _ -> do - fail ("This decoded version is not supported: " <> Data.Text.unpack version) - - case decode subTerm of - Nothing -> - fail ("This decoded CBOR expression does not represent a valid Dhall expression: " <> show subTerm) - Just expression -> - return expression +-- | Decode a Dhall expression from a CBOR `Term` +decode :: Term -> Either DecodingFailure (Expr s Import) +decode term = + case decodeWithoutVersion <|> decodeWithVersion of + Just expression -> Right expression + Nothing -> Left (CBORIsNotDhall term) + where + -- This is the behavior specified by the standard + decodeWithoutVersion = decodeMaybe term --- | Encode a Dhall expression using the specified `Version` -encodeWithVersion :: StandardVersion -> Expr s Import -> Term -encodeWithVersion V_5_0_0 expression = - TList [ TString "5.0.0", encode expression ] + -- For backwards compatibility with older expressions that have a version + -- tag to ease the migration + decodeWithVersion = do + TList [ TString _, taggedTerm ] <- return term + decodeMaybe taggedTerm -data DecodingFailure - = CannotDecodeVersionString Term - | UnsupportedVersionString Text - | CBORIsNotDhall Term +data DecodingFailure = CBORIsNotDhall Term deriving (Eq) instance Exception DecodingFailure @@ -855,25 +860,6 @@ _ERROR = "\ESC[1;31mError\ESC[0m" instance Show DecodingFailure where - show (CannotDecodeVersionString term) = - _ERROR <> ": Cannot decode version string\n" - <> "\n" - <> "This CBOR expression does not contain a version string in any\n" - <> "recognizable format\n" - <> "\n" - <> "↳ " <> show term <> "\n" - show (UnsupportedVersionString version) = - _ERROR <> ": Unsupported version string\n" - <> "\n" - <> "The encoded Dhall expression was tagged with a version string of:\n" - <> "\n" - <> "↳ " <> show version <> "\n" - <> "\n" - <> "... but this implementation cannot decode that version\n" - <> "\n" - <> "Some common reasons why you might get this error:\n" - <> "\n" - <> "● You are using an old version of the interpreter and need to upgrade\n" show (CBORIsNotDhall term) = _ERROR <> ": Cannot decode CBOR to Dhall\n" <> "\n" diff --git a/src/Dhall/Core.hs b/src/Dhall/Core.hs --- a/src/Dhall/Core.hs +++ b/src/Dhall/Core.hs @@ -87,12 +87,14 @@ import qualified Control.Monad import qualified Crypto.Hash +import qualified Data.Char import qualified Data.HashSet import qualified Data.Sequence import qualified Data.Text import qualified Data.Text.Prettyprint.Doc as Pretty import qualified Dhall.Map import qualified Dhall.Set +import qualified Text.Printf {-| Constants for a pure type system @@ -405,6 +407,8 @@ | TextLit (Chunks s a) -- | > TextAppend x y ~ x ++ y | TextAppend (Expr s a) (Expr s a) + -- | > TextShow ~ Text/show + | TextShow -- | > List ~ List | List -- | > ListLit (Just t ) [x, y, z] ~ [x, y, z] : List t @@ -456,8 +460,6 @@ -- | > Merge x y (Just t ) ~ merge x y : t -- > Merge x y Nothing ~ merge x y | Merge (Expr s a) (Expr s a) (Maybe (Expr s a)) - -- | > Constructors e ~ constructors e - | Constructors (Expr s a) -- | > Field e x ~ e.x | Field (Expr s a) Text -- | > Project e xs ~ e.{ xs } @@ -510,6 +512,7 @@ fmap _ Text = Text fmap f (TextLit cs) = TextLit (fmap f cs) fmap f (TextAppend e1 e2) = TextAppend (fmap f e1) (fmap f e2) + fmap _ TextShow = TextShow fmap _ List = List fmap f (ListLit maybeE seqE) = ListLit (fmap (fmap f) maybeE) (fmap (fmap f) seqE) fmap f (ListAppend e1 e2) = ListAppend (fmap f e1) (fmap f e2) @@ -534,7 +537,6 @@ fmap f (CombineTypes e1 e2) = CombineTypes (fmap f e1) (fmap f e2) fmap f (Prefer e1 e2) = Prefer (fmap f e1) (fmap f e2) fmap f (Merge e1 e2 maybeE) = Merge (fmap f e1) (fmap f e2) (fmap (fmap f) maybeE) - fmap f (Constructors e1) = Constructors (fmap f e1) fmap f (Field e1 v) = Field (fmap f e1) v fmap f (Project e1 vs) = Project (fmap f e1) vs fmap f (Note s e1) = Note s (fmap f e1) @@ -587,6 +589,7 @@ Text >>= _ = Text TextLit (Chunks a b) >>= k = TextLit (Chunks (fmap (fmap (>>= k)) a) b) TextAppend a b >>= k = TextAppend (a >>= k) (b >>= k) + TextShow >>= _ = TextShow List >>= _ = List ListLit a b >>= k = ListLit (fmap (>>= k) a) (fmap (>>= k) b) ListAppend a b >>= k = ListAppend (a >>= k) (b >>= k) @@ -611,7 +614,6 @@ CombineTypes a b >>= k = CombineTypes (a >>= k) (b >>= k) Prefer a b >>= k = Prefer (a >>= k) (b >>= k) Merge a b c >>= k = Merge (a >>= k) (b >>= k) (fmap (>>= k) c) - Constructors a >>= k = Constructors (a >>= k) Field a b >>= k = Field (a >>= k) b Project a b >>= k = Project (a >>= k) b Note a b >>= k = Note a (b >>= k) @@ -654,6 +656,7 @@ first _ Text = Text first k (TextLit (Chunks a b)) = TextLit (Chunks (fmap (fmap (first k)) a) b) first k (TextAppend a b ) = TextAppend (first k a) (first k b) + first _ TextShow = TextShow first _ List = List first k (ListLit a b ) = ListLit (fmap (first k) a) (fmap (first k) b) first k (ListAppend a b ) = ListAppend (first k a) (first k b) @@ -678,7 +681,6 @@ first k (CombineTypes a b ) = CombineTypes (first k a) (first k b) first k (Prefer a b ) = Prefer (first k a) (first k b) first k (Merge a b c ) = Merge (first k a) (first k b) (fmap (first k) c) - first k (Constructors a ) = Constructors (first k a) first k (Field a b ) = Field (first k a) b first k (Project a b ) = Project (first k a) b first k (Note a b ) = Note (k a) (first k b) @@ -828,14 +830,15 @@ 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₁ + case shift d (V x₀ n₁) (Let (l₀ :| ls₀) b₀) of + Let (l₁ :| ls₁) b₁ -> Let (Binding x₁ mA₁ a₁ :| (l₁ : ls₁)) b₁ + e -> Let (Binding x₁ mA₁ a₁ :| [] ) e 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 @@ -895,6 +898,7 @@ where a' = shift d v a b' = shift d v b +shift _ _ TextShow = TextShow shift _ _ List = List shift d v (ListLit a b) = ListLit a' b' where @@ -952,9 +956,6 @@ a' = shift d v a b' = shift d v b c' = fmap (shift d v) c -shift d v (Constructors a) = Constructors a' - where - a' = shift d v a shift d v (Field a b) = Field a' b where a' = shift d v a @@ -1005,7 +1006,9 @@ 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₁ + case subst (V x₀ n₁) e₁ (Let (l₀ :| ls₀) b₀) of + Let (l₁ :| ls₁) b₁ -> Let (Binding x₁ mA₁ a₁ :| (l₁ : ls₁)) b₁ + e -> Let (Binding x₁ mA₁ a₁ :| [] ) e where n₁ = if x₀ == x₁ then n₀ + 1 else n₀ @@ -1014,7 +1017,6 @@ 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 @@ -1074,6 +1076,7 @@ where a' = subst x e a b' = subst x e b +subst _ _ TextShow = TextShow subst _ _ List = List subst x e (ListLit a b) = ListLit a' b' where @@ -1122,9 +1125,6 @@ a' = subst x e a b' = subst x e b c' = fmap (subst x e) c -subst x e (Constructors a) = Constructors a' - where - a' = subst x e a subst x e (Field a b) = Field a' b where a' = subst x e a @@ -1201,12 +1201,12 @@ b₁ = alphaNormalize b₀ alphaNormalize (Let (Binding "_" mA₀ a₀ :| (l₀ : ls₀)) b₀) = - Let (Binding "_" mA₁ a₁ :| (l₁ : ls₁)) b₁ + case alphaNormalize (Let (l₀ :| ls₀) b₀) of + Let (l₁ :| ls₁) b₁ -> Let (Binding "_" mA₁ a₁ :| (l₁ : ls₁)) b₁ + e -> Let (Binding "_" mA₁ a₁ :| [] ) e 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 @@ -1218,7 +1218,9 @@ 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₄ + case alphaNormalize (Let (l₀ :| ls₀) b₃) of + Let (l₁ :| ls₁) b₄ -> Let (Binding "_" mA₁ a₁ :| (l₁ : ls₁)) b₄ + e -> Let (Binding "_" mA₁ a₁ :| [] ) e where mA₁ = fmap alphaNormalize mA₀ a₁ = alphaNormalize a₀ @@ -1226,8 +1228,6 @@ 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 @@ -1329,6 +1329,8 @@ l₁ = alphaNormalize l₀ r₁ = alphaNormalize r₀ +alphaNormalize TextShow = + TextShow alphaNormalize List = List alphaNormalize (ListLit (Just _T₀) ts₀) = @@ -1421,10 +1423,6 @@ u₁ = alphaNormalize u₀ _T₁ = fmap alphaNormalize _T₀ -alphaNormalize (Constructors u₀) = - Constructors u₁ - where - u₁ = alphaNormalize u₀ alphaNormalize (Field e₀ a) = Field e₁ a where @@ -1519,6 +1517,7 @@ denote Text = Text denote (TextLit (Chunks a b)) = TextLit (Chunks (fmap (fmap denote) a) b) denote (TextAppend a b ) = TextAppend (denote a) (denote b) +denote TextShow = TextShow denote List = List denote (ListLit a b ) = ListLit (fmap denote a) (fmap denote b) denote (ListAppend a b ) = ListAppend (denote a) (denote b) @@ -1543,7 +1542,6 @@ denote (CombineTypes a b ) = CombineTypes (denote a) (denote b) denote (Prefer a b ) = Prefer (denote a) (denote b) denote (Merge a b c ) = Merge (denote a) (denote b) (fmap denote c) -denote (Constructors a ) = Constructors (denote a) denote (Field a b ) = Field (denote a) b denote (Project a b ) = Project (denote a) b denote (ImportAlt a b ) = ImportAlt (denote a) (denote b) @@ -1711,6 +1709,10 @@ loop nothing App (App (App (App (App OptionalFold _) (Some x)) _) just) _ -> loop (App just x) + App TextShow (TextLit (Chunks [] oldText)) -> + loop (TextLit (Chunks [] newText)) + where + newText = textShow oldText _ -> do res2 <- ctx (App f' a') case res2 of @@ -1825,6 +1827,7 @@ decide l (TextLit n) | isEmpty n = l decide (TextLit m) (TextLit n) = TextLit (m <> n) decide l r = TextAppend l r + TextShow -> pure TextShow List -> pure List ListLit t es | Data.Sequence.null es -> ListLit <$> t' <*> es' @@ -1911,11 +1914,6 @@ _ -> Merge x' y' <$> t' where t' = traverse loop t - Constructors t -> do - t' <- loop t - case t' of - u@(Union _) -> pure u - _ -> pure $ Constructors t' Field r x -> do r' <- loop r case r' of @@ -1951,6 +1949,19 @@ ImportAlt l _r -> loop l Embed a -> pure (Embed a) +textShow :: Text -> Text +textShow text = "\"" <> Data.Text.concatMap f text <> "\"" + where + f '"' = "\\\"" + f '$' = "\\u0024" + f '\\' = "\\\\" + f '\b' = "\\b" + f '\n' = "\\n" + f '\r' = "\\r" + f '\t' = "\\t" + f c | c <= '\x1F' = Data.Text.pack (Text.Printf.printf "\\u%04d" (Data.Char.ord c)) + | otherwise = Data.Text.singleton c + {-| Returns `True` if two expressions are α-equivalent and β-equivalent and `False` otherwise -} @@ -2022,6 +2033,8 @@ False App (App (App (App (App OptionalFold _) (App None _)) _) _) _ -> False + App TextShow (TextLit (Chunks [] _)) -> + False _ -> True Let _ _ -> False Annot _ _ -> False @@ -2099,6 +2112,7 @@ decide _ (TextLit n) | isEmpty n = False decide (TextLit _) (TextLit _) = False decide _ _ = True + TextShow -> True List -> True ListLit t es -> all loop t && all loop es ListAppend x y -> loop x && loop y && decide x y @@ -2152,11 +2166,6 @@ Nothing -> True _ -> True _ -> True - Constructors t -> loop t && - case t of - Union _ -> False - _ -> True - Field r x -> loop r && case r of RecordLit kvs -> @@ -2254,6 +2263,7 @@ , "Double" , "Double/show" , "Text" + , "Text/show" , "List" , "List/build" , "List/fold" @@ -2312,6 +2322,7 @@ 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 _ TextShow = pure TextShow 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 @@ -2336,7 +2347,6 @@ 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 diff --git a/src/Dhall/Diff.hs b/src/Dhall/Diff.hs --- a/src/Dhall/Diff.hs +++ b/src/Dhall/Diff.hs @@ -642,10 +642,6 @@ <> ignore <> " " <> ignore -skeleton (Constructors {}) = - keyword "constructors" - <> " " - <> ignore skeleton (Field {}) = ignore <> dot @@ -974,12 +970,6 @@ where docs (App aL bL) (App aR bR) = Data.List.NonEmpty.cons (diffImportExpression bL bR) (docs aL aR) - docs (Constructors aL) (Constructors aR) = - diffImportExpression aL aR :| [ keyword "constructors" ] - docs aL aR@(Constructors {}) = - pure (mismatch aL aR) - docs aL@(Constructors {}) aR = - pure (mismatch aL aR) docs (Some aL) (Some aR) = diffImportExpression aL aR :| [ builtin "Some" ] docs aL aR@(Some {}) = @@ -992,12 +982,6 @@ mismatch l r diffApplicationExpression l r@(App {}) = mismatch l r -diffApplicationExpression (Constructors l) (Constructors r) = - enclosed' mempty mempty (keyword "constructors" :| [ diffImportExpression l r ]) -diffApplicationExpression l@(Constructors {}) r = - mismatch l r -diffApplicationExpression l r@(Constructors {}) = - mismatch l r diffApplicationExpression (Some l) (Some r) = enclosed' mempty mempty (builtin "Some" :| [ diffImportExpression l r ]) diffApplicationExpression l@(Some {}) r = @@ -1149,6 +1133,12 @@ diffPrimitiveExpression l@Text r = mismatch l r diffPrimitiveExpression l r@Text = + mismatch l r +diffPrimitiveExpression TextShow TextShow = + "…" +diffPrimitiveExpression l@TextShow r = + mismatch l r +diffPrimitiveExpression l r@TextShow = mismatch l r diffPrimitiveExpression List List = "…" diff --git a/src/Dhall/Format.hs b/src/Dhall/Format.hs --- a/src/Dhall/Format.hs +++ b/src/Dhall/Format.hs @@ -1,63 +1,114 @@ +{-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} -- | This module contains the implementation of the @dhall format@ subcommand module Dhall.Format ( -- * Format - format + Format(..) + , FormatMode(..) + , format ) where +import Control.Exception (Exception) +import Control.Monad.IO.Class (MonadIO(..)) import Dhall.Parser (exprAndHeaderFromText) import Dhall.Pretty (CharacterSet(..), annToAnsiStyle, layoutOpts) import Data.Monoid ((<>)) import qualified Data.Text.Prettyprint.Doc as Pretty -import qualified Data.Text.Prettyprint.Doc.Render.Terminal as Pretty +import qualified Data.Text.Prettyprint.Doc.Render.Terminal as Pretty.Terminal +import qualified Data.Text.Prettyprint.Doc.Render.Text as Pretty.Text import qualified Control.Exception import qualified Data.Text.IO import qualified Dhall.Pretty import qualified System.Console.ANSI import qualified System.IO +data NotFormatted = NotFormatted + deriving (Exception) + +instance Show NotFormatted where + show _ = "" + +-- | Arguments to the `format` subcommand +data Format = Format + { characterSet :: CharacterSet + , formatMode :: FormatMode + } + +{-| The `format` subcommand can either `Modify` its input or simply `Check` + that the input is already formatted +-} +data FormatMode + = Modify + { inplace :: Maybe FilePath + -- ^ Modify file in-place if present, otherwise read from @stdin@ and + -- write to @stdout@ + } + | Check + { path :: Maybe FilePath + -- ^ Read from the given file if present, otherwise read from @stdin@ + } + -- | Implementation of the @dhall format@ subcommand format - :: CharacterSet - -> Maybe FilePath - -- ^ Modify file in-place if present, otherwise read from @stdin@ and write - -- to @stdout@ + :: Format -> IO () -format characterSet inplace = do - case inplace of - Just file -> do - text <- Data.Text.IO.readFile file - (header, expr) <- case exprAndHeaderFromText "(stdin)" text of - Left err -> Control.Exception.throwIO err - Right x -> return x +format (Format {..}) = + case formatMode of + Modify {..} -> + case inplace of + Just file -> do + text <- Data.Text.IO.readFile file - let doc = Pretty.pretty header - <> Pretty.unAnnotate (Dhall.Pretty.prettyCharacterSet characterSet expr) - System.IO.withFile file System.IO.WriteMode (\handle -> do - Pretty.renderIO handle (Pretty.layoutSmart layoutOpts doc) - Data.Text.IO.hPutStrLn handle "" ) - Nothing -> do - inText <- Data.Text.IO.getContents + (header, expr) <- throws (exprAndHeaderFromText "(stdin)" text) - (header, expr) <- case exprAndHeaderFromText "(stdin)" inText of - Left err -> Control.Exception.throwIO err - Right x -> return x + let doc = Pretty.pretty header + <> Pretty.unAnnotate (Dhall.Pretty.prettyCharacterSet characterSet expr) + <> "\n" + System.IO.withFile file System.IO.WriteMode (\handle -> do + Pretty.Terminal.renderIO handle (Pretty.layoutSmart layoutOpts doc)) + Nothing -> do + inText <- Data.Text.IO.getContents - let doc = Pretty.pretty header - <> Dhall.Pretty.prettyCharacterSet characterSet expr + (header, expr) <- throws (exprAndHeaderFromText "(stdin)" inText) - supportsANSI <- System.Console.ANSI.hSupportsANSI System.IO.stdout + let doc = Pretty.pretty header + <> Dhall.Pretty.prettyCharacterSet characterSet expr + <> "\n" - if supportsANSI - then - Pretty.renderIO - System.IO.stdout - (fmap annToAnsiStyle (Pretty.layoutSmart layoutOpts doc)) - else - Pretty.renderIO - System.IO.stdout - (Pretty.layoutSmart layoutOpts (Pretty.unAnnotate doc)) + supportsANSI <- System.Console.ANSI.hSupportsANSI System.IO.stdout + + if supportsANSI + then + Pretty.Terminal.renderIO + System.IO.stdout + (fmap annToAnsiStyle (Pretty.layoutSmart layoutOpts doc)) + else + Pretty.Terminal.renderIO + System.IO.stdout + (Pretty.layoutSmart layoutOpts (Pretty.unAnnotate doc)) + Check {..} -> do + originalText <- case path of + Just file -> Data.Text.IO.readFile file + Nothing -> Data.Text.IO.getContents + + (header, expr) <- throws (exprAndHeaderFromText "(stdin)" originalText) + + let doc = Pretty.pretty header + <> Pretty.unAnnotate (Dhall.Pretty.prettyCharacterSet characterSet expr) + <> "\n" + + let formattedText = + Pretty.Text.renderStrict (Pretty.layoutSmart layoutOpts doc) + + if originalText == formattedText + then return () + else Control.Exception.throwIO NotFormatted + +throws :: (Exception e, MonadIO io) => Either e a -> io a +throws (Left e) = liftIO (Control.Exception.throwIO e) +throws (Right a) = return a diff --git a/src/Dhall/Freeze.hs b/src/Dhall/Freeze.hs --- a/src/Dhall/Freeze.hs +++ b/src/Dhall/Freeze.hs @@ -5,7 +5,8 @@ module Dhall.Freeze ( -- * Freeze freeze - , hashImport + , freezeImport + , freezeRemoteImport ) where import Control.Exception (SomeException) @@ -13,7 +14,7 @@ import Data.Maybe (fromMaybe) import Data.Text import Dhall.Binary (StandardVersion(..)) -import Dhall.Core (Expr(..), Import(..), ImportHashed(..)) +import Dhall.Core (Expr(..), Import(..), ImportHashed(..), ImportType(..)) import Dhall.Import (standardVersion) import Dhall.Parser (exprAndHeaderFromText, Src) import Dhall.Pretty (annToAnsiStyle, layoutOpts) @@ -33,13 +34,13 @@ import qualified System.IO -- | Retrieve an `Import` and update the hash to match the latest contents -hashImport +freezeImport :: FilePath -- ^ Current working directory -> StandardVersion -> Import -> IO Import -hashImport directory _standardVersion import_ = do +freezeImport directory _standardVersion import_ = do let unprotectedImport = import_ { importHashed = @@ -47,8 +48,12 @@ { hash = Nothing } } - let status = set standardVersion _standardVersion (Dhall.Import.emptyStatus directory) + let status = + set standardVersion + _standardVersion + (Dhall.Import.emptyStatus directory) + let download = State.evalStateT (Dhall.Import.loadWith (Embed import_)) status @@ -77,6 +82,18 @@ return newImport +-- | Freeze an import only if the import is a `Remote` import +freezeRemoteImport + :: FilePath + -- ^ Current working directory + -> StandardVersion + -> Import + -> IO Import +freezeRemoteImport directory _standardVersion import_ = do + case importType (importHashed import_) of + Remote {} -> freezeImport directory _standardVersion import_ + _ -> return import_ + parseExpr :: String -> Text -> IO (Text, Expr Src Import) parseExpr src txt = case exprAndHeaderFromText src txt of @@ -107,9 +124,11 @@ :: Maybe FilePath -- ^ Modify file in-place if present, otherwise read from @stdin@ and write -- to @stdout@ + -> Bool + -- ^ If `True` then freeze all imports, otherwise freeze only remote imports -> StandardVersion -> IO () -freeze inplace _standardVersion = do +freeze inplace everything _standardVersion = do (text, directory) <- case inplace of Nothing -> do text <- Data.Text.IO.getContents @@ -122,7 +141,10 @@ return (text, System.FilePath.takeDirectory file) (header, parsedExpression) <- parseExpr srcInfo text - frozenExpression <- traverse (hashImport directory _standardVersion) parsedExpression + + let freezeFunction = if everything then freezeImport else freezeRemoteImport + + frozenExpression <- traverse (freezeFunction directory _standardVersion) parsedExpression writeExpr inplace (header, frozenExpression) where srcInfo = fromMaybe "(stdin)" inplace diff --git a/src/Dhall/Import.hs b/src/Dhall/Import.hs --- a/src/Dhall/Import.hs +++ b/src/Dhall/Import.hs @@ -128,7 +128,7 @@ ) where import Control.Applicative (Alternative(..)) -import Codec.CBOR.Term (Term) +import Codec.CBOR.Term (Term(..)) import Control.Exception (Exception, SomeException, throwIO, toException) import Control.Monad (guard) import Control.Monad.Catch (throwM, MonadCatch(catch), catches, Handler(..)) @@ -137,7 +137,7 @@ import Crypto.Hash (SHA256) import Data.CaseInsensitive (CI) import Data.List.NonEmpty (NonEmpty(..)) -import Data.Semigroup (sconcat, (<>)) +import Data.Semigroup (Semigroup(..)) import Data.Text (Text) #if MIN_VERSION_base(4,8,0) #else @@ -167,7 +167,7 @@ import Dhall.Import.Types import Text.Dot ((.->.), userNodeId) -import Dhall.Parser (Parser(..), ParseError(..), Src(..)) +import Dhall.Parser (Parser(..), ParseError(..), Src(..), SourcedException(..)) import Dhall.TypeCheck (X(..)) import Lens.Family.State.Strict (zoom) @@ -255,14 +255,16 @@ instance Exception e => Exception (Imported e) instance Show e => Show (Imported e) where - show (Imported imports e) = + show (Imported canonicalizedImports e) = concat (zipWith indent [0..] toDisplay) ++ "\n" ++ show e where indent n import_ = "\n" ++ replicate (2 * n) ' ' ++ "↳ " ++ Dhall.Pretty.Internal.prettyToString import_ - canonical = NonEmpty.toList (canonicalizeAll imports) + + canonical = NonEmpty.toList canonicalizedImports + -- Tthe final (outermost) import is fake to establish the base -- directory. Also, we need outermost-first. toDisplay = drop 1 (reverse canonical) @@ -278,7 +280,6 @@ "\n" <> "\ESC[1;31mError\ESC[0m: Missing file " <> path - <> "\n" -- | Exception thrown when an environment variable is missing newtype MissingEnvironmentVariable = MissingEnvironmentVariable { name :: Text } @@ -302,19 +303,16 @@ show (MissingImports []) = "\n" <> "\ESC[1;31mError\ESC[0m: No valid imports" - <> "\n" show (MissingImports [e]) = show e show (MissingImports es) = "\n" <> "\ESC[1;31mError\ESC[0m: Failed to resolve imports. Error list:" <> "\n" <> concatMap (\e -> "\n" <> show e <> "\n") es - <> "\n" throwMissingImport :: (MonadCatch m, Exception e) => e -> m a throwMissingImport e = throwM (MissingImports [(toException e)]) - -- | Exception thrown when a HTTP url is imported but dhall was built without -- the @with-http@ Cabal flag. data CannotImportHTTPURL = @@ -336,15 +334,12 @@ <> url <> "\n" -canonicalizeAll :: NonEmpty Import -> NonEmpty Import -canonicalizeAll = NonEmpty.scanr1 step - where - step a parent = canonicalizeImport (a :| [parent]) - {-| -> canonicalize (canonicalize x) = canonicalize x +> canonicalize . canonicalize = canonicalize + +> canonicalize (a <> b) = canonicalize a <> canonicalize b -} -class Canonicalize path where +class Semigroup path => Canonicalize path where canonicalize :: path -> path -- | @@ -395,10 +390,6 @@ canonicalize (Import importHashed importMode) = Import (canonicalize importHashed) importMode -canonicalizeImport :: NonEmpty Import -> Import -canonicalizeImport imports = - canonicalize (sconcat (NonEmpty.reverse imports)) - toHeaders :: Expr s a -> Maybe [(CI Data.ByteString.ByteString, Data.ByteString.ByteString)] @@ -490,7 +481,7 @@ term <- throws (Codec.Serialise.deserialiseOrFail bytesLazy) - throws (Dhall.Binary.decodeWithVersion term) + throws (Dhall.Binary.decode term) case result of Just expression -> return expression @@ -527,16 +518,22 @@ expression ) - let bytes = encodeExpression _standardVersion normalizedExpression + let check version = do + let bytes = encodeExpression version normalizedExpression - let actualHash = Crypto.Hash.hash bytes + let actualHash = Crypto.Hash.hash bytes - if expectedHash == actualHash - then return () - else liftIO (Control.Exception.throwIO (HashMismatch {..})) + guard (expectedHash == actualHash) - liftIO (Data.ByteString.writeFile cacheFile bytes) + liftIO (Data.ByteString.writeFile cacheFile bytes) + let fallback = do + let actualHash = hashExpression NoVersion normalizedExpression + + liftIO (Control.Exception.throwIO (HashMismatch {..})) + + Data.Foldable.asum (map check [ minBound .. maxBound ]) <|> fallback + return () getCacheFile @@ -572,8 +569,6 @@ cacheDirectory <- getCacheDirectory - assertDirectory cacheDirectory - let dhallDirectory = cacheDirectory "dhall" assertDirectory dhallDirectory @@ -582,22 +577,23 @@ return cacheFile -getCacheDirectory :: MonadIO io => io FilePath -#if MIN_VERSION_directory(1,2,3) -getCacheDirectory = liftIO (Directory.getXdgDirectory Directory.XdgCache "") -#else -getCacheDirectory = liftIO $ do - maybeXDGCacheHome <- System.Environment.lookupEnv "XDG_CACHE_HOME" +getCacheDirectory :: (Alternative m, MonadIO m) => m FilePath +getCacheDirectory = alternative₀ <|> alternative₁ + where + alternative₀ = do + maybeXDGCacheHome <- do + liftIO (System.Environment.lookupEnv "XDG_CACHE_HOME") - case maybeXDGCacheHome of - Nothing -> do - homeDirectory <- Directory.getHomeDirectory + case maybeXDGCacheHome of + Just xdgCacheHome -> return xdgCacheHome + Nothing -> empty - return (homeDirectory ".cache") + alternative₁ = do + maybeHomeDirectory <- liftIO (System.Environment.lookupEnv "HOME") - Just xdgCacheHome -> do - return xdgCacheHome -#endif + case maybeHomeDirectory of + Just homeDirectory -> return (homeDirectory ".cache") + Nothing -> empty exprFromUncachedImport :: Import -> StateT (Status IO) IO (Expr Src Import) exprFromUncachedImport (Import {..}) = do @@ -715,34 +711,38 @@ -} loadWith :: MonadCatch m => Expr Src Import -> StateT (Status m) m (Expr Src X) loadWith expr₀ = case expr₀ of - Embed import_ -> do + Embed import₀ -> do Status {..} <- State.get - let imports = _stack + let parent = NonEmpty.head _stack + let import₁ = parent <> import₀ + + let child = canonicalize import₁ + let local (Import (ImportHashed _ (Remote {})) _) = False local (Import (ImportHashed _ (Local {})) _) = True local (Import (ImportHashed _ (Env {})) _) = True local (Import (ImportHashed _ (Missing {})) _) = True - let parent = canonicalizeImport imports - let imports' = NonEmpty.cons import_ imports - let here = canonicalizeImport imports' + let referentiallySane = not (local child) || local parent - if local here && not (local parent) - then throwMissingImport (Imported imports (ReferentiallyOpaque import_)) - else return () + if referentiallySane + then return () + else throwMissingImport (Imported _stack (ReferentiallyOpaque import₀)) - expr <- if here `elem` canonicalizeAll imports - then throwMissingImport (Imported imports (Cycle import_)) + let _stack' = NonEmpty.cons child _stack + + expr <- if child `elem` _stack + then throwMissingImport (Imported _stack (Cycle import₀)) else do - case Map.lookup here _cache of - Just (hereNode, expr) -> do + case Map.lookup child _cache of + Just (childNode, expr) -> do zoom dot . State.modify $ \getDot -> do parentNode <- getDot - -- Add edge between parent and here - parentNode .->. hereNode + -- Add edge between parent and child + parentNode .->. childNode -- Return parent NodeId pure parentNode @@ -764,7 +764,7 @@ throwM (MissingImports (map - (\e -> toException (Imported imports' e)) + (\e -> toException (Imported _stack' e)) es ) ) @@ -774,39 +774,39 @@ => SomeException -> StateT (Status m) m (Expr Src Import) handler₁ e = - throwMissingImport (Imported imports' e) + throwMissingImport (Imported _stack' e) -- This loads a \"dynamic\" expression (i.e. an expression -- that might still contain imports) - let loadDynamic = _resolver here + let loadDynamic = _resolver child expr' <- loadDynamic `catches` [ Handler handler₀, Handler handler₁ ] - let hereNodeId = userNodeId _nextNodeId + let childNodeId = userNodeId _nextNodeId -- Increment the next node id zoom nextNodeId $ State.modify succ -- Make current node the dot graph - zoom dot . State.put $ importNode hereNodeId here + zoom dot . State.put $ importNode childNodeId child - zoom stack (State.put imports') + zoom stack (State.put _stack') expr'' <- loadWith expr' - zoom stack (State.put imports) + zoom stack (State.put _stack) zoom dot . State.modify $ \getSubDot -> do parentNode <- _dot -- Get current node back from sub-graph - hereNode <- getSubDot + childNode <- getSubDot - -- Add edge between parent and here - parentNode .->. hereNode + -- Add edge between parent and child + parentNode .->. childNode -- Return parent NodeId pure parentNode - _cacher here expr'' + _cacher child expr'' -- Type-check expressions here for three separate reasons: -- @@ -819,30 +819,40 @@ -- There is no need to check expressions that have been -- cached, since they have already been checked expr''' <- case Dhall.TypeCheck.typeWith _startingContext expr'' of - Left err -> throwM (Imported imports' err) + Left err -> throwM (Imported _stack' err) Right _ -> return (Dhall.Core.normalizeWith (getReifiedNormalizer _normalizer) expr'') - zoom cache (State.modify' (Map.insert here (hereNodeId, expr'''))) + zoom cache (State.modify' (Map.insert child (childNodeId, expr'''))) return expr''' - case hash (importHashed import_) of + case hash (importHashed import₀) of Nothing -> do return () Just expectedHash -> do - let actualHash = - hashExpression _standardVersion (Dhall.Core.alphaNormalize expr) + let matches version = + let actualHash = + hashExpression version (Dhall.Core.alphaNormalize expr) - if expectedHash == actualHash + in expectedHash == actualHash + + if any matches [ minBound .. maxBound ] then return () - else throwMissingImport (Imported imports' (HashMismatch {..})) + else do + let actualHash = + hashExpression NoVersion (Dhall.Core.alphaNormalize expr) + throwMissingImport (Imported _stack' (HashMismatch {..})) + return expr ImportAlt a b -> loadWith a `catch` handler₀ where - handler₀ (MissingImports es₀) = - loadWith b `catch` handler₁ + handler₀ (SourcedException (Src begin _ text₀) (MissingImports es₀)) = + loadWith b `catch` handler₁ where - handler₁ (MissingImports es₁) = - throwM (MissingImports (es₀ ++ es₁)) + handler₁ (SourcedException (Src _ end text₁) (MissingImports es₁)) = + throwM (SourcedException (Src begin end text₂) (MissingImports (es₀ ++ es₁))) + where + text₂ = text₀ <> " ? " <> text₁ + Const a -> pure (Const a) Var a -> pure (Var a) Lam a b c -> Lam <$> pure a <*> loadWith b <*> loadWith c @@ -880,6 +890,7 @@ Text -> pure Text TextLit (Chunks a b) -> fmap TextLit (Chunks <$> mapM (mapM loadWith) a <*> pure b) TextAppend a b -> TextAppend <$> loadWith a <*> loadWith b + TextShow -> pure TextShow List -> pure List ListLit a b -> ListLit <$> mapM loadWith a <*> mapM loadWith b ListAppend a b -> ListAppend <$> loadWith a <*> loadWith b @@ -904,34 +915,46 @@ CombineTypes a b -> CombineTypes <$> loadWith a <*> loadWith b Prefer a b -> Prefer <$> loadWith a <*> loadWith b Merge a b c -> Merge <$> loadWith a <*> loadWith b <*> mapM loadWith c - Constructors a -> Constructors <$> loadWith a Field a b -> Field <$> loadWith a <*> pure b Project a b -> Project <$> loadWith a <*> pure b - Note a b -> Note <$> pure a <*> loadWith b + Note a b -> do + let handler e = throwM (SourcedException a (e :: MissingImports)) + (Note <$> pure a <*> loadWith b) `catch` handler + -- | Resolve all imports within an expression load :: Expr Src Import -> IO (Expr Src X) load expression = State.evalStateT (loadWith expression) (emptyStatus ".") encodeExpression - :: forall s . StandardVersion -> Expr s X -> Data.ByteString.ByteString + :: forall s + . StandardVersion + -- ^ `Nothing` means to encode without the version tag + -> Expr s X + -> Data.ByteString.ByteString encodeExpression _standardVersion expression = bytesStrict where intermediateExpression :: Expr s Import intermediateExpression = fmap absurd expression term :: Term - term = - Dhall.Binary.encodeWithVersion - _standardVersion - intermediateExpression + term = Dhall.Binary.encode intermediateExpression - bytesLazy = Codec.Serialise.serialise term + taggedTerm :: Term + taggedTerm = + case _standardVersion of + NoVersion -> term + s -> TList [ TString v, term ] + where + v = Dhall.Binary.renderStandardVersion s + bytesLazy = Codec.Serialise.serialise taggedTerm + bytesStrict = Data.ByteString.Lazy.toStrict bytesLazy -- | Hash a fully resolved expression -hashExpression :: StandardVersion -> Expr s X -> (Crypto.Hash.Digest SHA256) +hashExpression + :: StandardVersion -> Expr s X -> (Crypto.Hash.Digest SHA256) hashExpression _standardVersion expression = Crypto.Hash.hash (encodeExpression _standardVersion expression) diff --git a/src/Dhall/Import/HTTP.hs b/src/Dhall/Import/HTTP.hs --- a/src/Dhall/Import/HTTP.hs +++ b/src/Dhall/Import/HTTP.hs @@ -57,19 +57,19 @@ "\n" <> "\ESC[1;31mError\ESC[0m: Invalid remote host name\n" <> "\n" - <> "↳ " <> show host <> "\n" + <> "↳ " <> show host ResponseTimeout -> "\n" - <> "\ESC[1;31mError\ESC[0m: The remote host took too long to respond\n" + <> "\ESC[1;31mError\ESC[0m: The remote host took too long to respond" StatusCodeException response _ | statusCode == 404 -> "\n" - <> "\ESC[1;31mError\ESC[0m: Remote file not found\n" + <> "\ESC[1;31mError\ESC[0m: Remote file not found" | otherwise -> "\n" <> "\ESC[1;31mError\ESC[0m: Unexpected HTTP status code:\n" <> "\n" - <> "↳ " <> show statusCode <> "\n" + <> "↳ " <> show statusCode where statusCode = Network.HTTP.Types.Status.statusCode diff --git a/src/Dhall/Lint.hs b/src/Dhall/Lint.hs --- a/src/Dhall/Lint.hs +++ b/src/Dhall/Lint.hs @@ -3,12 +3,16 @@ module Dhall.Lint ( -- * Lint lint + , removeLetInLet + , removeUnusedBindings + , optionalLitToSomeNone ) where -import Dhall.Core (Binding(..), Chunks(..), Expr(..), Import, Var(..)) -import Data.Semigroup ((<>)) +import Control.Monad (mplus) import Data.List.NonEmpty (NonEmpty(..)) -import Dhall.TypeCheck (X(..)) +import Data.Semigroup ((<>)) +import Dhall.Core (Binding(..), Expr(..), Import, Var(..), subExpressions) +import Lens.Family (ASetter, over) import qualified Dhall.Core @@ -16,240 +20,49 @@ 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 - * removes the `constructors` keyword + * removes unused @let@ bindings with 'removeLetInLet'. + * consolidates nested @let@ bindings to use a multiple-@let@ binding with 'removeUnusedBindings'. + * switches legacy @List@-like @Optional@ literals to use @Some@ / @None@ instead with 'optionalLitToSomeNone' -} lint :: Expr s Import -> Expr t Import -lint expression = loop (Dhall.Core.denote expression) +lint = + rewriteOf + subExpressions + ( \e -> + removeLetInLet e + `mplus` removeUnusedBindings e + `mplus` optionalLitToSomeNone e + ) + . Dhall.Core.denote + +removeLetInLet :: Eq a => Expr s a -> Maybe (Expr s a) +removeLetInLet (Let a (Let b c)) = Just (Let (a <> b) c) +removeLetInLet _ = Nothing + +removeUnusedBindings :: Eq a => Expr s a -> Maybe (Expr s a) +removeUnusedBindings (Let (Binding a _ _ :| []) d) + | not (V a 0 `Dhall.Core.freeIn` d) = + Just d + | otherwise = + Nothing +removeUnusedBindings (Let (Binding a _ _ :| (l : ls)) d) + | not (V a 0 `Dhall.Core.freeIn` e) = + Just e + | otherwise = + Nothing where - loop (Const a) = - Const a - loop (Var a) = - Var a - loop (Lam a b c) = Lam a b' c' - where - b' = loop b - c' = loop c - loop (Pi a b c) = Pi a b' c' - where - b' = loop b - c' = loop c - loop (App a b) = App a' b' - where - a' = loop a - b' = loop b + e = Let (l :| ls) d +removeUnusedBindings _ = Nothing - -- 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 (Binding a b' c' :| []) d' - where - b' = fmap loop b - c' = loop c +optionalLitToSomeNone :: Expr s a -> Maybe (Expr s a) +optionalLitToSomeNone (OptionalLit _ (Just b)) = Just (Some b) +optionalLitToSomeNone (OptionalLit a Nothing) = Just (App None a) +optionalLitToSomeNone _ = Nothing - d' = loop d - loop (Let (Binding a b c :| (l : ls)) d) - | not (V a 0 `Dhall.Core.freeIn` Let (l' :| ls') 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) +rewriteOf :: ASetter a b a b -> (b -> Maybe a) -> a -> b +rewriteOf l f = go where go = transformOf l (\x -> maybe x go (f x)) - loop (Annot a b) = - Annot a' b' - where - a' = loop a - b' = loop b - loop Bool = - Bool - loop (BoolLit a) = - BoolLit a - loop (BoolAnd a b) = - BoolAnd a' b' - where - a' = loop a - b' = loop b - loop (BoolOr a b) = - BoolOr a' b' - where - a' = loop a - b' = loop b - loop (BoolEQ a b) = - BoolEQ a' b' - where - a' = loop a - b' = loop b - loop (BoolNE a b) = - BoolNE a' b' - where - a' = loop a - b' = loop b - loop (BoolIf a b c) = - BoolIf a' b' c' - where - a' = loop a - b' = loop b - c' = loop c - loop Natural = - Natural - loop (NaturalLit a) = - NaturalLit a - loop NaturalFold = - NaturalFold - loop NaturalBuild = - NaturalBuild - loop NaturalIsZero = - NaturalIsZero - loop NaturalEven = - NaturalEven - loop NaturalOdd = - NaturalOdd - loop NaturalToInteger = - NaturalToInteger - loop NaturalShow = - NaturalShow - loop (NaturalPlus a b) = - NaturalPlus a' b' - where - a' = loop a - b' = loop b - loop (NaturalTimes a b) = - NaturalTimes a' b' - where - a' = loop a - b' = loop b - loop Integer = - Integer - loop (IntegerLit a) = - IntegerLit a - loop IntegerShow = - IntegerShow - loop IntegerToDouble = - IntegerToDouble - loop Double = - Double - loop (DoubleLit a) = - DoubleLit a - loop DoubleShow = - DoubleShow - loop Text = - Text - loop (TextLit (Chunks a b)) = - TextLit (Chunks a' b) - where - a' = fmap (fmap loop) a - loop (TextAppend a b) = - TextAppend a' b' - where - a' = loop a - b' = loop b - loop List = - List - loop (ListLit a b) = - ListLit a' b' - where - a' = fmap loop a - b' = fmap loop b - loop (ListAppend a b) = - ListAppend a' b' - where - a' = loop a - b' = loop b - loop ListBuild = - ListBuild - loop ListFold = - ListFold - loop ListLength = - ListLength - loop ListHead = - ListHead - loop ListLast = - ListLast - loop ListIndexed = - ListIndexed - loop ListReverse = - ListReverse - loop Optional = - Optional - loop (Some a) = - Some a' - where - a' = loop a - loop None = - None - loop (OptionalLit _ (Just b)) = - loop (Some b) - loop (OptionalLit a Nothing) = - loop (App None a) - loop OptionalFold = - OptionalFold - loop OptionalBuild = - OptionalBuild - loop (Record a) = - Record a' - where - a' = fmap loop a - loop (RecordLit a) = - RecordLit a' - where - a' = fmap loop a - loop (Union a) = - Union a' - where - a' = fmap loop a - loop (UnionLit a b c) = - UnionLit a b' c' - where - b' = loop b - c' = fmap loop c - loop (Combine a b) = - Combine a' b' - where - a' = loop a - b' = loop b - loop (CombineTypes a b) = - CombineTypes a' b' - where - a' = loop a - b' = loop b - loop (Prefer a b) = - Prefer a' b' - where - a' = loop a - b' = loop b - loop (Merge a b c) = - Merge a' b' c' - where - a' = loop a - b' = loop b - c' = fmap loop c - loop (Constructors a) = - loop a - loop (Field a b) = - Field a' b - where - a' = loop a - loop (Project a b) = - Project a' b - where - a' = loop a - loop (Note a _) = - absurd a - loop (ImportAlt a b) = - ImportAlt a' b' - where - a' = loop a - b' = loop b - loop (Embed a) = - Embed a +transformOf :: ASetter a b a b -> (b -> b) -> a -> b +transformOf l f = go where go = f . over l go diff --git a/src/Dhall/Main.hs b/src/Dhall/Main.hs --- a/src/Dhall/Main.hs +++ b/src/Dhall/Main.hs @@ -70,6 +70,7 @@ import qualified System.Console.ANSI import qualified System.IO import qualified Text.Dot +import qualified Data.Map -- | Top-level program options data Options = Options @@ -84,18 +85,24 @@ data Mode = Default { annotate :: Bool } | Version - | Resolve { dot :: Bool } + | Resolve { resolveMode :: Maybe ResolveMode } | Type | Normalize | Repl - | Format { inplace :: Maybe FilePath } - | Freeze { inplace :: Maybe FilePath } + | Format { formatMode :: Dhall.Format.FormatMode } + | Freeze { inplace :: Maybe FilePath, all_ :: Bool } | Hash | Diff { expr1 :: Text, expr2 :: Text } | Lint { inplace :: Maybe FilePath } | Encode { json :: Bool } | Decode { json :: Bool } +data ResolveMode + = Dot + | ListTransitiveDependencies + | ListImmediateDependencies + + -- | `Parser` for the `Options` type parseOptions :: Parser Options parseOptions = @@ -134,7 +141,7 @@ <|> subcommand "resolve" "Resolve an expression's imports" - (Resolve <$> parseDot) + (Resolve <$> parseResolveMode) <|> subcommand "type" "Infer an expression's type" @@ -162,11 +169,11 @@ <|> subcommand "format" "Formatter for the Dhall language" - (Format <$> optional parseInplace) + (Format <$> parseFormatMode) <|> subcommand "freeze" - "Add hashes to all import statements of an expression" - (Freeze <$> optional parseInplace) + "Add integrity checks to remote import statements of an expression" + (Freeze <$> optional parseInplace <*> parseAllFlag) <|> subcommand "encode" "Encode a Dhall expression to binary" @@ -186,12 +193,25 @@ Options.Applicative.switch (Options.Applicative.long "annotate") - parseDot = - Options.Applicative.switch - ( Options.Applicative.long "dot" - <> Options.Applicative.help - "Output import dependency graph in dot format" - ) + parseResolveMode = + Options.Applicative.flag' (Just Dot) + ( Options.Applicative.long "dot" + <> Options.Applicative.help + "Output import dependency graph in dot format" + ) + <|> + Options.Applicative.flag' (Just ListImmediateDependencies) + ( Options.Applicative.long "immediate-dependencies" + <> Options.Applicative.help + "List immediate import dependencies" + ) + <|> + Options.Applicative.flag' (Just ListTransitiveDependencies) + ( Options.Applicative.long "transitive-dependencies" + <> Options.Applicative.help + "List transitive import dependencies" + ) + <|> pure Nothing parseInplace = Options.Applicative.strOption @@ -206,6 +226,23 @@ <> Options.Applicative.help "Use JSON representation of CBOR" ) + parseAllFlag = + Options.Applicative.switch + ( Options.Applicative.long "all" + <> Options.Applicative.help "Add integrity checks to all imports (not just remote imports)" + ) + + parseCheck = + Options.Applicative.switch + ( Options.Applicative.long "check" + <> Options.Applicative.help "Only check if the input is formatted" + ) + + parseFormatMode = adapt <$> parseCheck <*> optional parseInplace + where + adapt True path = Dhall.Format.Check {..} + adapt False inplace = Dhall.Format.Modify {..} + throws :: Exception e => Either e a -> IO a throws (Left e) = Control.Exception.throwIO e throws (Right a) = return a @@ -262,8 +299,12 @@ Control.Exception.throwIO (Imported ps e) handler2 e = do - let _ = e :: SomeException - System.IO.hPrint System.IO.stderr e + let string = show (e :: SomeException) + + if not (null string) + then System.IO.hPutStrLn System.IO.stderr string + else return () + System.Exit.exitFailure let renderDoc :: Handle -> Doc Ann -> IO () @@ -287,8 +328,15 @@ handle $ case mode of Version -> do - putStrLn (showVersion Meta.version) + let line₀ = "Haskell package version: " + <> Data.Text.pack (showVersion Meta.version) + let line₁ = "Standard version: " + <> Dhall.Binary.renderStandardVersion Dhall.Binary.defaultStandardVersion + + Data.Text.IO.putStrLn line₀ + Data.Text.IO.putStrLn line₁ + Default {..} -> do expression <- getExpression @@ -305,17 +353,43 @@ render System.IO.stdout annotatedExpression - Resolve dot -> do + Resolve (Just Dot) -> do expression <- getExpression - (resolvedExpression, Dhall.Import.Types.Status { _dot }) <- - State.runStateT (Dhall.Import.loadWith expression) status + (Dhall.Import.Types.Status { _dot}) <- + State.execStateT (Dhall.Import.loadWith expression) status - if dot - then putStr . ("strict " <>) . Text.Dot.showDot $ - Text.Dot.attribute ("rankdir", "LR") >> _dot - else render System.IO.stdout resolvedExpression + putStr . ("strict " <>) . Text.Dot.showDot $ + Text.Dot.attribute ("rankdir", "LR") >> + _dot + Resolve (Just ListImmediateDependencies) -> do + expression <- getExpression + + mapM_ (print + . Pretty.pretty + . Dhall.Core.importHashed) expression + + Resolve (Just ListTransitiveDependencies) -> do + expression <- getExpression + + (Dhall.Import.Types.Status { _cache }) <- + State.execStateT (Dhall.Import.loadWith expression) status + + mapM_ print + . fmap ( Pretty.pretty + . Dhall.Core.importType + . Dhall.Core.importHashed ) + . Data.Map.keys + $ _cache + + Resolve (Nothing) -> do + expression <- getExpression + + (resolvedExpression, _) <- + State.runStateT (Dhall.Import.loadWith expression) status + render System.IO.stdout resolvedExpression + Normalize -> do expression <- getExpression @@ -347,10 +421,10 @@ renderDoc System.IO.stdout diff Format {..} -> do - Dhall.Format.format characterSet inplace + Dhall.Format.format (Dhall.Format.Format {..}) Freeze {..} -> do - Dhall.Freeze.freeze inplace standardVersion + Dhall.Freeze.freeze inplace all_ standardVersion Hash -> do Dhall.Hash.hash standardVersion @@ -385,7 +459,7 @@ Encode {..} -> do expression <- getExpression - let term = Dhall.Binary.encodeWithVersion standardVersion expression + let term = Dhall.Binary.encode expression let bytes = Codec.Serialise.serialise term @@ -419,7 +493,7 @@ else do throws (Codec.Serialise.deserialiseOrFail bytes) - expression <- throws (Dhall.Binary.decodeWithVersion term) + expression <- throws (Dhall.Binary.decode term) let doc = Dhall.Pretty.prettyCharacterSet characterSet expression diff --git a/src/Dhall/Parser.hs b/src/Dhall/Parser.hs --- a/src/Dhall/Parser.hs +++ b/src/Dhall/Parser.hs @@ -12,6 +12,7 @@ -- * Types , Src(..) + , SourcedException(..) , ParseError(..) , Parser(..) ) 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 @@ -1,4 +1,5 @@ {-# LANGUAGE CPP #-} +{-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE OverloadedStrings #-} @@ -6,6 +7,7 @@ import Control.Applicative (Alternative (..), liftA2) +import Control.Exception (Exception) import Control.Monad (MonadPlus (..)) import Data.Data (Data) import Data.Semigroup (Semigroup (..)) @@ -25,7 +27,10 @@ import qualified Data.Sequence import qualified Data.Set import qualified Data.Text +import qualified Data.Text.Prettyprint.Doc as Pretty +import qualified Data.Text.Prettyprint.Doc.Render.String as Pretty import qualified Dhall.Map +import qualified Dhall.Pretty import qualified Dhall.Util import qualified Dhall.Set import qualified Text.Megaparsec @@ -38,6 +43,18 @@ data Src = Src !Text.Megaparsec.SourcePos !Text.Megaparsec.SourcePos Text -- Text field is intentionally lazy deriving (Data, Eq, Show) + +data SourcedException e = SourcedException Src e + +instance Exception e => Exception (SourcedException e) + +instance Show e => Show (SourcedException e) where + show (SourcedException source exception) = + show exception + <> "\n" + <> "\n" + <> Pretty.renderString + (Pretty.layoutPretty Dhall.Pretty.layoutOpts (pretty source)) -- | Doesn't force the 'Text' part laxSrcEq :: Src -> Src -> Bool 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 @@ -134,8 +134,9 @@ case (shallowDenote a, shallowDenote b) of (ListLit _ xs, App f c) -> case shallowDenote f of - List -> - return (ListLit (Just c) xs) + List -> case xs of + [] -> return (ListLit (Just c) xs) + _ -> return (Annot a b) Optional -> case xs of [x] -> return (OptionalLit c (Just x)) [] -> return (OptionalLit c Nothing) @@ -175,9 +176,9 @@ CombineTypes <$ _combineTypes <|> Prefer <$ _prefer <|> NaturalTimes <$ _times - <|> BoolNE <$ _notEqual + <|> BoolEQ <$ _doubleEqual - precedence3Operator = BoolEQ <$ _doubleEqual + precedence3Operator = BoolNE <$ _notEqual precedence0Expression = makeOperatorExpression precedence1Expression precedence0Operator @@ -192,8 +193,7 @@ makeOperatorExpression applicationExpression precedence3Operator applicationExpression = do - f <- (do _constructors; return Constructors) - <|> (do _Some; return Some) + f <- (do _Some; return Some) <|> return id a <- noted importExpression b <- Text.Megaparsec.many (noted importExpression) @@ -346,7 +346,8 @@ 'S' -> Const Sort <$ _Sort 'T' -> choice - [ Text <$ _Text + [ TextShow <$ _TextShow + , Text <$ _Text , BoolLit True <$ _True , Const Type <$ _Type ] 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 @@ -53,6 +53,7 @@ _Integer, _Double, _Text, + _TextShow, _List, _True, _False, @@ -110,6 +111,7 @@ import qualified Data.Text import qualified Dhall.Set import qualified Text.Megaparsec +import qualified Text.Megaparsec.Char.Lexer import qualified Text.Parser.Char import qualified Text.Parser.Combinators @@ -159,13 +161,15 @@ integerLiteral :: Parser Integer integerLiteral = (do sign <- signPrefix - a <- Text.Parser.Token.natural + a <- Text.Megaparsec.Char.Lexer.decimal + whitespace return (sign a) ) "integer literal" naturalLiteral :: Parser Natural naturalLiteral = (do - a <- Text.Parser.Token.natural - return (fromIntegral a) ) "natural literal" + a <- Text.Megaparsec.Char.Lexer.decimal + whitespace + return a ) "natural literal" identifier :: Parser Var identifier = do @@ -173,7 +177,9 @@ let indexed = do _ <- Text.Parser.Char.char '@' - Text.Parser.Token.natural + n <- Text.Megaparsec.Char.Lexer.decimal + whitespace + return n n <- indexed <|> pure 0 return (V x n) @@ -330,7 +336,7 @@ quotedPathCharacter c = ('\x20' <= c && c <= '\x21') || ('\x23' <= c && c <= '\x2E') - || ('\x30' <= c && c <= '\x7E') + || ('\x30' <= c && c <= '\x10FFFF') pathComponent :: Parser Text pathComponent = do @@ -620,6 +626,9 @@ _Text :: Parser () _Text = reserved "Text" + +_TextShow :: Parser () +_TextShow = reserved "Text/show" _List :: Parser () _List = reserved "List" 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 @@ -195,13 +195,31 @@ -- | Pretty-print anonymous functions and function types arrows :: CharacterSet -> [(Doc Ann, Doc Ann)] -> Doc Ann -arrows characterSet = +arrows ASCII = enclose' "" + " " + (" " <> rarrow ASCII <> " ") + (rarrow ASCII <> " ") +arrows Unicode = + enclose' + "" " " - (" " <> rarrow characterSet <> " ") - (rarrow characterSet <> space) + (" " <> rarrow Unicode <> " ") + (rarrow Unicode <> " ") +combine :: CharacterSet -> Text +combine ASCII = "/\\" +combine Unicode = "∧" + +combineTypes :: CharacterSet -> Text +combineTypes ASCII = "//\\\\" +combineTypes Unicode = "⩓" + +prefer :: CharacterSet -> Text +prefer ASCII = "//" +prefer Unicode = "⫽" + {-| Format an expression that holds a variable number of elements, such as a list, record, or union -} @@ -612,7 +630,7 @@ prettyCombineExpression :: Pretty a => Expr s a -> Doc Ann prettyCombineExpression a0@(Combine _ _) = - prettyOperator "∧" (docs a0) + prettyOperator (combine characterSet) (docs a0) where docs (Combine a b) = prettyPreferExpression b : docs a docs (Note _ b) = docs b @@ -624,7 +642,7 @@ prettyPreferExpression :: Pretty a => Expr s a -> Doc Ann prettyPreferExpression a0@(Prefer _ _) = - prettyOperator "⫽" (docs a0) + prettyOperator (prefer characterSet) (docs a0) where docs (Prefer a b) = prettyCombineTypesExpression b : docs a docs (Note _ b) = docs b @@ -636,7 +654,7 @@ prettyCombineTypesExpression :: Pretty a => Expr s a -> Doc Ann prettyCombineTypesExpression a0@(CombineTypes _ _) = - prettyOperator "⩓" (docs a0) + prettyOperator (combineTypes characterSet) (docs a0) where docs (CombineTypes a b) = prettyTimesExpression b : docs a docs (Note _ b) = docs b @@ -684,19 +702,17 @@ prettyApplicationExpression :: Pretty a => Expr s a -> Doc Ann prettyApplicationExpression a0 = case a0 of - App _ _ -> result - Constructors _ -> result - Some _ -> result - Note _ b -> prettyApplicationExpression b - _ -> prettyImportExpression a0 + App _ _ -> result + Some _ -> result + Note _ b -> prettyApplicationExpression b + _ -> prettyImportExpression a0 where result = enclose' "" "" " " "" (fmap duplicate (reverse (docs a0))) - docs (App a b) = prettyImportExpression b : docs a - docs (Constructors b) = [ prettyImportExpression b , keyword "constructors" ] - docs (Some a) = [ prettyImportExpression a , builtin "Some" ] - docs (Note _ b) = docs b - docs b = [ prettyImportExpression b ] + docs (App a b) = prettyImportExpression b : docs a + docs (Some a) = [ prettyImportExpression a , builtin "Some" ] + docs (Note _ b) = docs b + docs b = [ prettyImportExpression b ] prettyImportExpression :: Pretty a => Expr s a -> Doc Ann prettyImportExpression (Embed a) = @@ -751,6 +767,8 @@ builtin "Double/show" prettyPrimitiveExpression Text = builtin "Text" + prettyPrimitiveExpression TextShow = + builtin "Text/show" prettyPrimitiveExpression List = builtin "List" prettyPrimitiveExpression ListBuild = diff --git a/src/Dhall/Repl.hs b/src/Dhall/Repl.hs --- a/src/Dhall/Repl.hs +++ b/src/Dhall/Repl.hs @@ -11,24 +11,29 @@ ) where import Control.Exception ( SomeException(SomeException), displayException, throwIO ) +import Control.Monad ( forM_ ) import Control.Monad.IO.Class ( MonadIO, liftIO ) import Control.Monad.State.Class ( MonadState, get, modify ) import Control.Monad.State.Strict ( evalStateT ) -import Data.List ( elemIndex, isPrefixOf, nub ) +import Data.List ( isPrefixOf, nub ) import Data.List.NonEmpty (NonEmpty(..)) +import Data.Maybe ( mapMaybe ) import Data.Semigroup ((<>)) +import Data.Text ( Text ) import Dhall.Binary (StandardVersion(..)) import Dhall.Context (Context) -import Dhall.Import (standardVersion) +import Dhall.Import (hashExpressionToCode, standardVersion) import Dhall.Pretty (CharacterSet(..)) import Lens.Family (set) import System.Console.Haskeline (Interrupt(..)) import System.Console.Haskeline.Completion ( Completion, simpleCompletion ) +import System.Directory ( getDirectoryContents ) import System.Environment ( getEnvironment ) import qualified Control.Monad.Trans.State.Strict as State import qualified Data.HashSet import qualified Data.Text as Text +import qualified Data.Text.IO as Text.IO import qualified Data.Text.Prettyprint.Doc as Pretty import qualified Data.Text.Prettyprint.Doc.Render.Terminal as Pretty ( renderIO ) import qualified Dhall @@ -74,6 +79,7 @@ , explain :: Bool , characterSet :: CharacterSet , _standardVersion :: StandardVersion + , outputHandle :: Maybe System.IO.Handle } @@ -85,6 +91,7 @@ , explain = False , _standardVersion = Dhall.Binary.defaultStandardVersion , characterSet = Unicode + , outputHandle = Just System.IO.stdout } @@ -138,14 +145,12 @@ modify ( \e -> e { envIt = Just ( Binding expr exprType ) } ) - output System.IO.stdout expr + output expr typeOf :: ( MonadIO m, MonadState Env m ) => [String] -> m () -typeOf [] = - liftIO ( putStrLn ":type requires an argument to check the type of" ) - +typeOf [] = fail ":type requires an argument to check the type of" typeOf srcs = do loaded <- @@ -157,7 +162,7 @@ exprType' <- normalize exprType - output System.IO.stdout exprType' + output exprType' applyContext @@ -202,20 +207,15 @@ -- Separate the equal sign to be its own word in order to simplify parsing -- This is intended to be used with the options that require assignment separateEqual :: [String] -> [String] -separateEqual [] = [] -separateEqual (x:xs) - -- Handle the case where there is no space between the var and "=" - | Just i <- elemIndex '=' x - = let (a, _:b) = splitAt i x - in a : "=" : b : xs - - -- Handle the case where there is no space between the "=" and the expression - | ('=':y):ys <- xs - = x : "=" : y : ys - - | otherwise - = x : xs - +separateEqual [] = + [] +separateEqual (str₀ : ('=' : str₁) : strs) = + str₀ : "=" : str₁ : strs +separateEqual (str : strs) + | (str₀, '=' : str₁) <- break (== '=') str = + str₀ : "=" : str₁ : strs + | otherwise = + str : strs addBinding :: ( MonadIO m, MonadState Env m ) => [String] -> m () addBinding (k : "=" : srcs) = do @@ -243,14 +243,125 @@ } ) - output - System.IO.stdout - ( Expr.Annot ( Expr.Var ( Dhall.V varName 0 ) ) t ) + output ( Expr.Annot ( Expr.Var ( Dhall.V varName 0 ) ) t ) -addBinding _ = - liftIO ( fail ":let should be of the form `:let x = y`" ) +addBinding _ = fail ":let should be of the form `:let x = y`" +hashBinding :: ( MonadIO m, MonadState Env m ) => [String] -> m () +hashBinding [] = fail ":hash should be of the form `:hash expr" +hashBinding tokens = do + loadedExpression <- parseAndLoad (unwords tokens) + + _ <- typeCheck loadedExpression + + normalizedExpression <- normalize loadedExpression + + Env{_standardVersion} <- get + + writeOutputHandle $ hashExpressionToCode _standardVersion normalizedExpression + +saveFilePrefix :: FilePath +saveFilePrefix = ".dhall-repl" + +-- | Find the index for the current _active_ dhall save file +currentSaveFileIndex :: MonadIO m => m (Maybe Int) +currentSaveFileIndex = do + files <- liftIO $ getDirectoryContents "." + + let parseIndex file + | saveFilePrefix `isPrefixOf` file + , '-':index <- drop (length saveFilePrefix) file + , [(x, "")] <- reads index -- safe version of read + = Just x + + | otherwise + = Nothing + + pure $ case mapMaybe parseIndex files of + [] -> Nothing + xs -> Just $ maximum xs + +-- | Find the name for the current _active_ dhall save file +currentSaveFile :: MonadIO m => m (Maybe FilePath) +currentSaveFile = + (fmap . fmap) (\i -> saveFilePrefix <> "-" <> show i) currentSaveFileIndex + +-- | Find the name for the next dhall save file +nextSaveFile :: MonadIO m => m FilePath +nextSaveFile = do + mIndex <- currentSaveFileIndex + + let nextIndex = maybe 0 succ mIndex + + pure $ saveFilePrefix <> "-" <> show nextIndex + +loadBinding + :: ( MonadIO m, MonadState Env m, Haskeline.MonadException m ) + => [String] -> m () +loadBinding [] = do + mFile <- currentSaveFile + + case mFile of + Just file -> loadBinding [file] + Nothing -> + fail $ ":load couldn't find any `" <> saveFilePrefix <> "-*` files" + +loadBinding [file] = do + -- Read commands from the save file + replLines <- map words . lines <$> liftIO (readFile file) + + let runCommand ((c:cmd):opts) + | c == optionsPrefix + , Just action <- lookup cmd options + = action opts + runCommand _ = fail $ + ":load expects `" <> file <> "` to contain one command per line" + + -- Keep current handle in scope + Env { outputHandle } <- get + + -- Discard output + modify (\e -> e { outputHandle = Nothing }) + + -- Run all the commands + forM_ replLines runCommand + + -- Restore the previous handle + modify (\e -> e { outputHandle = outputHandle }) + + writeOutputHandle $ "Loaded `" <> Text.pack file <> "`\n" + +loadBinding _ = fail ":load should be of the form `:load` or `:load file`" + saveBinding :: ( MonadIO m, MonadState Env m ) => [String] -> m () +-- Save all the bindings into a context save file +saveBinding [] = do + file <- nextSaveFile + + saveBinding [file] + +-- Save all the bindings into `file` +saveBinding [file] = do + env <- get + + let bindings + = reverse + . (fmap . fmap) bindingExpr + . Dhall.Context.toList + $ envBindings env + + handler handle = + State.evalStateT + (forM_ bindings $ \(name, expr) -> do + liftIO (System.IO.hPutStr handle $ ":let " <> Text.unpack name <> " = ") + outputWithoutSpacing expr) + (env { outputHandle = Just handle }) + + liftIO (System.IO.withFile file System.IO.WriteMode handler) + + writeOutputHandle $ "Context saved to `" <> Text.pack file <> "`\n" + +-- Save a single expression to `file` saveBinding (file : "=" : tokens) = do loadedExpression <- parseAndLoad (unwords tokens) @@ -261,11 +372,28 @@ env <- get let handler handle = - State.evalStateT (output handle normalizedExpression) env + State.evalStateT + (output normalizedExpression) + (env { outputHandle = Just handle }) liftIO (System.IO.withFile file System.IO.WriteMode handler) -saveBinding _ = fail ":save should be of the form `:save x = y`" + writeOutputHandle $ "Expression saved to `" <> Text.pack file <> "`\n" + +saveBinding _ = fail ":save should be of the form `:save`, `:save file`, or `:save file = expr`" + +setOption :: ( MonadIO m, MonadState Env m ) => [String] -> m () +setOption [ "--explain" ] = do + modify (\e -> e { explain = True }) +setOption _ = do + writeOutputHandle ":set should be of the form `:set `" + +unsetOption :: ( MonadIO m, MonadState Env m ) => [String] -> m () +unsetOption [ "--explain" ] = do + modify (\e -> e { explain = False }) +unsetOption _ = do + writeOutputHandle ":unset should be of the form `:unset `" + cmdQuit :: ( MonadIO m, MonadState Env m ) => [String] -> m () cmdQuit _ = do liftIO (putStrLn "Goodbye.") @@ -281,8 +409,12 @@ => Repline.Options m options = [ ( "type", dontCrash . typeOf ) + , ( "hash", dontCrash . hashBinding ) , ( "let", dontCrash . addBinding . separateEqual ) + , ( "load", dontCrash . loadBinding ) , ( "save", dontCrash . saveBinding . separateEqual ) + , ( "set", dontCrash . setOption) + , ( "unset", dontCrash . unsetOption) , ( "quit", cmdQuit ) ] @@ -309,6 +441,10 @@ | reversedPrev == ":" = pure . listCompletion $ fst <$> (options :: Repline.Options Repl) + -- Complete load command + | reversedPrev == reverse ":load " + = Haskeline.listFiles word + -- Complete file paths | any (`isPrefixOf` word) [ "/", "./", "../", "~/" ] = Haskeline.listFiles word @@ -318,12 +454,11 @@ = listCompletion . fmap fst <$> liftIO getEnvironment -- Complete record fields and union alternatives - | '.' `elem` word + | var : subFields <- Text.split (== '.') (Text.pack word) + , not $ null subFields = do Env { envBindings } <- get - let var:subFields = Text.split (== '.') (Text.pack word) - case Dhall.Context.lookup var 0 envBindings of Nothing -> pure [] @@ -378,26 +513,42 @@ m ( \ e@SomeException{} -> liftIO ( putStrLn ( displayException e ) ) ) +writeOutputHandle :: (MonadIO m, MonadState Env m) => Text -> m () +writeOutputHandle txt = do + Env { outputHandle } <- get + case outputHandle of + Just handle -> liftIO $ Text.IO.hPutStrLn handle txt + Nothing -> pure () + output - :: (Pretty.Pretty a, MonadState Env m, MonadIO m) - => System.IO.Handle -> Dhall.Expr s a -> m () -output handle expr = do - Env { characterSet } <- get + :: (Pretty.Pretty a, MonadState Env m, MonadIO m) + => Dhall.Expr s a -> m () +output expr = do + writeOutputHandle "" -- Visual spacing - liftIO (System.IO.hPutStrLn handle "") -- Visual spacing + outputWithoutSpacing expr - let stream = - Pretty.layoutSmart Dhall.Pretty.layoutOpts - (Dhall.Pretty.prettyCharacterSet characterSet expr) + writeOutputHandle "" -- Visual spacing - supportsANSI <- liftIO (System.Console.ANSI.hSupportsANSI handle) - let ansiStream = - if supportsANSI - then fmap Dhall.Pretty.annToAnsiStyle stream - else Pretty.unAnnotateS stream +outputWithoutSpacing + :: (Pretty.Pretty a, MonadState Env m, MonadIO m) + => Dhall.Expr s a -> m () +outputWithoutSpacing expr = do + Env { characterSet, outputHandle } <- get - liftIO (Pretty.renderIO handle ansiStream) - liftIO (System.IO.hPutStrLn handle "") -- Pretty printing doesn't end with a new line + case outputHandle of + Nothing -> pure () + Just handle -> do + let stream = + Pretty.layoutSmart Dhall.Pretty.layoutOpts + (Dhall.Pretty.prettyCharacterSet characterSet expr) - liftIO (System.IO.hPutStrLn handle "") -- Visual spacing + supportsANSI <- liftIO (System.Console.ANSI.hSupportsANSI handle) + let ansiStream = + if supportsANSI + then fmap Dhall.Pretty.annToAnsiStyle stream + else Pretty.unAnnotateS stream + + liftIO (Pretty.renderIO handle ansiStream) + liftIO (System.IO.hPutStrLn handle "") -- Pretty printing doesn't end with a new line diff --git a/src/Dhall/Tutorial.hs b/src/Dhall/Tutorial.hs --- a/src/Dhall/Tutorial.hs +++ b/src/Dhall/Tutorial.hs @@ -426,6 +426,7 @@ -- ↳ ./file2 -- ... -- Cyclic import: ./file1 +-- ... -- -- You can also import expressions by URL. For example, you can find a Dhall -- expression hosted at this GitHub URL: @@ -476,7 +477,7 @@ -- *** Exception: -- ↳ ./baz: -- ... --- ...Error...: Missing file .../baz: +-- ...Error...: Missing file ...baz: -- ... -- -- This is because the parser thinks that @./baz:@ is a single token due to @@ -1143,48 +1144,28 @@ -- -- > data Example = Empty | Person { name :: Text, age :: Text } -- --- You can resemble Haskell further by defining convenient constructors for each --- alternative, like this: +-- You could resemble Haskell further by defining convenient constructors for +-- each alternative, like this: -- --- > let Empty = < Empty = {=} | Person : { name : Text, age : Natural } > --- > in let Person = --- > λ(p : { name : Text, age : Natural }) → < Person = p | Empty : {} > +-- > let Empty = < Empty = {=} | Person : { name : Text, age : Natural } > +-- > let Person = +-- > λ(p : { name : Text, age : Natural }) → < Person = p | Empty : {} > -- > in [ Empty -- > , Person { name = "John", age = 23 } -- > , Person { name = "Amy" , age = 25 } -- > , Empty -- > ] -- --- ... and Dhall even provides the @constructors@ keyword to automate this --- common pattern: +-- ... but there is no need to do so, since the Dhall language auto-generates +-- constructors for each alternative. You can access each constructor as if it +-- were a field of the union type: -- --- > let MyType = constructors < Empty : {} | Person : { name : Text, age : Natural } > +-- > let MyType = < Empty : {} | Person : { name : Text, age : Natural } > -- > in [ MyType.Empty {=} -- > , MyType.Person { name = "John", age = 23 } -- > , MyType.Person { name = "Amy" , age = 25 } -- > ] -- --- The @constructors@ keyword takes a union type argument and returns a record --- with one field per union type constructor: --- --- > $ dhall --- > constructors < Empty : {} | Person : { name : Text, age : Natural } > --- > --- > --- > { Empty : --- > ∀(Empty : {}) → < Empty : {} | Person : { age : Natural, name : Text } > --- > , Person : --- > ∀(Person : { age : Natural, name : Text }) --- > → < Empty : {} | Person : { age : Natural, name : Text } > --- > } --- > --- > { Empty = --- > λ(Empty : {}) → < Empty = Empty | Person : { age : Natural, name : Text } > --- > , Person = --- > λ(Person : { age : Natural, name : Text }) --- > → < Person = Person | Empty : {} > --- > } --- -- You can also extract fields during pattern matching such as in the following -- function which renders each value to `Text`: -- @@ -1628,7 +1609,7 @@ -- > z) (y.diff (n + List/length { index : Natural, value : a } kvs)) }) { count = -- > 0, diff = λ(_ : Natural) → nil }).diff 0) -- --- ... and run the expression through the the formatter: +-- ... and run the expression through the formatter: -- -- > $ dhall format < ./unformatted -- > λ(a : Type) diff --git a/src/Dhall/TypeCheck.hs b/src/Dhall/TypeCheck.hs --- a/src/Dhall/TypeCheck.hs +++ b/src/Dhall/TypeCheck.hs @@ -359,6 +359,8 @@ Text -> return () _ -> Left (TypeError ctx e (CantTextAppend r tr)) return Text + loop _ TextShow = do + return (Pi "_" Text Text) loop _ List = do return (Pi "_" (Const Type) (Const Type)) loop ctx e@(ListLit Nothing xs) = do @@ -787,13 +789,6 @@ _ -> Left (TypeError ctx e (HandlerNotAFunction kY tX)) mapM_ process (Dhall.Map.toList ktsY) return t - loop ctx e@(Constructors t ) = do - _ <- loop ctx t - - case Dhall.Core.normalize t of - u@(Union _) -> loop ctx u - t' -> Left (TypeError ctx e (ConstructorsRequiresAUnionType t t')) - loop ctx e@(Field r x ) = do t <- fmap Dhall.Core.normalize (loop ctx r) @@ -945,8 +940,7 @@ _NOT = "\ESC[1mnot\ESC[0m" insert :: Pretty a => a -> Doc Ann -insert expression = - "↳ " <> Pretty.align (Dhall.Util.snipDoc (Pretty.pretty expression)) +insert = Dhall.Util.insert prettyDiff :: (Eq a, Pretty a) => Expr s a -> Expr s a -> Doc Ann prettyDiff exprL exprR = Dhall.Diff.diffNormalized exprL exprR diff --git a/src/Dhall/Util.hs b/src/Dhall/Util.hs --- a/src/Dhall/Util.hs +++ b/src/Dhall/Util.hs @@ -5,11 +5,12 @@ module Dhall.Util ( snip , snipDoc + , insert ) where import Data.Monoid ((<>)) import Data.Text (Text) -import Data.Text.Prettyprint.Doc (Doc) +import Data.Text.Prettyprint.Doc (Doc, Pretty) import Dhall.Pretty (Ann) import qualified Data.Text @@ -67,3 +68,8 @@ where go (_:xs) (_:ys) = go xs ys go _ r = r + +-- | Function to insert an aligned pretty expression +insert :: Pretty a => a -> Doc Ann +insert expression = + "↳ " <> Pretty.align (snipDoc (Pretty.pretty expression)) diff --git a/tests/Dhall/Test/Dhall.hs b/tests/Dhall/Test/Dhall.hs new file mode 100644 --- /dev/null +++ b/tests/Dhall/Test/Dhall.hs @@ -0,0 +1,59 @@ +{-# LANGUAGE OverloadedStrings #-} +{-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE ScopedTypeVariables #-} +module Dhall.Test.Dhall where + +import Control.Exception (SomeException, try) +import Numeric.Natural (Natural) +import Test.Tasty +import Test.Tasty.HUnit + +import qualified Dhall +import qualified Dhall.Core +import qualified Dhall.Map + +tests :: TestTree +tests = + testGroup "Input" + [ shouldShowDetailedTypeError ] + +data MyType = MyType { foo :: String , bar :: Natural } + +wrongDhallType :: Dhall.Type MyType +wrongDhallType = Dhall.Type { .. } + where expected = + Dhall.Core.Record + ( Dhall.Map.fromList + [ ( "bar", Dhall.Core.Natural) + , ( "foo", Dhall.Core.Text ) + ] + ) + extract _ = Nothing + +shouldShowDetailedTypeError :: TestTree +shouldShowDetailedTypeError = testCase "detailed TypeError" $ do + inputEx :: Either SomeException MyType <- + try ( Dhall.input wrongDhallType "{ bar = 0, foo = \"foo\" }") + + let expectedMsg = + "\ESC[1;31mError\ESC[0m: Invalid Dhall.Type \n\ + \ \n\ + \Every Type must provide an extract function that succeeds if an expression \n\ + \matches the expected type. You provided a Type that disobeys this contract \n\ + \ \n\ + \The Type provided has the expected dhall type: \n\ + \ \n\ + \↳ { bar : Natural, foo : Text }\n\ + \ \n\ + \and it couldn't extract a value from the well-typed expression: \n\ + \ \n\ + \↳ { bar = 0, foo = \"foo\" }\n\ + \ \n" + + let assertMsg = "The exception message did not match the expected output" + + case inputEx of + Left ex -> assertEqual assertMsg expectedMsg (show ex) + Right _ -> fail "The extraction using a wrong type succeded" + + diff --git a/tests/Dhall/Test/Import.hs b/tests/Dhall/Test/Import.hs --- a/tests/Dhall/Test/Import.hs +++ b/tests/Dhall/Test/Import.hs @@ -5,6 +5,7 @@ import Data.Text (Text) import Test.Tasty (TestTree) import Dhall.Import (MissingImports(..)) +import Dhall.Parser (SourcedException(..)) import Control.Exception (catch, throwIO) import Data.Monoid ((<>)) @@ -23,38 +24,30 @@ [ shouldFail 3 "alternative of several unset env variables" - "./tests/import/failure/alternativeEnv.dhall" + "./dhall-lang/tests/import/failure/alternativeEnv.dhall" , shouldFail 1 "alternative of env variable and missing" - "./tests/import/failure/alternativeEnvMissing.dhall" + "./dhall-lang/tests/import/failure/alternativeEnvMissing.dhall" , shouldFail 0 "just missing" - "./tests/import/failure/missing.dhall" + "./dhall-lang/tests/import/failure/missing.dhall" , shouldNotFail "alternative of env variable, missing, and a Natural" - "./tests/import/success/alternativeEnvNaturalA.dhall" + "./dhall-lang/tests/import/success/alternativeEnvNaturalA.dhall" , shouldNotFail "alternative of env variable and a Natural" - "./tests/import/success/alternativeEnvSimpleA.dhall" + "./dhall-lang/tests/import/success/alternativeEnvSimpleA.dhall" , shouldNotFail "alternative of a Natural and missing" - "./tests/import/success/alternativeNaturalA.dhall" + "./dhall-lang/tests/import/success/alternativeNaturalA.dhall" ] , Test.Tasty.testGroup "import relative to argument" [ shouldNotFailRelative - "works" - "./tests/import/data/foo/bar" - "./tests/import/success/relative.dhall" - , shouldNotFailRelative "a semantic integrity check if fields are reordered" - "./tests/import/success/" - "./tests/import/success/fieldOrderA.dhall" - , shouldNotFailRelative - "a semantic integrity check when importing an expression using `constructors`" - "./tests/import/success/" - "./tests/import/success/issue553B.dhall" + "./dhall-lang/tests/import/success/" + "./dhall-lang/tests/import/success/fieldOrderA.dhall" ] ] @@ -88,9 +81,13 @@ (do _ <- Dhall.Import.load actualExpr fail "Import should have failed, but it succeeds") - (\(MissingImports es) -> case length es == failures of - True -> pure () - False -> fail ("Should have failed " - <> show failures - <> " times, but failed with: \n" - <> show es)) ) + (\(SourcedException _ (MissingImports es)) -> + case length es == failures of + True -> pure () + False -> fail + ( "Should have failed " + <> show failures + <> " times, but failed with: \n" + <> show es + ) + ) ) diff --git a/tests/Dhall/Test/Lint.hs b/tests/Dhall/Test/Lint.hs --- a/tests/Dhall/Test/Lint.hs +++ b/tests/Dhall/Test/Lint.hs @@ -22,6 +22,9 @@ [ should "correctly handle multi-let expressions" "success/multilet" + , should + "not fail when an inner expression removes all `let` bindings" + "success/regression0" ] should :: Text -> Text -> TestTree diff --git a/tests/Dhall/Test/Main.hs b/tests/Dhall/Test/Main.hs --- a/tests/Dhall/Test/Main.hs +++ b/tests/Dhall/Test/Main.hs @@ -1,7 +1,8 @@ module Main where -import Test.Tasty (TestTree) +import Test.Tasty (TestTree) +import qualified Dhall.Test.Dhall import qualified Dhall.Test.Format import qualified Dhall.Test.Import import qualified Dhall.Test.Lint @@ -11,11 +12,13 @@ import qualified Dhall.Test.Regression import qualified Dhall.Test.Tutorial import qualified Dhall.Test.TypeCheck +import qualified GHC.IO.Encoding import qualified System.Directory import qualified System.Environment +import qualified System.IO import qualified Test.Tasty -import System.FilePath (()) +import System.FilePath (()) allTests :: TestTree allTests = @@ -29,10 +32,13 @@ , Dhall.Test.Import.tests , Dhall.Test.QuickCheck.tests , Dhall.Test.Lint.tests + , Dhall.Test.Dhall.tests ] main :: IO () main = do + + GHC.IO.Encoding.setLocaleEncoding System.IO.utf8 pwd <- System.Directory.getCurrentDirectory System.Environment.setEnv "XDG_CACHE_HOME" (pwd ".cache") Test.Tasty.defaultMain allTests diff --git a/tests/Dhall/Test/Normalization.hs b/tests/Dhall/Test/Normalization.hs --- a/tests/Dhall/Test/Normalization.hs +++ b/tests/Dhall/Test/Normalization.hs @@ -184,6 +184,8 @@ , shouldNormalize "Text/concatMapSep" "./success/prelude/Text/concatMapSep/1" , shouldNormalize "Text/concatSep" "./success/prelude/Text/concatSep/0" , shouldNormalize "Text/concatSep" "./success/prelude/Text/concatSep/1" + , shouldNormalize "Text/show" "./success/prelude/Text/show/0" + , shouldNormalize "Text/show" "./success/prelude/Text/show/1" ] simplifications :: TestTree @@ -276,8 +278,8 @@ should :: Text -> Text -> TestTree should name basename = Test.Tasty.HUnit.testCase (Data.Text.unpack name) $ do - let actualCode = "./tests/normalization/" <> basename <> "A.dhall" - let expectedCode = "./tests/normalization/" <> basename <> "B.dhall" + let actualCode = "./dhall-lang/tests/normalization/" <> basename <> "A.dhall" + let expectedCode = "./dhall-lang/tests/normalization/" <> basename <> "B.dhall" actualExpr <- case Dhall.Parser.exprFromText mempty actualCode of Left err -> Control.Exception.throwIO err diff --git a/tests/Dhall/Test/Parser.hs b/tests/Dhall/Test/Parser.hs --- a/tests/Dhall/Test/Parser.hs +++ b/tests/Dhall/Test/Parser.hs @@ -2,12 +2,15 @@ module Dhall.Test.Parser where -import Data.Text (Text) -import Test.Tasty (TestTree) +import Data.Text (Text) +import Test.Tasty (TestTree) +import qualified Codec.Serialise import qualified Control.Exception +import qualified Data.ByteString.Lazy import qualified Data.Text import qualified Data.Text.IO +import qualified Dhall.Binary import qualified Dhall.Parser import qualified Test.Tasty import qualified Test.Tasty.HUnit @@ -18,163 +21,168 @@ [ Test.Tasty.testGroup "whitespace" [ shouldParse "prefix/suffix" - "./tests/parser/success/whitespace" + "./dhall-lang/tests/parser/success/whitespace" , shouldParse "block comment" - "./tests/parser/success/blockComment" + "./dhall-lang/tests/parser/success/blockComment" , shouldParse "nested block comment" - "./tests/parser/success/nestedBlockComment" + "./dhall-lang/tests/parser/success/nestedBlockComment" , shouldParse "line comment" - "./tests/parser/success/lineComment" + "./dhall-lang/tests/parser/success/lineComment" , shouldParse "Unicode comment" - "./tests/parser/success/unicodeComment" + "./dhall-lang/tests/parser/success/unicodeComment" , shouldParse "whitespace buffet" - "./tests/parser/success/whitespaceBuffet" + "./dhall-lang/tests/parser/success/whitespaceBuffet" ] , shouldParse "label" - "./tests/parser/success/label" + "./dhall-lang/tests/parser/success/label" , shouldParse "quoted label" - "./tests/parser/success/quotedLabel" + "./dhall-lang/tests/parser/success/quotedLabel" , shouldParse "double quoted string" - "./tests/parser/success/doubleQuotedString" + "./dhall-lang/tests/parser/success/doubleQuotedString" , shouldParse "Unicode double quoted string" - "./tests/parser/success/unicodeDoubleQuotedString" + "./dhall-lang/tests/parser/success/unicodeDoubleQuotedString" , shouldParse "escaped double quoted string" - "./tests/parser/success/escapedDoubleQuotedString" + "./dhall-lang/tests/parser/success/escapedDoubleQuotedString" , shouldParse "interpolated double quoted string" - "./tests/parser/success/interpolatedDoubleQuotedString" + "./dhall-lang/tests/parser/success/interpolatedDoubleQuotedString" , shouldParse "single quoted string" - "./tests/parser/success/singleQuotedString" + "./dhall-lang/tests/parser/success/singleQuotedString" , shouldParse "escaped single quoted string" - "./tests/parser/success/escapedSingleQuotedString" + "./dhall-lang/tests/parser/success/escapedSingleQuotedString" , shouldParse "interpolated single quoted string" - "./tests/parser/success/interpolatedSingleQuotedString" + "./dhall-lang/tests/parser/success/interpolatedSingleQuotedString" , shouldParse "double" - "./tests/parser/success/double" + "./dhall-lang/tests/parser/success/double" , shouldParse "natural" - "./tests/parser/success/natural" + "./dhall-lang/tests/parser/success/natural" , shouldParse "identifier" - "./tests/parser/success/identifier" + "./dhall-lang/tests/parser/success/identifier" , shouldParse "paths" - "./tests/parser/success/paths" + "./dhall-lang/tests/parser/success/paths" , shouldParse "path termination" - "./tests/parser/success/pathTermination" + "./dhall-lang/tests/parser/success/pathTermination" , shouldParse "urls" - "./tests/parser/success/urls" + "./dhall-lang/tests/parser/success/urls" , shouldParse "environmentVariables" - "./tests/parser/success/environmentVariables" + "./dhall-lang/tests/parser/success/environmentVariables" , shouldParse "lambda" - "./tests/parser/success/lambda" + "./dhall-lang/tests/parser/success/lambda" , shouldParse "if then else" - "./tests/parser/success/ifThenElse" + "./dhall-lang/tests/parser/success/ifThenElse" , shouldParse "let" - "./tests/parser/success/let" + "./dhall-lang/tests/parser/success/let" , shouldParse "forall" - "./tests/parser/success/forall" + "./dhall-lang/tests/parser/success/forall" , shouldParse "function type" - "./tests/parser/success/functionType" + "./dhall-lang/tests/parser/success/functionType" , shouldParse "operators" - "./tests/parser/success/operators" + "./dhall-lang/tests/parser/success/operators" , shouldParse "annotations" - "./tests/parser/success/annotations" + "./dhall-lang/tests/parser/success/annotations" , shouldParse "merge" - "./tests/parser/success/merge" - , shouldParse - "constructors" - "./tests/parser/success/constructors" + "./dhall-lang/tests/parser/success/merge" , shouldParse "fields" - "./tests/parser/success/fields" + "./dhall-lang/tests/parser/success/fields" , shouldParse "record" - "./tests/parser/success/record" + "./dhall-lang/tests/parser/success/record" , shouldParse "union" - "./tests/parser/success/union" + "./dhall-lang/tests/parser/success/union" , shouldParse "list" - "./tests/parser/success/list" + "./dhall-lang/tests/parser/success/list" , shouldParse "builtins" - "./tests/parser/success/builtins" + "./dhall-lang/tests/parser/success/builtins" , shouldParse "import alternatives" - "./tests/parser/success/importAlt" + "./dhall-lang/tests/parser/success/importAlt" , shouldParse "large expression" - "./tests/parser/success/largeExpression" + "./dhall-lang/tests/parser/success/largeExpression" , shouldParse "names that begin with reserved identifiers" - "./tests/parser/success/reservedPrefix" + "./dhall-lang/tests/parser/success/reservedPrefix" , shouldParse "interpolated expressions with leading whitespace" - "./tests/parser/success/template" + "./dhall-lang/tests/parser/success/template" , shouldParse "collections with type annotations containing imports" - "./tests/parser/success/collectionImportType" + "./dhall-lang/tests/parser/success/collectionImportType" , shouldParse "a parenthesized custom header import" - "./tests/parser/success/parenthesizeUsing" + "./dhall-lang/tests/parser/success/parenthesizeUsing" , shouldNotParse "accessing a field of an import without parentheses" - "./tests/parser/failure/importAccess.dhall" + "./dhall-lang/tests/parser/failure/importAccess.dhall" , shouldParse "Sort" - "./tests/parser/success/sort" + "./dhall-lang/tests/parser/success/sort" , shouldParse "quoted path components" - "./tests/parser/success/quotedPaths" + "./dhall-lang/tests/parser/success/quotedPaths" , shouldNotParse "positive double out of bounds" - "./tests/parser/failure/doubleBoundsPos.dhall" + "./dhall-lang/tests/parser/failure/doubleBoundsPos.dhall" , shouldNotParse "negative double out of bounds" - "./tests/parser/failure/doubleBoundsNeg.dhall" + "./dhall-lang/tests/parser/failure/doubleBoundsNeg.dhall" , shouldParse "as Text" - "./tests/parser/success/asText" - , shouldParse - "custom headers" - "./tests/parser/success/customHeaders" + "./dhall-lang/tests/parser/success/asText" , shouldNotParse "a multi-line literal without an initial newline" - "./tests/parser/failure/mandatoryNewline.dhall" + "./dhall-lang/tests/parser/failure/mandatoryNewline.dhall" + , shouldParse + "a Unicode path component" + "./dhall-lang/tests/parser/success/unicodePaths" ] shouldParse :: Text -> FilePath -> TestTree -shouldParse name path = Test.Tasty.HUnit.testCase (Data.Text.unpack name) (do - text <- Data.Text.IO.readFile (path <> "A.dhall") - case Dhall.Parser.exprFromText mempty text of - Left err -> Control.Exception.throwIO err - Right _ -> return () ) +shouldParse name path = Test.Tasty.HUnit.testCase (Data.Text.unpack name) $ do + text <- Data.Text.IO.readFile (path <> "A.dhall") + encoded <- Data.ByteString.Lazy.readFile (path <> "B.dhallb") + + expression <- case Dhall.Parser.exprFromText mempty text of + Left e -> Control.Exception.throwIO e + Right a -> pure a + + let term = Dhall.Binary.encode expression + bytes = Codec.Serialise.serialise term + + let message = "The expected CBOR representation doesn't match the actual one" + Test.Tasty.HUnit.assertEqual message encoded bytes shouldNotParse :: Text -> FilePath -> TestTree shouldNotParse name path = Test.Tasty.HUnit.testCase (Data.Text.unpack name) (do diff --git a/tests/Dhall/Test/QuickCheck.hs b/tests/Dhall/Test/QuickCheck.hs --- a/tests/Dhall/Test/QuickCheck.hs +++ b/tests/Dhall/Test/QuickCheck.hs @@ -36,6 +36,7 @@ import qualified Codec.Serialise import qualified Data.Coerce +import qualified Data.List import qualified Dhall.Map import qualified Data.Sequence import qualified Dhall.Binary @@ -124,7 +125,8 @@ arbitrary = do n <- Test.QuickCheck.choose (0, 2) kvs <- Test.QuickCheck.vectorOf n ((,) <$> arbitrary <*> arbitrary) - return (Dhall.Map.fromList kvs) + -- Sorting the fields here because serialization needs them in order + return (Dhall.Map.fromList (Data.List.sortOn fst kvs)) shrink = map Dhall.Map.fromList @@ -237,7 +239,6 @@ , ( 1, lift2 CombineTypes) , ( 1, lift2 Prefer) , ( 1, lift3 Merge) - , ( 1, lift1 Constructors) , ( 1, lift2 Field) , ( 1, lift2 Project) , ( 7, lift1 Embed) @@ -334,10 +335,10 @@ binaryRoundtrip expression = wrap (fmap - Dhall.Binary.decodeWithVersion + Dhall.Binary.decode (Codec.Serialise.deserialiseOrFail (Codec.Serialise.serialise - (Dhall.Binary.encodeWithVersion Dhall.Binary.defaultStandardVersion expression) + (Dhall.Binary.encode expression) ) ) ) diff --git a/tests/Dhall/Test/Regression.hs b/tests/Dhall/Test/Regression.hs --- a/tests/Dhall/Test/Regression.hs +++ b/tests/Dhall/Test/Regression.hs @@ -20,7 +20,6 @@ import qualified Test.Tasty import qualified Test.Tasty.HUnit -import Control.DeepSeq (($!!)) import Dhall.Import (Imported) import Dhall.Parser (Src) import Dhall.TypeCheck (TypeError, X) @@ -35,7 +34,6 @@ , issue151 , issue164 , issue201 - , issue209 , issue216 , issue253 , parsing0 @@ -130,15 +128,6 @@ issue201 = Test.Tasty.HUnit.testCase "Issue #201" (do -- Verify that type synonyms work _ <- Util.code "./tests/regression/issue201.dhall" - return () ) - -issue209 :: TestTree -issue209 = Test.Tasty.HUnit.testCase "Issue #209" (do - -- Verify that pretty-printing `constructors` doesn't trigger an infinite - -- loop - e <- Util.code "./tests/regression/issue209.dhall" - let text = Dhall.Core.pretty e - Just _ <- System.Timeout.timeout 1000000 (Control.Exception.evaluate $!! text) return () ) issue216 :: TestTree diff --git a/tests/Dhall/Test/TypeCheck.hs b/tests/Dhall/Test/TypeCheck.hs --- a/tests/Dhall/Test/TypeCheck.hs +++ b/tests/Dhall/Test/TypeCheck.hs @@ -96,8 +96,8 @@ should :: Text -> Text -> TestTree should name basename = Test.Tasty.HUnit.testCase (Data.Text.unpack name) $ do - let actualCode = "./tests/typecheck/" <> basename <> "A.dhall" - let expectedCode = "./tests/typecheck/" <> basename <> "B.dhall" + let actualCode = "./dhall-lang/tests/typecheck/" <> basename <> "A.dhall" + let expectedCode = "./dhall-lang/tests/typecheck/" <> basename <> "B.dhall" actualExpr <- case Dhall.Parser.exprFromText mempty actualCode of Left err -> Control.Exception.throwIO err @@ -116,7 +116,7 @@ shouldNotTypeCheck :: Text -> Text -> TestTree shouldNotTypeCheck name basename = Test.Tasty.HUnit.testCase (Data.Text.unpack name) $ do - let code = "./tests/typecheck/" <> basename <> ".dhall" + let code = "./dhall-lang/tests/typecheck/" <> basename <> ".dhall" expression <- case Dhall.Parser.exprFromText mempty code of Left exception -> Control.Exception.throwIO exception diff --git a/tests/import/data/fieldOrder/1.dhall b/tests/import/data/fieldOrder/1.dhall deleted file mode 100644 --- a/tests/import/data/fieldOrder/1.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ foo = 1, bar = True } diff --git a/tests/import/data/fieldOrder/2.dhall b/tests/import/data/fieldOrder/2.dhall deleted file mode 100644 --- a/tests/import/data/fieldOrder/2.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ bar = True, foo = 1 } diff --git a/tests/import/data/foo/bar/a.dhall b/tests/import/data/foo/bar/a.dhall deleted file mode 100644 --- a/tests/import/data/foo/bar/a.dhall +++ /dev/null @@ -1,1 +0,0 @@ -42 diff --git a/tests/import/failure/alternativeEnv.dhall b/tests/import/failure/alternativeEnv.dhall deleted file mode 100644 --- a/tests/import/failure/alternativeEnv.dhall +++ /dev/null @@ -1,1 +0,0 @@ -env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 diff --git a/tests/import/failure/alternativeEnvMissing.dhall b/tests/import/failure/alternativeEnvMissing.dhall deleted file mode 100644 --- a/tests/import/failure/alternativeEnvMissing.dhall +++ /dev/null @@ -1,1 +0,0 @@ -env:UNSET ? missing diff --git a/tests/import/failure/missing.dhall b/tests/import/failure/missing.dhall deleted file mode 100644 --- a/tests/import/failure/missing.dhall +++ /dev/null @@ -1,1 +0,0 @@ -missing diff --git a/tests/import/success/alternativeEnvNaturalA.dhall b/tests/import/success/alternativeEnvNaturalA.dhall deleted file mode 100644 --- a/tests/import/success/alternativeEnvNaturalA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2 diff --git a/tests/import/success/alternativeEnvNaturalB.dhall b/tests/import/success/alternativeEnvNaturalB.dhall deleted file mode 100644 --- a/tests/import/success/alternativeEnvNaturalB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -2 diff --git a/tests/import/success/alternativeEnvSimpleA.dhall b/tests/import/success/alternativeEnvSimpleA.dhall deleted file mode 100644 --- a/tests/import/success/alternativeEnvSimpleA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -env:UNSET ? 3 diff --git a/tests/import/success/alternativeEnvSimpleB.dhall b/tests/import/success/alternativeEnvSimpleB.dhall deleted file mode 100644 --- a/tests/import/success/alternativeEnvSimpleB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -3 diff --git a/tests/import/success/alternativeNaturalA.dhall b/tests/import/success/alternativeNaturalA.dhall deleted file mode 100644 --- a/tests/import/success/alternativeNaturalA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -4 ? missing diff --git a/tests/import/success/alternativeNaturalB.dhall b/tests/import/success/alternativeNaturalB.dhall deleted file mode 100644 --- a/tests/import/success/alternativeNaturalB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -4 diff --git a/tests/import/success/fieldOrderA.dhall b/tests/import/success/fieldOrderA.dhall deleted file mode 100644 --- a/tests/import/success/fieldOrderA.dhall +++ /dev/null @@ -1,5 +0,0 @@ -{ example0 = - ../data/fieldOrder/1.dhall sha256:261b3aca810973f81175d19b16226aaa5e76df7ea51c5d45e890dd6cdc49abbd -, example1 = - ../data/fieldOrder/2.dhall sha256:261b3aca810973f81175d19b16226aaa5e76df7ea51c5d45e890dd6cdc49abbd -} diff --git a/tests/import/success/fieldOrderB.dhall b/tests/import/success/fieldOrderB.dhall deleted file mode 100644 --- a/tests/import/success/fieldOrderB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ example0 = { bar = True, foo = 1 }, example1 = { bar = True, foo = 1 } } diff --git a/tests/import/success/issue553A.dhall b/tests/import/success/issue553A.dhall deleted file mode 100644 --- a/tests/import/success/issue553A.dhall +++ /dev/null @@ -1,5 +0,0 @@ - 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 deleted file mode 100644 --- a/tests/import/success/issue553B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -./issue553A.dhall sha256:250873549ddd262f27f3b197b2a2631fb569e7bdfe12446fc0912b4a2359a83e diff --git a/tests/import/success/relative.dhall b/tests/import/success/relative.dhall deleted file mode 100644 --- a/tests/import/success/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/lint/success/regression0A.dhall b/tests/lint/success/regression0A.dhall new file mode 100644 --- /dev/null +++ b/tests/lint/success/regression0A.dhall @@ -0,0 +1,7 @@ + let replicate = https://prelude.dhall-lang.org/List/replicate + +in let Config = { name : Text, age : Natural } + +in let Configs = List Config + +in replicate 10 Text "!" diff --git a/tests/lint/success/regression0B.dhall b/tests/lint/success/regression0B.dhall new file mode 100644 --- /dev/null +++ b/tests/lint/success/regression0B.dhall @@ -0,0 +1,3 @@ +let replicate = https://prelude.dhall-lang.org/List/replicate + +in replicate 10 Text "!" diff --git a/tests/normalization/success/haskell-tutorial/access/0A.dhall b/tests/normalization/success/haskell-tutorial/access/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/access/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ x = "foo" }.x diff --git a/tests/normalization/success/haskell-tutorial/access/0B.dhall b/tests/normalization/success/haskell-tutorial/access/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/access/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"foo" diff --git a/tests/normalization/success/haskell-tutorial/access/1A.dhall b/tests/normalization/success/haskell-tutorial/access/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/access/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -< 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 deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/access/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(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 deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/combineTypes/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ 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 deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/combineTypes/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ 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 deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/combineTypes/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ 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 deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/combineTypes/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ 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 deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/prefer/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ 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 deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/prefer/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ 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 deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/projection/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ 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 deleted file mode 100644 --- a/tests/normalization/success/haskell-tutorial/projection/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ x = 1, y = True } diff --git a/tests/normalization/success/multiline/escapeA.dhall b/tests/normalization/success/multiline/escapeA.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/escapeA.dhall +++ /dev/null @@ -1,9 +0,0 @@ --- Verify that an implementation is processing escape sequences correctly - -'' -''${ -''' -$ -" -\ -'' diff --git a/tests/normalization/success/multiline/escapeB.dhall b/tests/normalization/success/multiline/escapeB.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/escapeB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"\${\n''\n\$\n\"\n\\\n" diff --git a/tests/normalization/success/multiline/hangingIndentA.dhall b/tests/normalization/success/multiline/hangingIndentA.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/hangingIndentA.dhall +++ /dev/null @@ -1,15 +0,0 @@ -{- The indent is computed as the minimum number of leading spaces over all lines - in a multi-line literal, including the line right before the closing quotes. - In this case, there are three lines: - - * The first line containing " foo" with two leading spaces - * The second line containing " bar" with two leading spaces - * The third line containing " " with two leading spaces - - Therefore we strip two leading spaces from all three lines --} - -'' - foo - bar - '' diff --git a/tests/normalization/success/multiline/hangingIndentB.dhall b/tests/normalization/success/multiline/hangingIndentB.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/hangingIndentB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"foo\nbar\n" diff --git a/tests/normalization/success/multiline/interestingA.dhall b/tests/normalization/success/multiline/interestingA.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/interestingA.dhall +++ /dev/null @@ -1,7 +0,0 @@ --- Non-trivial example that combines several multi-line literal features - -λ(x : Text) → '' - ${x} baz - bar - foo - '' diff --git a/tests/normalization/success/multiline/interestingB.dhall b/tests/normalization/success/multiline/interestingB.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/interestingB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(x : Text) → "${x} baz\n bar\n foo\n " diff --git a/tests/normalization/success/multiline/interiorIndentA.dhall b/tests/normalization/success/multiline/interiorIndentA.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/interiorIndentA.dhall +++ /dev/null @@ -1,16 +0,0 @@ -{- The indent is computed as the minimum number of leading spaces over all lines - in a multi-line literal, including the line right before the closing quotes. - In this case, there are three lines: - - * The first line containing " foo" with two leading spaces - * The second line containing " bar" with two leading spaces - * The third line containing "" with zero leading spaces - - Since the last line has zero leading spaces, the minimum number of leading - spaces over all three lines is zero, so we don't strip any spaces. --} - -'' - foo - bar -'' diff --git a/tests/normalization/success/multiline/interiorIndentB.dhall b/tests/normalization/success/multiline/interiorIndentB.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/interiorIndentB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -" foo\n bar\n" diff --git a/tests/normalization/success/multiline/interpolationA.dhall b/tests/normalization/success/multiline/interpolationA.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/interpolationA.dhall +++ /dev/null @@ -1,9 +0,0 @@ -{- This example verifies that an implementation is correctly breaking leading - spaces at interpolated expressions. The first line has the fewest number of - leading spaces (2) due to the interruption by the interpolated expression. --} - -'' -${Natural/show 1} foo - bar -'' diff --git a/tests/normalization/success/multiline/interpolationB.dhall b/tests/normalization/success/multiline/interpolationB.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/interpolationB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"${Natural/show 1} foo\n bar\n" diff --git a/tests/normalization/success/multiline/preserveCommentA.dhall b/tests/normalization/success/multiline/preserveCommentA.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/preserveCommentA.dhall +++ /dev/null @@ -1,8 +0,0 @@ -{- A comment within the interior of a multi-line literal counts as part of the - literal --} - -'' --- Hello -{- world -} -'' diff --git a/tests/normalization/success/multiline/preserveCommentB.dhall b/tests/normalization/success/multiline/preserveCommentB.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/preserveCommentB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"-- Hello\n{- world -}\n" diff --git a/tests/normalization/success/multiline/singleLineA.dhall b/tests/normalization/success/multiline/singleLineA.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/singleLineA.dhall +++ /dev/null @@ -1,6 +0,0 @@ -{- This is how you encode a multi-line literal that contains no newlines - - The leading newline is stripped --} -'' -foo'' diff --git a/tests/normalization/success/multiline/singleLineB.dhall b/tests/normalization/success/multiline/singleLineB.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/singleLineB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"foo" diff --git a/tests/normalization/success/multiline/twoLinesA.dhall b/tests/normalization/success/multiline/twoLinesA.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/twoLinesA.dhall +++ /dev/null @@ -1,7 +0,0 @@ -{- Verify that an implementation is correctly preserving newlines in the - corresponding double-quoted literal --} - -'' -foo -bar'' diff --git a/tests/normalization/success/multiline/twoLinesB.dhall b/tests/normalization/success/multiline/twoLinesB.dhall deleted file mode 100644 --- a/tests/normalization/success/multiline/twoLinesB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"foo\nbar" diff --git a/tests/normalization/success/prelude/Bool/and/0A.dhall b/tests/normalization/success/prelude/Bool/and/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/and/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/and/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Bool/and/1A.dhall b/tests/normalization/success/prelude/Bool/and/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/and/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/and/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Bool/build/0A.dhall b/tests/normalization/success/prelude/Bool/build/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Bool/build/0B.dhall b/tests/normalization/success/prelude/Bool/build/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Bool/build/1A.dhall b/tests/normalization/success/prelude/Bool/build/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Bool/build/1B.dhall b/tests/normalization/success/prelude/Bool/build/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Bool/even/0A.dhall b/tests/normalization/success/prelude/Bool/even/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/even/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/even/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Bool/even/1A.dhall b/tests/normalization/success/prelude/Bool/even/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/even/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/even/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Bool/even/2A.dhall b/tests/normalization/success/prelude/Bool/even/2A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/even/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/even/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Bool/even/3A.dhall b/tests/normalization/success/prelude/Bool/even/3A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/even/3A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/even/3B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Bool/fold/0A.dhall b/tests/normalization/success/prelude/Bool/fold/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/fold/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/success/prelude/Bool/fold/1A.dhall b/tests/normalization/success/prelude/Bool/fold/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/fold/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -1 diff --git a/tests/normalization/success/prelude/Bool/not/0A.dhall b/tests/normalization/success/prelude/Bool/not/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/not/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/not/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Bool/not/1A.dhall b/tests/normalization/success/prelude/Bool/not/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/not/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/not/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Bool/odd/0A.dhall b/tests/normalization/success/prelude/Bool/odd/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/odd/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/odd/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Bool/odd/1A.dhall b/tests/normalization/success/prelude/Bool/odd/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/odd/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/odd/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Bool/odd/2A.dhall b/tests/normalization/success/prelude/Bool/odd/2A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/odd/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/odd/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Bool/odd/3A.dhall b/tests/normalization/success/prelude/Bool/odd/3A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/odd/3A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/odd/3B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Bool/or/0A.dhall b/tests/normalization/success/prelude/Bool/or/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/or/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/or/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Bool/or/1A.dhall b/tests/normalization/success/prelude/Bool/or/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/or/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/or/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Bool/show/0A.dhall b/tests/normalization/success/prelude/Bool/show/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"True" diff --git a/tests/normalization/success/prelude/Bool/show/1A.dhall b/tests/normalization/success/prelude/Bool/show/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Bool/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"False" diff --git a/tests/normalization/success/prelude/Double/show/0A.dhall b/tests/normalization/success/prelude/Double/show/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Double/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Double/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"-3.1" diff --git a/tests/normalization/success/prelude/Double/show/1A.dhall b/tests/normalization/success/prelude/Double/show/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Double/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Double/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"0.4" diff --git a/tests/normalization/success/prelude/Integer/show/0A.dhall b/tests/normalization/success/prelude/Integer/show/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Integer/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Integer/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"-3" diff --git a/tests/normalization/success/prelude/Integer/show/1A.dhall b/tests/normalization/success/prelude/Integer/show/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Integer/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Integer/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"+0" diff --git a/tests/normalization/success/prelude/Integer/toDouble/0A.dhall b/tests/normalization/success/prelude/Integer/toDouble/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Integer/toDouble/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Integer/toDouble/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ --3.0 diff --git a/tests/normalization/success/prelude/Integer/toDouble/1A.dhall b/tests/normalization/success/prelude/Integer/toDouble/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Integer/toDouble/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Integer/toDouble/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -2.0 diff --git a/tests/normalization/success/prelude/List/all/0A.dhall b/tests/normalization/success/prelude/List/all/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/all/0B.dhall b/tests/normalization/success/prelude/List/all/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/all/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/List/all/1A.dhall b/tests/normalization/success/prelude/List/all/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/all/1B.dhall b/tests/normalization/success/prelude/List/all/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/all/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/List/any/0A.dhall b/tests/normalization/success/prelude/List/any/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/any/0B.dhall b/tests/normalization/success/prelude/List/any/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/any/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/List/any/1A.dhall b/tests/normalization/success/prelude/List/any/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/any/1B.dhall b/tests/normalization/success/prelude/List/any/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/any/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/List/build/0A.dhall b/tests/normalization/success/prelude/List/build/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/build/0B.dhall b/tests/normalization/success/prelude/List/build/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ "ABC", "DEF" ] diff --git a/tests/normalization/success/prelude/List/build/1A.dhall b/tests/normalization/success/prelude/List/build/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/build/1B.dhall b/tests/normalization/success/prelude/List/build/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Text diff --git a/tests/normalization/success/prelude/List/concat/0A.dhall b/tests/normalization/success/prelude/List/concat/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/concat/0B.dhall b/tests/normalization/success/prelude/List/concat/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/concat/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 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 deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/concat/1B.dhall b/tests/normalization/success/prelude/List/concat/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/concat/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/success/prelude/List/concatMap/0A.dhall b/tests/normalization/success/prelude/List/concatMap/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/concatMap/0B.dhall b/tests/normalization/success/prelude/List/concatMap/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/concatMap/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 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 deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/concatMap/1B.dhall b/tests/normalization/success/prelude/List/concatMap/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/concatMap/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/success/prelude/List/filter/0A.dhall b/tests/normalization/success/prelude/List/filter/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/filter/0B.dhall b/tests/normalization/success/prelude/List/filter/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/filter/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 2 ] diff --git a/tests/normalization/success/prelude/List/filter/1A.dhall b/tests/normalization/success/prelude/List/filter/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/filter/1B.dhall b/tests/normalization/success/prelude/List/filter/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/filter/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 3, 5 ] diff --git a/tests/normalization/success/prelude/List/fold/0A.dhall b/tests/normalization/success/prelude/List/fold/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/fold/0B.dhall b/tests/normalization/success/prelude/List/fold/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -10 diff --git a/tests/normalization/success/prelude/List/fold/1A.dhall b/tests/normalization/success/prelude/List/fold/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/fold/1B.dhall b/tests/normalization/success/prelude/List/fold/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(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 deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/fold/2B.dhall b/tests/normalization/success/prelude/List/fold/2B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/generate/0A.dhall b/tests/normalization/success/prelude/List/generate/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/generate/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/generate/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/generate/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/generate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Bool diff --git a/tests/normalization/success/prelude/List/head/0A.dhall b/tests/normalization/success/prelude/List/head/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/head/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/head/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 0 diff --git a/tests/normalization/success/prelude/List/head/1A.dhall b/tests/normalization/success/prelude/List/head/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/head/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/head/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/success/prelude/List/indexed/0A.dhall b/tests/normalization/success/prelude/List/indexed/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/indexed/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/indexed/1A.dhall b/tests/normalization/success/prelude/List/indexed/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/indexed/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/indexed/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : 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 deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/iterate/0B.dhall b/tests/normalization/success/prelude/List/iterate/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/iterate/1A.dhall b/tests/normalization/success/prelude/List/iterate/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/iterate/1B.dhall b/tests/normalization/success/prelude/List/iterate/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/iterate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/success/prelude/List/last/0A.dhall b/tests/normalization/success/prelude/List/last/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/last/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/last/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 2 diff --git a/tests/normalization/success/prelude/List/last/1A.dhall b/tests/normalization/success/prelude/List/last/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/last/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/last/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/success/prelude/List/length/0A.dhall b/tests/normalization/success/prelude/List/length/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/length/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/length/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -3 diff --git a/tests/normalization/success/prelude/List/length/1A.dhall b/tests/normalization/success/prelude/List/length/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/length/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/length/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/success/prelude/List/map/0A.dhall b/tests/normalization/success/prelude/List/map/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/map/0B.dhall b/tests/normalization/success/prelude/List/map/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/map/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ True, False, False ] diff --git a/tests/normalization/success/prelude/List/map/1A.dhall b/tests/normalization/success/prelude/List/map/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/map/1B.dhall b/tests/normalization/success/prelude/List/map/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/map/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Bool diff --git a/tests/normalization/success/prelude/List/null/0A.dhall b/tests/normalization/success/prelude/List/null/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/null/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/null/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/List/null/1A.dhall b/tests/normalization/success/prelude/List/null/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/null/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/null/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/List/replicate/0A.dhall b/tests/normalization/success/prelude/List/replicate/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/replicate/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/replicate/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/replicate/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/replicate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/success/prelude/List/reverse/0A.dhall b/tests/normalization/success/prelude/List/reverse/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/reverse/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/reverse/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 2, 1, 0 ] diff --git a/tests/normalization/success/prelude/List/reverse/1A.dhall b/tests/normalization/success/prelude/List/reverse/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/reverse/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/List/reverse/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/success/prelude/List/shifted/0A.dhall b/tests/normalization/success/prelude/List/shifted/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/shifted/0B.dhall b/tests/normalization/success/prelude/List/shifted/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/shifted/1A.dhall b/tests/normalization/success/prelude/List/shifted/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/shifted/1B.dhall b/tests/normalization/success/prelude/List/shifted/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/shifted/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : 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 deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/unzip/0B.dhall b/tests/normalization/success/prelude/List/unzip/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/unzip/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _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 deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/List/unzip/1B.dhall b/tests/normalization/success/prelude/List/unzip/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/List/unzip/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _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 deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Natural/build/0B.dhall b/tests/normalization/success/prelude/Natural/build/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -3 diff --git a/tests/normalization/success/prelude/Natural/build/1A.dhall b/tests/normalization/success/prelude/Natural/build/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Natural/build/1B.dhall b/tests/normalization/success/prelude/Natural/build/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/success/prelude/Natural/enumerate/0A.dhall b/tests/normalization/success/prelude/Natural/enumerate/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/enumerate/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Natural/enumerate/1A.dhall b/tests/normalization/success/prelude/Natural/enumerate/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/enumerate/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/enumerate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/success/prelude/Natural/even/0A.dhall b/tests/normalization/success/prelude/Natural/even/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/even/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/even/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Natural/even/1A.dhall b/tests/normalization/success/prelude/Natural/even/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/even/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/even/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Natural/fold/0A.dhall b/tests/normalization/success/prelude/Natural/fold/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Natural/fold/0B.dhall b/tests/normalization/success/prelude/Natural/fold/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -125 diff --git a/tests/normalization/success/prelude/Natural/fold/1A.dhall b/tests/normalization/success/prelude/Natural/fold/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Natural/fold/1B.dhall b/tests/normalization/success/prelude/Natural/fold/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(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 deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Natural/fold/2B.dhall b/tests/normalization/success/prelude/Natural/fold/2B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Natural/isZero/0A.dhall b/tests/normalization/success/prelude/Natural/isZero/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/isZero/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/isZero/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Natural/isZero/1A.dhall b/tests/normalization/success/prelude/Natural/isZero/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/isZero/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/isZero/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Natural/odd/0A.dhall b/tests/normalization/success/prelude/Natural/odd/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/odd/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/odd/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Natural/odd/1A.dhall b/tests/normalization/success/prelude/Natural/odd/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/odd/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/odd/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Natural/product/0A.dhall b/tests/normalization/success/prelude/Natural/product/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/product/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/product/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -30 diff --git a/tests/normalization/success/prelude/Natural/product/1A.dhall b/tests/normalization/success/prelude/Natural/product/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/product/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/product/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -1 diff --git a/tests/normalization/success/prelude/Natural/show/0A.dhall b/tests/normalization/success/prelude/Natural/show/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"3" diff --git a/tests/normalization/success/prelude/Natural/show/1A.dhall b/tests/normalization/success/prelude/Natural/show/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"0" diff --git a/tests/normalization/success/prelude/Natural/sum/0A.dhall b/tests/normalization/success/prelude/Natural/sum/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/sum/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/sum/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -10 diff --git a/tests/normalization/success/prelude/Natural/sum/1A.dhall b/tests/normalization/success/prelude/Natural/sum/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/sum/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/sum/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/success/prelude/Natural/toDouble/0A.dhall b/tests/normalization/success/prelude/Natural/toDouble/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/toDouble/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/toDouble/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -3.0 diff --git a/tests/normalization/success/prelude/Natural/toDouble/1A.dhall b/tests/normalization/success/prelude/Natural/toDouble/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/toDouble/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/toDouble/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0.0 diff --git a/tests/normalization/success/prelude/Natural/toInteger/0A.dhall b/tests/normalization/success/prelude/Natural/toInteger/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/toInteger/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/toInteger/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -+3 diff --git a/tests/normalization/success/prelude/Natural/toInteger/1A.dhall b/tests/normalization/success/prelude/Natural/toInteger/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/toInteger/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Natural/toInteger/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -+0 diff --git a/tests/normalization/success/prelude/Optional/all/0A.dhall b/tests/normalization/success/prelude/Optional/all/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/all/0B.dhall b/tests/normalization/success/prelude/Optional/all/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/all/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Optional/all/1A.dhall b/tests/normalization/success/prelude/Optional/all/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/all/1B.dhall b/tests/normalization/success/prelude/Optional/all/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/all/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Optional/any/0A.dhall b/tests/normalization/success/prelude/Optional/any/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/any/0B.dhall b/tests/normalization/success/prelude/Optional/any/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/any/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Optional/any/1A.dhall b/tests/normalization/success/prelude/Optional/any/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/any/1B.dhall b/tests/normalization/success/prelude/Optional/any/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/any/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Optional/build/0A.dhall b/tests/normalization/success/prelude/Optional/build/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/build/0B.dhall b/tests/normalization/success/prelude/Optional/build/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 1 diff --git a/tests/normalization/success/prelude/Optional/build/1A.dhall b/tests/normalization/success/prelude/Optional/build/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/build/1B.dhall b/tests/normalization/success/prelude/Optional/build/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/success/prelude/Optional/concat/0A.dhall b/tests/normalization/success/prelude/Optional/concat/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/concat/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/concat/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 1 diff --git a/tests/normalization/success/prelude/Optional/concat/1A.dhall b/tests/normalization/success/prelude/Optional/concat/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/concat/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/concat/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/success/prelude/Optional/concat/2A.dhall b/tests/normalization/success/prelude/Optional/concat/2A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/concat/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/concat/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/success/prelude/Optional/filter/0A.dhall b/tests/normalization/success/prelude/Optional/filter/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/filter/0B.dhall b/tests/normalization/success/prelude/Optional/filter/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/filter/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 2 diff --git a/tests/normalization/success/prelude/Optional/filter/1A.dhall b/tests/normalization/success/prelude/Optional/filter/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/filter/1B.dhall b/tests/normalization/success/prelude/Optional/filter/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/filter/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/success/prelude/Optional/fold/0A.dhall b/tests/normalization/success/prelude/Optional/fold/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/fold/0B.dhall b/tests/normalization/success/prelude/Optional/fold/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -2 diff --git a/tests/normalization/success/prelude/Optional/fold/1A.dhall b/tests/normalization/success/prelude/Optional/fold/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/fold/1B.dhall b/tests/normalization/success/prelude/Optional/fold/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/success/prelude/Optional/head/0A.dhall b/tests/normalization/success/prelude/Optional/head/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/head/0B.dhall b/tests/normalization/success/prelude/Optional/head/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/head/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 1 diff --git a/tests/normalization/success/prelude/Optional/head/1A.dhall b/tests/normalization/success/prelude/Optional/head/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/head/1B.dhall b/tests/normalization/success/prelude/Optional/head/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/head/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/success/prelude/Optional/head/2A.dhall b/tests/normalization/success/prelude/Optional/head/2A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/head/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/head/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/success/prelude/Optional/last/0A.dhall b/tests/normalization/success/prelude/Optional/last/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/last/0B.dhall b/tests/normalization/success/prelude/Optional/last/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/last/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some 2 diff --git a/tests/normalization/success/prelude/Optional/last/1A.dhall b/tests/normalization/success/prelude/Optional/last/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/last/1B.dhall b/tests/normalization/success/prelude/Optional/last/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/last/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/success/prelude/Optional/last/2A.dhall b/tests/normalization/success/prelude/Optional/last/2A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/last/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/last/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Natural diff --git a/tests/normalization/success/prelude/Optional/length/0A.dhall b/tests/normalization/success/prelude/Optional/length/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/length/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/length/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -1 diff --git a/tests/normalization/success/prelude/Optional/length/1A.dhall b/tests/normalization/success/prelude/Optional/length/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/length/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/length/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -0 diff --git a/tests/normalization/success/prelude/Optional/map/0A.dhall b/tests/normalization/success/prelude/Optional/map/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/map/0B.dhall b/tests/normalization/success/prelude/Optional/map/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/map/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Some False diff --git a/tests/normalization/success/prelude/Optional/map/1A.dhall b/tests/normalization/success/prelude/Optional/map/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/map/1B.dhall b/tests/normalization/success/prelude/Optional/map/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/map/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -None Bool diff --git a/tests/normalization/success/prelude/Optional/null/0A.dhall b/tests/normalization/success/prelude/Optional/null/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/null/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/null/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -False diff --git a/tests/normalization/success/prelude/Optional/null/1A.dhall b/tests/normalization/success/prelude/Optional/null/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/null/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/null/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -True diff --git a/tests/normalization/success/prelude/Optional/toList/0A.dhall b/tests/normalization/success/prelude/Optional/toList/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/toList/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/toList/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 1 ] : List Natural diff --git a/tests/normalization/success/prelude/Optional/toList/1A.dhall b/tests/normalization/success/prelude/Optional/toList/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/toList/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/toList/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[] : List Natural diff --git a/tests/normalization/success/prelude/Optional/unzip/0A.dhall b/tests/normalization/success/prelude/Optional/unzip/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/unzip/0B.dhall b/tests/normalization/success/prelude/Optional/unzip/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/unzip/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _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 deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Optional/unzip/1B.dhall b/tests/normalization/success/prelude/Optional/unzip/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Optional/unzip/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concat/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concat/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"ABCDEFGHI" diff --git a/tests/normalization/success/prelude/Text/concat/1A.dhall b/tests/normalization/success/prelude/Text/concat/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concat/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concat/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"" diff --git a/tests/normalization/success/prelude/Text/concatMap/0A.dhall b/tests/normalization/success/prelude/Text/concatMap/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Text/concatMap/0B.dhall b/tests/normalization/success/prelude/Text/concatMap/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concatMap/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"0 1 2 " diff --git a/tests/normalization/success/prelude/Text/concatMap/1A.dhall b/tests/normalization/success/prelude/Text/concatMap/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Text/concatMap/1B.dhall b/tests/normalization/success/prelude/Text/concatMap/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concatMap/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"" diff --git a/tests/normalization/success/prelude/Text/concatMapSep/0A.dhall b/tests/normalization/success/prelude/Text/concatMapSep/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Text/concatMapSep/0B.dhall b/tests/normalization/success/prelude/Text/concatMapSep/0B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concatMapSep/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"0, 1, 2" diff --git a/tests/normalization/success/prelude/Text/concatMapSep/1A.dhall b/tests/normalization/success/prelude/Text/concatMapSep/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/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/success/prelude/Text/concatMapSep/1B.dhall b/tests/normalization/success/prelude/Text/concatMapSep/1B.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concatMapSep/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"" diff --git a/tests/normalization/success/prelude/Text/concatSep/0A.dhall b/tests/normalization/success/prelude/Text/concatSep/0A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concatSep/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concatSep/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"ABC, DEF, GHI" diff --git a/tests/normalization/success/prelude/Text/concatSep/1A.dhall b/tests/normalization/success/prelude/Text/concatSep/1A.dhall deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concatSep/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../../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 deleted file mode 100644 --- a/tests/normalization/success/prelude/Text/concatSep/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"" diff --git a/tests/normalization/success/remoteSystemsA.dhall b/tests/normalization/success/remoteSystemsA.dhall deleted file mode 100644 --- a/tests/normalization/success/remoteSystemsA.dhall +++ /dev/null @@ -1,52 +0,0 @@ -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 deleted file mode 100644 --- a/tests/normalization/success/remoteSystemsB.dhall +++ /dev/null @@ -1,212 +0,0 @@ - λ ( _ - : 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 - } - _ - Text - ( λ ( _ - : { cores : - Natural - , host : - Text - , key : - Text - , mandatoryFeatures : - List Text - , platforms : - List Text - , speedFactor : - Natural - , supportedFeatures : - List Text - , user : - Optional Text - } - ) - → λ(_ : Text) - → '' - ${Optional/fold - Text - _@1.user - Text - (λ(user : Text) → "${user}@${_@1.host}") - _@1.host} ${merge - { Empty = λ(_ : {}) → "", NonEmpty = λ(_ : Text) → _ } - ( List/fold - Text - _@1.platforms - < Empty : {} | NonEmpty : Text > - ( λ(_ : Text) - → λ(_ : < Empty : {} | NonEmpty : Text >) - → merge - { Empty = - λ(_ : {}) → < NonEmpty = _@2 | Empty : {} > - , NonEmpty = - λ(_ : Text) - → < NonEmpty = _@2 ++ "," ++ _ | Empty : {} > - } - _ - : < Empty : {} | NonEmpty : Text > - ) - < Empty = {=} | NonEmpty : Text > - ) - : Text} ${_@1.key} ${Integer/show - ( Natural/toInteger _@1.cores - )} ${Integer/show - ( Natural/toInteger - _@1.speedFactor - )} ${merge - { Empty = - λ(_ : {}) → "" - , NonEmpty = - λ(_ : Text) → _ - } - ( List/fold - Text - _@1.supportedFeatures - < Empty : - {} - | NonEmpty : - Text - > - ( λ(_ : Text) - → λ ( _ - : < Empty : - {} - | NonEmpty : - Text - > - ) - → merge - { Empty = - λ(_ : {}) - → < NonEmpty = - _@2 - | Empty : - {} - > - , NonEmpty = - λ(_ : Text) - → < NonEmpty = - _@2 - ++ "," - ++ _ - | Empty : - {} - > - } - _ - : < Empty : - {} - | NonEmpty : - Text - > - ) - < Empty = - {=} - | NonEmpty : - Text - > - ) - : Text} ${merge - { Empty = - λ(_ : {}) - → "" - , NonEmpty = - λ ( _ - : Text - ) - → _ - } - ( List/fold - Text - _@1.mandatoryFeatures - < Empty : - {} - | NonEmpty : - Text - > - ( λ ( _ - : Text - ) - → λ ( _ - : < Empty : - {} - | NonEmpty : - Text - > - ) - → merge - { Empty = - λ ( _ - : {} - ) - → < NonEmpty = - _@2 - | Empty : - {} - > - , NonEmpty = - λ ( _ - : Text - ) - → < NonEmpty = - _@2 - ++ "," - ++ _ - | Empty : - {} - > - } - _ - : < Empty : - {} - | NonEmpty : - Text - > - ) - < Empty = - {=} - | NonEmpty : - Text - > - ) - : Text} - '' - ++ _ - ) - "" diff --git a/tests/normalization/success/simple/doubleShowA.dhall b/tests/normalization/success/simple/doubleShowA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/doubleShowA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ 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 deleted file mode 100644 --- a/tests/normalization/success/simple/doubleShowB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ example0 = "-0.42", example1 = "13.37" } diff --git a/tests/normalization/success/simple/integerShowA.dhall b/tests/normalization/success/simple/integerShowA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/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/success/simple/integerShowB.dhall b/tests/normalization/success/simple/integerShowB.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/integerShowB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ example0 = "+1337", example1 = "-42", example2 = "+0" } diff --git a/tests/normalization/success/simple/integerToDoubleA.dhall b/tests/normalization/success/simple/integerToDoubleA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/integerToDoubleA.dhall +++ /dev/null @@ -1,10 +0,0 @@ -[ 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 deleted file mode 100644 --- a/tests/normalization/success/simple/integerToDoubleB.dhall +++ /dev/null @@ -1,9 +0,0 @@ -[ 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 deleted file mode 100644 --- a/tests/normalization/success/simple/letletA.dhall +++ /dev/null @@ -1,3 +0,0 @@ -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 deleted file mode 100644 --- a/tests/normalization/success/simple/letletB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -1337 diff --git a/tests/normalization/success/simple/listBuildA.dhall b/tests/normalization/success/simple/listBuildA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/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/success/simple/listBuildB.dhall b/tests/normalization/success/simple/listBuildB.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/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/success/simple/multiLineA.dhall b/tests/normalization/success/simple/multiLineA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/multiLineA.dhall +++ /dev/null @@ -1,4 +0,0 @@ -'' - foo -bar -'' diff --git a/tests/normalization/success/simple/multiLineB.dhall b/tests/normalization/success/simple/multiLineB.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/multiLineB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -'' - foo -bar -'' diff --git a/tests/normalization/success/simple/naturalBuildA.dhall b/tests/normalization/success/simple/naturalBuildA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/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/success/simple/naturalBuildB.dhall b/tests/normalization/success/simple/naturalBuildB.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/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/success/simple/naturalPlusA.dhall b/tests/normalization/success/simple/naturalPlusA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/naturalPlusA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -1 + 2 diff --git a/tests/normalization/success/simple/naturalPlusB.dhall b/tests/normalization/success/simple/naturalPlusB.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/naturalPlusB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -3 diff --git a/tests/normalization/success/simple/naturalShowA.dhall b/tests/normalization/success/simple/naturalShowA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/naturalShowA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural/show 42 diff --git a/tests/normalization/success/simple/naturalShowB.dhall b/tests/normalization/success/simple/naturalShowB.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/naturalShowB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"42" diff --git a/tests/normalization/success/simple/naturalToIntegerA.dhall b/tests/normalization/success/simple/naturalToIntegerA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/naturalToIntegerA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural/toInteger 1 diff --git a/tests/normalization/success/simple/naturalToIntegerB.dhall b/tests/normalization/success/simple/naturalToIntegerB.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/naturalToIntegerB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -+1 diff --git a/tests/normalization/success/simple/optionalBuildA.dhall b/tests/normalization/success/simple/optionalBuildA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/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/success/simple/optionalBuildB.dhall b/tests/normalization/success/simple/optionalBuildB.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/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/success/simple/optionalBuildFoldA.dhall b/tests/normalization/success/simple/optionalBuildFoldA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/optionalBuildFoldA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -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 deleted file mode 100644 --- a/tests/normalization/success/simple/optionalBuildFoldB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ "foo" ] : Optional Text diff --git a/tests/normalization/success/simple/optionalFoldA.dhall b/tests/normalization/success/simple/optionalFoldA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/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/success/simple/optionalFoldB.dhall b/tests/normalization/success/simple/optionalFoldB.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/optionalFoldB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ example0 = 1, example1 = 2 } diff --git a/tests/normalization/success/simple/sortOperatorA.dhall b/tests/normalization/success/simple/sortOperatorA.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/sortOperatorA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ b = 2 } // { a = 1 } diff --git a/tests/normalization/success/simple/sortOperatorB.dhall b/tests/normalization/success/simple/sortOperatorB.dhall deleted file mode 100644 --- a/tests/normalization/success/simple/sortOperatorB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ a = 1, b = 2 } diff --git a/tests/normalization/success/simplifications/andA.dhall b/tests/normalization/success/simplifications/andA.dhall deleted file mode 100644 --- a/tests/normalization/success/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/success/simplifications/andB.dhall b/tests/normalization/success/simplifications/andB.dhall deleted file mode 100644 --- a/tests/normalization/success/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/success/simplifications/eqA.dhall b/tests/normalization/success/simplifications/eqA.dhall deleted file mode 100644 --- a/tests/normalization/success/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/success/simplifications/eqB.dhall b/tests/normalization/success/simplifications/eqB.dhall deleted file mode 100644 --- a/tests/normalization/success/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/success/simplifications/ifThenElseA.dhall b/tests/normalization/success/simplifications/ifThenElseA.dhall deleted file mode 100644 --- a/tests/normalization/success/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/success/simplifications/ifThenElseB.dhall b/tests/normalization/success/simplifications/ifThenElseB.dhall deleted file mode 100644 --- a/tests/normalization/success/simplifications/ifThenElseB.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{ 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 deleted file mode 100644 --- a/tests/normalization/success/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/success/simplifications/neB.dhall b/tests/normalization/success/simplifications/neB.dhall deleted file mode 100644 --- a/tests/normalization/success/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/success/simplifications/orA.dhall b/tests/normalization/success/simplifications/orA.dhall deleted file mode 100644 --- a/tests/normalization/success/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/success/simplifications/orB.dhall b/tests/normalization/success/simplifications/orB.dhall deleted file mode 100644 --- a/tests/normalization/success/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/parser/failure/doubleBoundsNeg.dhall b/tests/parser/failure/doubleBoundsNeg.dhall deleted file mode 100644 --- a/tests/parser/failure/doubleBoundsNeg.dhall +++ /dev/null @@ -1,1 +0,0 @@ --179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0 diff --git a/tests/parser/failure/doubleBoundsPos.dhall b/tests/parser/failure/doubleBoundsPos.dhall deleted file mode 100644 --- a/tests/parser/failure/doubleBoundsPos.dhall +++ /dev/null @@ -1,1 +0,0 @@ -179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0 diff --git a/tests/parser/failure/importAccess.dhall b/tests/parser/failure/importAccess.dhall deleted file mode 100644 --- a/tests/parser/failure/importAccess.dhall +++ /dev/null @@ -1,1 +0,0 @@ -./testImport .hello diff --git a/tests/parser/failure/mandatoryNewline.dhall b/tests/parser/failure/mandatoryNewline.dhall deleted file mode 100644 --- a/tests/parser/failure/mandatoryNewline.dhall +++ /dev/null @@ -1,2 +0,0 @@ --- Multi-line literals require a mandatory newline after the opening quotes -''ABC'' diff --git a/tests/parser/success/annotationsA.dhall b/tests/parser/success/annotationsA.dhall deleted file mode 100644 --- a/tests/parser/success/annotationsA.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/success/annotationsB.dhall b/tests/parser/success/annotationsB.dhall deleted file mode 100644 --- a/tests/parser/success/annotationsB.dhall +++ /dev/null @@ -1,84 +0,0 @@ -[ - 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/asTextA.dhall b/tests/parser/success/asTextA.dhall deleted file mode 100644 --- a/tests/parser/success/asTextA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -https://example.com/foo as Text diff --git a/tests/parser/success/asTextB.dhall b/tests/parser/success/asTextB.dhall deleted file mode 100644 --- a/tests/parser/success/asTextB.dhall +++ /dev/null @@ -1,11 +0,0 @@ -[ - 24, - null, - 1, - null, - 1, - "example.com", - "foo", - null, - null -] diff --git a/tests/parser/success/blockCommentA.dhall b/tests/parser/success/blockCommentA.dhall deleted file mode 100644 --- a/tests/parser/success/blockCommentA.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{- foo -} - -1 diff --git a/tests/parser/success/blockCommentB.dhall b/tests/parser/success/blockCommentB.dhall deleted file mode 100644 --- a/tests/parser/success/blockCommentB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ - 15, - 1 -] diff --git a/tests/parser/success/builtinsA.dhall b/tests/parser/success/builtinsA.dhall deleted file mode 100644 --- a/tests/parser/success/builtinsA.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/success/builtinsB.dhall b/tests/parser/success/builtinsB.dhall deleted file mode 100644 --- a/tests/parser/success/builtinsB.dhall +++ /dev/null @@ -1,57 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/collectionImportTypeA.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{ example0 = [] : Optional ./type.dhall -, example1 = [] : List ./type.dhall -} diff --git a/tests/parser/success/collectionImportTypeB.dhall b/tests/parser/success/collectionImportTypeB.dhall deleted file mode 100644 --- a/tests/parser/success/collectionImportTypeB.dhall +++ /dev/null @@ -1,25 +0,0 @@ -[ - 8, - { - "example0": [ - 5, - [ - 24, - null, - 0, - 3, - "type.dhall" - ] - ], - "example1": [ - 4, - [ - 24, - null, - 0, - 3, - "type.dhall" - ] - ] - } -] diff --git a/tests/parser/success/constructorsA.dhall b/tests/parser/success/constructorsA.dhall deleted file mode 100644 --- a/tests/parser/success/constructorsA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -constructors < Left : Natural | Right : Bool > diff --git a/tests/parser/success/constructorsB.dhall b/tests/parser/success/constructorsB.dhall deleted file mode 100644 --- a/tests/parser/success/constructorsB.dhall +++ /dev/null @@ -1,10 +0,0 @@ -[ - 13, - [ - 11, - { - "Left": "Natural", - "Right": "Bool" - } - ] -] diff --git a/tests/parser/success/customHeadersA.dhall b/tests/parser/success/customHeadersA.dhall deleted file mode 100644 --- a/tests/parser/success/customHeadersA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -https://example.com/foo using ./headers.dhall diff --git a/tests/parser/success/customHeadersB.dhall b/tests/parser/success/customHeadersB.dhall deleted file mode 100644 --- a/tests/parser/success/customHeadersB.dhall +++ /dev/null @@ -1,17 +0,0 @@ -[ - 24, - null, - 0, - [ - 24, - null, - 0, - 3, - "headers.dhall" - ], - 1, - "example.com", - "foo", - null, - null -] diff --git a/tests/parser/success/doubleA.dhall b/tests/parser/success/doubleA.dhall deleted file mode 100644 --- a/tests/parser/success/doubleA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ 1.1, -1.1, 1e1, 1.1e1, -1.1 ] diff --git a/tests/parser/success/doubleB.dhall b/tests/parser/success/doubleB.dhall deleted file mode 100644 --- a/tests/parser/success/doubleB.dhall +++ /dev/null @@ -1,9 +0,0 @@ -[ - 4, - null, - 1.1, - -1.1, - 10, - 11, - -1.1 -] diff --git a/tests/parser/success/doubleQuotedStringA.dhall b/tests/parser/success/doubleQuotedStringA.dhall deleted file mode 100644 --- a/tests/parser/success/doubleQuotedStringA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"ABC" diff --git a/tests/parser/success/doubleQuotedStringB.dhall b/tests/parser/success/doubleQuotedStringB.dhall deleted file mode 100644 --- a/tests/parser/success/doubleQuotedStringB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ - 18, - "ABC" -] diff --git a/tests/parser/success/environmentVariablesA.dhall b/tests/parser/success/environmentVariablesA.dhall deleted file mode 100644 --- a/tests/parser/success/environmentVariablesA.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/success/environmentVariablesB.dhall b/tests/parser/success/environmentVariablesB.dhall deleted file mode 100644 --- a/tests/parser/success/environmentVariablesB.dhall +++ /dev/null @@ -1,18 +0,0 @@ -[ - 4, - null, - [ - 24, - null, - 0, - 6, - "FOO" - ], - [ - 24, - null, - 0, - 6, - "\\\"\\\\\\a\\b\\f\\n\\r\\t\\v" - ] -] diff --git a/tests/parser/success/escapedDoubleQuotedStringA.dhall b/tests/parser/success/escapedDoubleQuotedStringA.dhall deleted file mode 100644 --- a/tests/parser/success/escapedDoubleQuotedStringA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"\\\"\$\\\/\b\f\n\r\t \u2200(a : Type) \u2192 a" diff --git a/tests/parser/success/escapedDoubleQuotedStringB.dhall b/tests/parser/success/escapedDoubleQuotedStringB.dhall deleted file mode 100644 --- a/tests/parser/success/escapedDoubleQuotedStringB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ - 18, - "\\\"$\\/\b\f\n\r\t ∀(a : Type) → a" -] diff --git a/tests/parser/success/escapedSingleQuotedStringA.dhall b/tests/parser/success/escapedSingleQuotedStringA.dhall deleted file mode 100644 --- a/tests/parser/success/escapedSingleQuotedStringA.dhall +++ /dev/null @@ -1,4 +0,0 @@ -'' -''${ -''' -'' diff --git a/tests/parser/success/escapedSingleQuotedStringB.dhall b/tests/parser/success/escapedSingleQuotedStringB.dhall deleted file mode 100644 --- a/tests/parser/success/escapedSingleQuotedStringB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ - 18, - "${\n''\n" -] diff --git a/tests/parser/success/fieldsA.dhall b/tests/parser/success/fieldsA.dhall deleted file mode 100644 --- a/tests/parser/success/fieldsA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -({ foo = { bar = { baz = 1 } } }).foo. bar .baz diff --git a/tests/parser/success/fieldsB.dhall b/tests/parser/success/fieldsB.dhall deleted file mode 100644 --- a/tests/parser/success/fieldsB.dhall +++ /dev/null @@ -1,31 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/forallA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(a : Type) → forall (b : Type) -> a diff --git a/tests/parser/success/forallB.dhall b/tests/parser/success/forallB.dhall deleted file mode 100644 --- a/tests/parser/success/forallB.dhall +++ /dev/null @@ -1,11 +0,0 @@ -[ - 2, - "a", - "Type", - [ - 2, - "b", - "Type", - "a" - ] -] diff --git a/tests/parser/success/functionTypeA.dhall b/tests/parser/success/functionTypeA.dhall deleted file mode 100644 --- a/tests/parser/success/functionTypeA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool → Bool -> Bool diff --git a/tests/parser/success/functionTypeB.dhall b/tests/parser/success/functionTypeB.dhall deleted file mode 100644 --- a/tests/parser/success/functionTypeB.dhall +++ /dev/null @@ -1,9 +0,0 @@ -[ - 2, - "Bool", - [ - 2, - "Bool", - "Bool" - ] -] diff --git a/tests/parser/success/identifierA.dhall b/tests/parser/success/identifierA.dhall deleted file mode 100644 --- a/tests/parser/success/identifierA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(a : Type) → λ(a : Type) → a@1 diff --git a/tests/parser/success/identifierB.dhall b/tests/parser/success/identifierB.dhall deleted file mode 100644 --- a/tests/parser/success/identifierB.dhall +++ /dev/null @@ -1,14 +0,0 @@ -[ - 1, - "a", - "Type", - [ - 1, - "a", - "Type", - [ - "a", - 1 - ] - ] -] diff --git a/tests/parser/success/ifThenElseA.dhall b/tests/parser/success/ifThenElseA.dhall deleted file mode 100644 --- a/tests/parser/success/ifThenElseA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -if True then 1 else 2 diff --git a/tests/parser/success/ifThenElseB.dhall b/tests/parser/success/ifThenElseB.dhall deleted file mode 100644 --- a/tests/parser/success/ifThenElseB.dhall +++ /dev/null @@ -1,12 +0,0 @@ -[ - 14, - true, - [ - 15, - 1 - ], - [ - 15, - 2 - ] -] diff --git a/tests/parser/success/importAltA.dhall b/tests/parser/success/importAltA.dhall deleted file mode 100644 --- a/tests/parser/success/importAltA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2 diff --git a/tests/parser/success/importAltB.dhall b/tests/parser/success/importAltB.dhall deleted file mode 100644 --- a/tests/parser/success/importAltB.dhall +++ /dev/null @@ -1,47 +0,0 @@ -[ - 3, - 11, - [ - 3, - 11, - [ - 3, - 11, - [ - 3, - 11, - [ - 24, - null, - 1, - 6, - "UNSET1" - ], - [ - 24, - null, - 0, - 6, - "UNSET2" - ] - ], - [ - 24, - null, - 0, - 7 - ] - ], - [ - 24, - null, - 0, - 6, - "UNSET3" - ] - ], - [ - 15, - 2 - ] -] diff --git a/tests/parser/success/interpolatedDoubleQuotedStringA.dhall b/tests/parser/success/interpolatedDoubleQuotedStringA.dhall deleted file mode 100644 --- a/tests/parser/success/interpolatedDoubleQuotedStringA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"ABC${Integer/show 123}" diff --git a/tests/parser/success/interpolatedDoubleQuotedStringB.dhall b/tests/parser/success/interpolatedDoubleQuotedStringB.dhall deleted file mode 100644 --- a/tests/parser/success/interpolatedDoubleQuotedStringB.dhall +++ /dev/null @@ -1,13 +0,0 @@ -[ - 18, - "ABC", - [ - 0, - "Integer/show", - [ - 15, - 123 - ] - ], - "" -] diff --git a/tests/parser/success/interpolatedSingleQuotedStringA.dhall b/tests/parser/success/interpolatedSingleQuotedStringA.dhall deleted file mode 100644 --- a/tests/parser/success/interpolatedSingleQuotedStringA.dhall +++ /dev/null @@ -1,4 +0,0 @@ -'' -ABC -${Integer/show 123} -'' diff --git a/tests/parser/success/interpolatedSingleQuotedStringB.dhall b/tests/parser/success/interpolatedSingleQuotedStringB.dhall deleted file mode 100644 --- a/tests/parser/success/interpolatedSingleQuotedStringB.dhall +++ /dev/null @@ -1,13 +0,0 @@ -[ - 18, - "ABC\n", - [ - 0, - "Integer/show", - [ - 15, - 123 - ] - ], - "\n" -] diff --git a/tests/parser/success/labelA.dhall b/tests/parser/success/labelA.dhall deleted file mode 100644 --- a/tests/parser/success/labelA.dhall +++ /dev/null @@ -1,2 +0,0 @@ -let _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ = 1 -in _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ diff --git a/tests/parser/success/labelB.dhall b/tests/parser/success/labelB.dhall deleted file mode 100644 --- a/tests/parser/success/labelB.dhall +++ /dev/null @@ -1,10 +0,0 @@ -[ - 25, - "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/", - null, - [ - 15, - 1 - ], - "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/" -] diff --git a/tests/parser/success/lambdaA.dhall b/tests/parser/success/lambdaA.dhall deleted file mode 100644 --- a/tests/parser/success/lambdaA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(a : Type) → \(b : Type) -> a diff --git a/tests/parser/success/lambdaB.dhall b/tests/parser/success/lambdaB.dhall deleted file mode 100644 --- a/tests/parser/success/lambdaB.dhall +++ /dev/null @@ -1,11 +0,0 @@ -[ - 1, - "a", - "Type", - [ - 1, - "b", - "Type", - "a" - ] -] diff --git a/tests/parser/success/largeExpressionA.dhall b/tests/parser/success/largeExpressionA.dhall deleted file mode 100644 --- a/tests/parser/success/largeExpressionA.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/success/largeExpressionB.dhall b/tests/parser/success/largeExpressionB.dhall deleted file mode 100644 --- a/tests/parser/success/largeExpressionB.dhall +++ /dev/null @@ -1,1303 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/letA.dhall +++ /dev/null @@ -1,3 +0,0 @@ - let x = 1 -in let y : Integer = 2 -in x diff --git a/tests/parser/success/letB.dhall b/tests/parser/success/letB.dhall deleted file mode 100644 --- a/tests/parser/success/letB.dhall +++ /dev/null @@ -1,19 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/lineCommentA.dhall +++ /dev/null @@ -1,3 +0,0 @@ --- foo - -1 diff --git a/tests/parser/success/lineCommentB.dhall b/tests/parser/success/lineCommentB.dhall deleted file mode 100644 --- a/tests/parser/success/lineCommentB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ - 15, - 1 -] diff --git a/tests/parser/success/listA.dhall b/tests/parser/success/listA.dhall deleted file mode 100644 --- a/tests/parser/success/listA.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ [1, 2, 3] -, [1, 2, 3] : List Integer -, [] : List Integer -] diff --git a/tests/parser/success/listB.dhall b/tests/parser/success/listB.dhall deleted file mode 100644 --- a/tests/parser/success/listB.dhall +++ /dev/null @@ -1,40 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/mergeA.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/success/mergeB.dhall b/tests/parser/success/mergeB.dhall deleted file mode 100644 --- a/tests/parser/success/mergeB.dhall +++ /dev/null @@ -1,45 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/multiletA.dhall +++ /dev/null @@ -1,3 +0,0 @@ -let a = 1 -let b = 2 -in a + b diff --git a/tests/parser/success/multiletB.dhall b/tests/parser/success/multiletB.dhall deleted file mode 100644 --- a/tests/parser/success/multiletB.dhall +++ /dev/null @@ -1,21 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/naturalA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -[ +0, +1, +01, +10 ] diff --git a/tests/parser/success/naturalB.dhall b/tests/parser/success/naturalB.dhall deleted file mode 100644 --- a/tests/parser/success/naturalB.dhall +++ /dev/null @@ -1,20 +0,0 @@ -[ - 4, - null, - [ - 16, - 0 - ], - [ - 16, - 1 - ], - [ - 16, - 1 - ], - [ - 16, - 10 - ] -] diff --git a/tests/parser/success/nestedBlockCommentA.dhall b/tests/parser/success/nestedBlockCommentA.dhall deleted file mode 100644 --- a/tests/parser/success/nestedBlockCommentA.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{- foo {- bar -} baz -} - -1 diff --git a/tests/parser/success/nestedBlockCommentB.dhall b/tests/parser/success/nestedBlockCommentB.dhall deleted file mode 100644 --- a/tests/parser/success/nestedBlockCommentB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ - 15, - 1 -] diff --git a/tests/parser/success/operatorsA.dhall b/tests/parser/success/operatorsA.dhall deleted file mode 100644 --- a/tests/parser/success/operatorsA.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/success/operatorsB.dhall b/tests/parser/success/operatorsB.dhall deleted file mode 100644 --- a/tests/parser/success/operatorsB.dhall +++ /dev/null @@ -1,96 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/parenthesizeUsingA.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/success/parenthesizeUsingB.dhall b/tests/parser/success/parenthesizeUsingB.dhall deleted file mode 100644 --- a/tests/parser/success/parenthesizeUsingB.dhall +++ /dev/null @@ -1,27 +0,0 @@ -[ - 24, - [ - "sha256", - "b0e3ec1797b32c80c0bcb7e8254b08c7e9e35e75e6b410c7ac21477ab90167ad" - ], - 0, - [ - 24, - [ - "sha256", - "16173e984d35ee3ffd8b6b79167df89480e67d1cd03ea5d0fc93689e4d928e61" - ], - 0, - 3, - "a.dhall" - ], - 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 deleted file mode 100644 --- a/tests/parser/success/pathTerminationA.dhall +++ /dev/null @@ -1,3 +0,0 @@ --- Verify that certain punctuation marks terminate paths correctly - λ(x : ./example) -→ [./example, {bar = , qux = ./example}, ./example] diff --git a/tests/parser/success/pathTerminationB.dhall b/tests/parser/success/pathTerminationB.dhall deleted file mode 100644 --- a/tests/parser/success/pathTerminationB.dhall +++ /dev/null @@ -1,53 +0,0 @@ -[ - 1, - "x", - [ - 24, - null, - 0, - 3, - "example" - ], - [ - 4, - null, - [ - 24, - null, - 0, - 3, - "example" - ], - [ - 8, - { - "qux": [ - 24, - null, - 0, - 3, - "example" - ], - "bar": [ - 12, - "baz", - [ - 24, - null, - 0, - 3, - "example" - ], - {} - ] - } - ], - [ - 24, - null, - 0, - 3, - "example" - ] - ] -] diff --git a/tests/parser/success/pathsA.dhall b/tests/parser/success/pathsA.dhall deleted file mode 100644 --- a/tests/parser/success/pathsA.dhall +++ /dev/null @@ -1,5 +0,0 @@ -[ /absolute/path -, ./relative/path -, ~/home/anchored/path -, /ipfs/QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx/Prelude -] diff --git a/tests/parser/success/pathsB.dhall b/tests/parser/success/pathsB.dhall deleted file mode 100644 --- a/tests/parser/success/pathsB.dhall +++ /dev/null @@ -1,38 +0,0 @@ -[ - 4, - null, - [ - 24, - null, - 0, - 2, - "absolute", - "path" - ], - [ - 24, - null, - 0, - 3, - "relative", - "path" - ], - [ - 24, - null, - 0, - 5, - "home", - "anchored", - "path" - ], - [ - 24, - null, - 0, - 2, - "ipfs", - "QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx", - "Prelude" - ] -] diff --git a/tests/parser/success/quotedLabelA.dhall b/tests/parser/success/quotedLabelA.dhall deleted file mode 100644 --- a/tests/parser/success/quotedLabelA.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/success/quotedLabelB.dhall b/tests/parser/success/quotedLabelB.dhall deleted file mode 100644 --- a/tests/parser/success/quotedLabelB.dhall +++ /dev/null @@ -1,35 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/quotedPathsA.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{ 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 deleted file mode 100644 --- a/tests/parser/success/quotedPathsB.dhall +++ /dev/null @@ -1,26 +0,0 @@ -[ - 8, - { - "example0": [ - 24, - null, - 0, - 2, - "foo", - "bar", - "baz qux" - ], - "example1": [ - 24, - null, - 0, - null, - 1, - "example.com", - "foo", - "bar?baz", - "qux", - null - ] - } -] diff --git a/tests/parser/success/recordA.dhall b/tests/parser/success/recordA.dhall deleted file mode 100644 --- a/tests/parser/success/recordA.dhall +++ /dev/null @@ -1,4 +0,0 @@ -{ 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 deleted file mode 100644 --- a/tests/parser/success/recordB.dhall +++ /dev/null @@ -1,25 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/reservedPrefixA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -let TypeSynonym = Integer in 1 : TypeSynonym diff --git a/tests/parser/success/reservedPrefixB.dhall b/tests/parser/success/reservedPrefixB.dhall deleted file mode 100644 --- a/tests/parser/success/reservedPrefixB.dhall +++ /dev/null @@ -1,14 +0,0 @@ -[ - 25, - "TypeSynonym", - null, - "Integer", - [ - 26, - [ - 15, - 1 - ], - "TypeSynonym" - ] -] diff --git a/tests/parser/success/singleQuotedStringA.dhall b/tests/parser/success/singleQuotedStringA.dhall deleted file mode 100644 --- a/tests/parser/success/singleQuotedStringA.dhall +++ /dev/null @@ -1,4 +0,0 @@ -'' -ABC -DEF -'' diff --git a/tests/parser/success/singleQuotedStringB.dhall b/tests/parser/success/singleQuotedStringB.dhall deleted file mode 100644 --- a/tests/parser/success/singleQuotedStringB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ - 18, - "ABC\nDEF\n" -] diff --git a/tests/parser/success/sortA.dhall b/tests/parser/success/sortA.dhall deleted file mode 100644 --- a/tests/parser/success/sortA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Sort diff --git a/tests/parser/success/sortB.dhall b/tests/parser/success/sortB.dhall deleted file mode 100644 --- a/tests/parser/success/sortB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"Sort" diff --git a/tests/parser/success/templateA.dhall b/tests/parser/success/templateA.dhall deleted file mode 100644 --- a/tests/parser/success/templateA.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/success/templateB.dhall b/tests/parser/success/templateB.dhall deleted file mode 100644 --- a/tests/parser/success/templateB.dhall +++ /dev/null @@ -1,60 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/unicodeCommentA.dhall +++ /dev/null @@ -1,3 +0,0 @@ -{- ∀(a : Type) → a -} - -1 diff --git a/tests/parser/success/unicodeCommentB.dhall b/tests/parser/success/unicodeCommentB.dhall deleted file mode 100644 --- a/tests/parser/success/unicodeCommentB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ - 15, - 1 -] diff --git a/tests/parser/success/unicodeDoubleQuotedStringA.dhall b/tests/parser/success/unicodeDoubleQuotedStringA.dhall deleted file mode 100644 --- a/tests/parser/success/unicodeDoubleQuotedStringA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -"∀(a : Type) → a" diff --git a/tests/parser/success/unicodeDoubleQuotedStringB.dhall b/tests/parser/success/unicodeDoubleQuotedStringB.dhall deleted file mode 100644 --- a/tests/parser/success/unicodeDoubleQuotedStringB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ - 18, - "∀(a : Type) → a" -] diff --git a/tests/parser/success/unionA.dhall b/tests/parser/success/unionA.dhall deleted file mode 100644 --- a/tests/parser/success/unionA.dhall +++ /dev/null @@ -1,4 +0,0 @@ -< A : { } -| B = { = } -| C : {} -> : < A : {} | B : {} | C : {} > diff --git a/tests/parser/success/unionB.dhall b/tests/parser/success/unionB.dhall deleted file mode 100644 --- a/tests/parser/success/unionB.dhall +++ /dev/null @@ -1,38 +0,0 @@ -[ - 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 deleted file mode 100644 --- a/tests/parser/success/urlsA.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/success/urlsB.dhall b/tests/parser/success/urlsB.dhall deleted file mode 100644 --- a/tests/parser/success/urlsB.dhall +++ /dev/null @@ -1,110 +0,0 @@ -[ - 4, - null, - [ - 24, - null, - 0, - null, - 0, - "example.com", - "someFile.dhall", - null, - null - ], - [ - 24, - null, - 0, - null, - 1, - "john:doe@example.com:8080", - "foo", - "bar", - "qux=0", - "xyzzy" - ], - [ - 24, - null, - 0, - null, - 0, - "prelude.dhall-lang.org", - "package.dhall", - null, - null - ], - [ - 24, - null, - 0, - null, - 1, - "ipfs.io", - "ipfs", - "QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx", - "Prelude", - null, - null - ], - [ - 24, - null, - 0, - null, - 1, - "raw.githubusercontent.com", - "dhall-lang", - "dhall-haskell", - "18e4e9a18dc53271146df3ccf5b4177c3552236b", - "examples", - "True", - null, - null - ], - [ - 24, - null, - 0, - null, - 1, - "127.0.0.1", - "index.dhall", - null, - null - ], - [ - 24, - null, - 0, - null, - 1, - "[::]", - "index.dhall", - null, - null - ], - [ - 24, - null, - 0, - null, - 1, - "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]", - "tutorial.dhall", - null, - null - ], - [ - 24, - null, - 0, - null, - 1, - "-._~%2C!$&'()*+,;=:@-._~%2C!$&'()*+,;=:", - "foo", - "/-._~%2C!$&'()*+,;=:@/?", - "/-._~%2C!$&'()*+,;=:@/?" - ] -] diff --git a/tests/parser/success/whitespaceA.dhall b/tests/parser/success/whitespaceA.dhall deleted file mode 100644 --- a/tests/parser/success/whitespaceA.dhall +++ /dev/null @@ -1,3 +0,0 @@ - -1 - diff --git a/tests/parser/success/whitespaceB.dhall b/tests/parser/success/whitespaceB.dhall deleted file mode 100644 --- a/tests/parser/success/whitespaceB.dhall +++ /dev/null @@ -1,4 +0,0 @@ -[ - 15, - 1 -] diff --git a/tests/parser/success/whitespaceBuffetA.dhall b/tests/parser/success/whitespaceBuffetA.dhall deleted file mode 100644 --- a/tests/parser/success/whitespaceBuffetA.dhall +++ /dev/null @@ -1,9 +0,0 @@ - -- This - - Natural/even {- - -{- file --} - has - - -} +2 -- mixed {- line endings -} diff --git a/tests/parser/success/whitespaceBuffetB.dhall b/tests/parser/success/whitespaceBuffetB.dhall deleted file mode 100644 --- a/tests/parser/success/whitespaceBuffetB.dhall +++ /dev/null @@ -1,8 +0,0 @@ -[ - 0, - "Natural/even", - [ - 16, - 2 - ] -] diff --git a/tests/regression/issue209.dhall b/tests/regression/issue209.dhall deleted file mode 100644 --- a/tests/regression/issue209.dhall +++ /dev/null @@ -1,1 +0,0 @@ -constructors <> diff --git a/tests/tutorial/unions3A.dhall b/tests/tutorial/unions3A.dhall --- a/tests/tutorial/unions3A.dhall +++ b/tests/tutorial/unions3A.dhall @@ -1,4 +1,4 @@ - let MyType = constructors < Empty : {} | Person : { name : Text, age : Natural } > + let MyType = < Empty : {} | Person : { name : Text, age : Natural } > in [ MyType.Empty {=} , MyType.Person { name = "John", age = 23 } , MyType.Person { name = "Amy" , age = 25 } diff --git a/tests/tutorial/unions4A.dhall b/tests/tutorial/unions4A.dhall --- a/tests/tutorial/unions4A.dhall +++ b/tests/tutorial/unions4A.dhall @@ -1,1 +1,1 @@ -constructors < Empty : {} | Person : { name : Text, age : Natural } > +< Empty : {} | Person : { name : Text, age : Natural } > diff --git a/tests/typecheck/failure/combineMixedRecords.dhall b/tests/typecheck/failure/combineMixedRecords.dhall deleted file mode 100644 --- a/tests/typecheck/failure/combineMixedRecords.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ foo = 1 } ∧ { bar = Text } diff --git a/tests/typecheck/failure/hurkensParadox.dhall b/tests/typecheck/failure/hurkensParadox.dhall deleted file mode 100644 --- a/tests/typecheck/failure/hurkensParadox.dhall +++ /dev/null @@ -1,49 +0,0 @@ - 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/failure/mixedUnions.dhall b/tests/typecheck/failure/mixedUnions.dhall deleted file mode 100644 --- a/tests/typecheck/failure/mixedUnions.dhall +++ /dev/null @@ -1,1 +0,0 @@ -< Left : Natural | Right : Type > diff --git a/tests/typecheck/failure/preferMixedRecords.dhall b/tests/typecheck/failure/preferMixedRecords.dhall deleted file mode 100644 --- a/tests/typecheck/failure/preferMixedRecords.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ foo = 1 } ⫽ { bar = Text } diff --git a/tests/typecheck/success/accessEncodedTypeA.dhall b/tests/typecheck/success/accessEncodedTypeA.dhall deleted file mode 100644 --- a/tests/typecheck/success/accessEncodedTypeA.dhall +++ /dev/null @@ -1,4 +0,0 @@ - λ ( 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 deleted file mode 100644 --- a/tests/typecheck/success/accessEncodedTypeB.dhall +++ /dev/null @@ -1,4 +0,0 @@ - ∀ ( 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 deleted file mode 100644 --- a/tests/typecheck/success/accessTypeA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(record : { x : Type, y : Type → Type }) → record.x diff --git a/tests/typecheck/success/accessTypeB.dhall b/tests/typecheck/success/accessTypeB.dhall deleted file mode 100644 --- a/tests/typecheck/success/accessTypeB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(record : { x : Type, y : Type → Type }) → Type diff --git a/tests/typecheck/success/prelude/Bool/and/0A.dhall b/tests/typecheck/success/prelude/Bool/and/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/and/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/and/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/and/1A.dhall b/tests/typecheck/success/prelude/Bool/and/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/and/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/and/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/build/0A.dhall b/tests/typecheck/success/prelude/Bool/build/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/build/0A.dhall +++ /dev/null @@ -1,2 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/build/1A.dhall b/tests/typecheck/success/prelude/Bool/build/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/build/1A.dhall +++ /dev/null @@ -1,2 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/even/0A.dhall b/tests/typecheck/success/prelude/Bool/even/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/even/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/even/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/even/1A.dhall b/tests/typecheck/success/prelude/Bool/even/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/even/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/even/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/even/2A.dhall b/tests/typecheck/success/prelude/Bool/even/2A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/even/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Bool/even [ False ] diff --git a/tests/typecheck/success/prelude/Bool/even/2B.dhall b/tests/typecheck/success/prelude/Bool/even/2B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/even/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/even/3A.dhall b/tests/typecheck/success/prelude/Bool/even/3A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/even/3A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/even/3B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/fold/0A.dhall b/tests/typecheck/success/prelude/Bool/fold/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/fold/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Bool/fold/1A.dhall b/tests/typecheck/success/prelude/Bool/fold/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/fold/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Bool/not/0A.dhall b/tests/typecheck/success/prelude/Bool/not/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/not/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Bool/not True diff --git a/tests/typecheck/success/prelude/Bool/not/0B.dhall b/tests/typecheck/success/prelude/Bool/not/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/not/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/not/1A.dhall b/tests/typecheck/success/prelude/Bool/not/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/not/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Bool/not False diff --git a/tests/typecheck/success/prelude/Bool/not/1B.dhall b/tests/typecheck/success/prelude/Bool/not/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/not/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/odd/0A.dhall b/tests/typecheck/success/prelude/Bool/odd/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/odd/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/odd/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/odd/1A.dhall b/tests/typecheck/success/prelude/Bool/odd/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/odd/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/odd/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/odd/2A.dhall b/tests/typecheck/success/prelude/Bool/odd/2A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/odd/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Bool/odd [ True ] diff --git a/tests/typecheck/success/prelude/Bool/odd/2B.dhall b/tests/typecheck/success/prelude/Bool/odd/2B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/odd/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/odd/3A.dhall b/tests/typecheck/success/prelude/Bool/odd/3A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/odd/3A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/odd/3B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/or/0A.dhall b/tests/typecheck/success/prelude/Bool/or/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/or/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/or/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/or/1A.dhall b/tests/typecheck/success/prelude/Bool/or/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/or/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/or/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Bool/show/0A.dhall b/tests/typecheck/success/prelude/Bool/show/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Bool/show True diff --git a/tests/typecheck/success/prelude/Bool/show/0B.dhall b/tests/typecheck/success/prelude/Bool/show/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Bool/show/1A.dhall b/tests/typecheck/success/prelude/Bool/show/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Bool/show False diff --git a/tests/typecheck/success/prelude/Bool/show/1B.dhall b/tests/typecheck/success/prelude/Bool/show/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Bool/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Double/show/0A.dhall b/tests/typecheck/success/prelude/Double/show/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Double/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Double/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Double/show/1A.dhall b/tests/typecheck/success/prelude/Double/show/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Double/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Double/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Integer/show/0A.dhall b/tests/typecheck/success/prelude/Integer/show/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Integer/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Integer/show -3 diff --git a/tests/typecheck/success/prelude/Integer/show/0B.dhall b/tests/typecheck/success/prelude/Integer/show/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Integer/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Integer/show/1A.dhall b/tests/typecheck/success/prelude/Integer/show/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Integer/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Integer/show +0 diff --git a/tests/typecheck/success/prelude/Integer/show/1B.dhall b/tests/typecheck/success/prelude/Integer/show/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Integer/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Integer/toDouble/0A.dhall b/tests/typecheck/success/prelude/Integer/toDouble/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Integer/toDouble/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Integer/toDouble -3 diff --git a/tests/typecheck/success/prelude/Integer/toDouble/0B.dhall b/tests/typecheck/success/prelude/Integer/toDouble/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Integer/toDouble/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Double diff --git a/tests/typecheck/success/prelude/Integer/toDouble/1A.dhall b/tests/typecheck/success/prelude/Integer/toDouble/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Integer/toDouble/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Integer/toDouble +2 diff --git a/tests/typecheck/success/prelude/Integer/toDouble/1B.dhall b/tests/typecheck/success/prelude/Integer/toDouble/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Integer/toDouble/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Double diff --git a/tests/typecheck/success/prelude/List/all/0A.dhall b/tests/typecheck/success/prelude/List/all/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/all/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/all/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/List/all/1A.dhall b/tests/typecheck/success/prelude/List/all/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/all/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/all/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/List/any/0A.dhall b/tests/typecheck/success/prelude/List/any/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/any/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/any/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/List/any/1A.dhall b/tests/typecheck/success/prelude/List/any/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/any/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/any/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/List/build/0A.dhall b/tests/typecheck/success/prelude/List/build/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/build/0A.dhall +++ /dev/null @@ -1,7 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Text diff --git a/tests/typecheck/success/prelude/List/build/1A.dhall b/tests/typecheck/success/prelude/List/build/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/build/1A.dhall +++ /dev/null @@ -1,7 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Text diff --git a/tests/typecheck/success/prelude/List/concat/0A.dhall b/tests/typecheck/success/prelude/List/concat/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/concat/0A.dhall +++ /dev/null @@ -1,5 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/concat/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/concat/1A.dhall b/tests/typecheck/success/prelude/List/concat/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/concat/1A.dhall +++ /dev/null @@ -1,5 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/concat/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/concatMap/0A.dhall b/tests/typecheck/success/prelude/List/concatMap/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/concatMap/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/concatMap/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/concatMap/1A.dhall b/tests/typecheck/success/prelude/List/concatMap/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/concatMap/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/concatMap/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/filter/0A.dhall b/tests/typecheck/success/prelude/List/filter/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/filter/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/filter/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/filter/1A.dhall b/tests/typecheck/success/prelude/List/filter/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/filter/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/filter/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/fold/0A.dhall b/tests/typecheck/success/prelude/List/fold/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/fold/0A.dhall +++ /dev/null @@ -1,6 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/List/fold/1A.dhall b/tests/typecheck/success/prelude/List/fold/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/fold/1A.dhall +++ /dev/null @@ -1,7 +0,0 @@ - λ(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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(nil : Natural) → Natural diff --git a/tests/typecheck/success/prelude/List/fold/2A.dhall b/tests/typecheck/success/prelude/List/fold/2A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/fold/2A.dhall +++ /dev/null @@ -1,4 +0,0 @@ - λ(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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/fold/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/generate/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/generate/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Bool diff --git a/tests/typecheck/success/prelude/List/generate/1A.dhall b/tests/typecheck/success/prelude/List/generate/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/generate/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/generate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Bool diff --git a/tests/typecheck/success/prelude/List/head/0A.dhall b/tests/typecheck/success/prelude/List/head/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/head/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/head/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/List/head/1A.dhall b/tests/typecheck/success/prelude/List/head/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/head/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/head/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/List/indexed/0A.dhall b/tests/typecheck/success/prelude/List/indexed/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/indexed/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/indexed/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/indexed/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/indexed/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/iterate/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/iterate/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/iterate/1A.dhall b/tests/typecheck/success/prelude/List/iterate/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/iterate/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/iterate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/last/0A.dhall b/tests/typecheck/success/prelude/List/last/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/last/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/last/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/List/last/1A.dhall b/tests/typecheck/success/prelude/List/last/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/last/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/last/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/List/length/0A.dhall b/tests/typecheck/success/prelude/List/length/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/length/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/length/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/List/length/1A.dhall b/tests/typecheck/success/prelude/List/length/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/length/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/length/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/List/map/0A.dhall b/tests/typecheck/success/prelude/List/map/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/map/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/map/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Bool diff --git a/tests/typecheck/success/prelude/List/map/1A.dhall b/tests/typecheck/success/prelude/List/map/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/map/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/map/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Bool diff --git a/tests/typecheck/success/prelude/List/null/0A.dhall b/tests/typecheck/success/prelude/List/null/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/null/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/null/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/List/null/1A.dhall b/tests/typecheck/success/prelude/List/null/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/null/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/null/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/List/replicate/0A.dhall b/tests/typecheck/success/prelude/List/replicate/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/replicate/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/replicate/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/replicate/1A.dhall b/tests/typecheck/success/prelude/List/replicate/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/replicate/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/replicate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/reverse/0A.dhall b/tests/typecheck/success/prelude/List/reverse/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/reverse/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/reverse/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/reverse/1A.dhall b/tests/typecheck/success/prelude/List/reverse/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/reverse/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/reverse/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/List/shifted/0A.dhall b/tests/typecheck/success/prelude/List/shifted/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/shifted/0A.dhall +++ /dev/null @@ -1,15 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/shifted/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/shifted/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/shifted/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/unzip/0A.dhall +++ /dev/null @@ -1,7 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/unzip/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/unzip/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/List/unzip/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _1 : List Text, _2 : List Bool } diff --git a/tests/typecheck/success/prelude/Monoid/00A.dhall b/tests/typecheck/success/prelude/Monoid/00A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/00A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.and diff --git a/tests/typecheck/success/prelude/Monoid/00B.dhall b/tests/typecheck/success/prelude/Monoid/00B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/00B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/success/prelude/Monoid/01A.dhall b/tests/typecheck/success/prelude/Monoid/01A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/01A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.or diff --git a/tests/typecheck/success/prelude/Monoid/01B.dhall b/tests/typecheck/success/prelude/Monoid/01B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/01B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/success/prelude/Monoid/02A.dhall b/tests/typecheck/success/prelude/Monoid/02A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/02A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.even diff --git a/tests/typecheck/success/prelude/Monoid/02B.dhall b/tests/typecheck/success/prelude/Monoid/02B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/02B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/success/prelude/Monoid/03A.dhall b/tests/typecheck/success/prelude/Monoid/03A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/03A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Bool`.odd diff --git a/tests/typecheck/success/prelude/Monoid/03B.dhall b/tests/typecheck/success/prelude/Monoid/03B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/03B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../Prelude/Monoid Bool diff --git a/tests/typecheck/success/prelude/Monoid/04A.dhall b/tests/typecheck/success/prelude/Monoid/04A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/04A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.concat diff --git a/tests/typecheck/success/prelude/Monoid/04B.dhall b/tests/typecheck/success/prelude/Monoid/04B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/04B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(a : Type) → ../../../../../Prelude/Monoid (List a) diff --git a/tests/typecheck/success/prelude/Monoid/05A.dhall b/tests/typecheck/success/prelude/Monoid/05A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/05A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`List`.shifted diff --git a/tests/typecheck/success/prelude/Monoid/05B.dhall b/tests/typecheck/success/prelude/Monoid/05B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/05B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/06A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.sum diff --git a/tests/typecheck/success/prelude/Monoid/06B.dhall b/tests/typecheck/success/prelude/Monoid/06B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/06B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../Prelude/Monoid Natural diff --git a/tests/typecheck/success/prelude/Monoid/07A.dhall b/tests/typecheck/success/prelude/Monoid/07A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/07A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Natural`.product diff --git a/tests/typecheck/success/prelude/Monoid/07B.dhall b/tests/typecheck/success/prelude/Monoid/07B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/07B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../Prelude/Monoid Natural diff --git a/tests/typecheck/success/prelude/Monoid/08A.dhall b/tests/typecheck/success/prelude/Monoid/08A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/08A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.head diff --git a/tests/typecheck/success/prelude/Monoid/08B.dhall b/tests/typecheck/success/prelude/Monoid/08B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/08B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(a : Type) → ../../../../../Prelude/Monoid (Optional a) diff --git a/tests/typecheck/success/prelude/Monoid/09A.dhall b/tests/typecheck/success/prelude/Monoid/09A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/09A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Optional`.last diff --git a/tests/typecheck/success/prelude/Monoid/09B.dhall b/tests/typecheck/success/prelude/Monoid/09B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/09B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(a : Type) → ../../../../../Prelude/Monoid (Optional a) diff --git a/tests/typecheck/success/prelude/Monoid/10A.dhall b/tests/typecheck/success/prelude/Monoid/10A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/10A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -(../../../../../Prelude/package.dhall).`Text`.concat diff --git a/tests/typecheck/success/prelude/Monoid/10B.dhall b/tests/typecheck/success/prelude/Monoid/10B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Monoid/10B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../Prelude/Monoid Text diff --git a/tests/typecheck/success/prelude/Natural/build/0A.dhall b/tests/typecheck/success/prelude/Natural/build/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/build/0A.dhall +++ /dev/null @@ -1,6 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Natural/build/1A.dhall b/tests/typecheck/success/prelude/Natural/build/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/build/1A.dhall +++ /dev/null @@ -1,6 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Natural/enumerate/0A.dhall b/tests/typecheck/success/prelude/Natural/enumerate/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/enumerate/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/enumerate 10 diff --git a/tests/typecheck/success/prelude/Natural/enumerate/0B.dhall b/tests/typecheck/success/prelude/Natural/enumerate/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/enumerate/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/Natural/enumerate/1A.dhall b/tests/typecheck/success/prelude/Natural/enumerate/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/enumerate/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/enumerate 0 diff --git a/tests/typecheck/success/prelude/Natural/enumerate/1B.dhall b/tests/typecheck/success/prelude/Natural/enumerate/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/enumerate/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/Natural/even/0A.dhall b/tests/typecheck/success/prelude/Natural/even/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/even/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/even 3 diff --git a/tests/typecheck/success/prelude/Natural/even/0B.dhall b/tests/typecheck/success/prelude/Natural/even/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/even/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Natural/even/1A.dhall b/tests/typecheck/success/prelude/Natural/even/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/even/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/even 0 diff --git a/tests/typecheck/success/prelude/Natural/even/1B.dhall b/tests/typecheck/success/prelude/Natural/even/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/even/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Natural/fold/0A.dhall b/tests/typecheck/success/prelude/Natural/fold/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/fold/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Natural/fold/1A.dhall b/tests/typecheck/success/prelude/Natural/fold/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/fold/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(zero : Natural) → Natural diff --git a/tests/typecheck/success/prelude/Natural/fold/2A.dhall b/tests/typecheck/success/prelude/Natural/fold/2A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/fold/2A.dhall +++ /dev/null @@ -1,4 +0,0 @@ - λ(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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/fold/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/isZero/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/isZero 2 diff --git a/tests/typecheck/success/prelude/Natural/isZero/0B.dhall b/tests/typecheck/success/prelude/Natural/isZero/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/isZero/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Natural/isZero/1A.dhall b/tests/typecheck/success/prelude/Natural/isZero/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/isZero/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/isZero 0 diff --git a/tests/typecheck/success/prelude/Natural/isZero/1B.dhall b/tests/typecheck/success/prelude/Natural/isZero/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/isZero/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Natural/odd/0A.dhall b/tests/typecheck/success/prelude/Natural/odd/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/odd/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/odd 3 diff --git a/tests/typecheck/success/prelude/Natural/odd/0B.dhall b/tests/typecheck/success/prelude/Natural/odd/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/odd/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Natural/odd/1A.dhall b/tests/typecheck/success/prelude/Natural/odd/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/odd/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/odd 0 diff --git a/tests/typecheck/success/prelude/Natural/odd/1B.dhall b/tests/typecheck/success/prelude/Natural/odd/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/odd/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Natural/product/0A.dhall b/tests/typecheck/success/prelude/Natural/product/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/product/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/product/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Natural/product/1A.dhall b/tests/typecheck/success/prelude/Natural/product/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/product/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/product/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Natural/show/0A.dhall b/tests/typecheck/success/prelude/Natural/show/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/show/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/show 3 diff --git a/tests/typecheck/success/prelude/Natural/show/0B.dhall b/tests/typecheck/success/prelude/Natural/show/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/show/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Natural/show/1A.dhall b/tests/typecheck/success/prelude/Natural/show/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/show/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/show 0 diff --git a/tests/typecheck/success/prelude/Natural/show/1B.dhall b/tests/typecheck/success/prelude/Natural/show/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/show/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Natural/sum/0A.dhall b/tests/typecheck/success/prelude/Natural/sum/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/sum/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/sum/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Natural/sum/1A.dhall b/tests/typecheck/success/prelude/Natural/sum/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/sum/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/sum/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Natural/toDouble/0A.dhall b/tests/typecheck/success/prelude/Natural/toDouble/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/toDouble/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/toDouble 3 diff --git a/tests/typecheck/success/prelude/Natural/toDouble/0B.dhall b/tests/typecheck/success/prelude/Natural/toDouble/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/toDouble/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Double diff --git a/tests/typecheck/success/prelude/Natural/toDouble/1A.dhall b/tests/typecheck/success/prelude/Natural/toDouble/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/toDouble/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/toDouble 0 diff --git a/tests/typecheck/success/prelude/Natural/toDouble/1B.dhall b/tests/typecheck/success/prelude/Natural/toDouble/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/toDouble/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Double diff --git a/tests/typecheck/success/prelude/Natural/toInteger/0A.dhall b/tests/typecheck/success/prelude/Natural/toInteger/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/toInteger/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/toInteger 3 diff --git a/tests/typecheck/success/prelude/Natural/toInteger/0B.dhall b/tests/typecheck/success/prelude/Natural/toInteger/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/toInteger/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Integer diff --git a/tests/typecheck/success/prelude/Natural/toInteger/1A.dhall b/tests/typecheck/success/prelude/Natural/toInteger/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/toInteger/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../Prelude/Natural/toInteger 0 diff --git a/tests/typecheck/success/prelude/Natural/toInteger/1B.dhall b/tests/typecheck/success/prelude/Natural/toInteger/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Natural/toInteger/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Integer diff --git a/tests/typecheck/success/prelude/Optional/all/0A.dhall b/tests/typecheck/success/prelude/Optional/all/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/all/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/all/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Optional/all/1A.dhall b/tests/typecheck/success/prelude/Optional/all/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/all/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/all/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Optional/any/0A.dhall b/tests/typecheck/success/prelude/Optional/any/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/any/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/any/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Optional/any/1A.dhall b/tests/typecheck/success/prelude/Optional/any/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/any/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/any/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Optional/build/0A.dhall b/tests/typecheck/success/prelude/Optional/build/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/build/0A.dhall +++ /dev/null @@ -1,7 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/build/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/build/1A.dhall b/tests/typecheck/success/prelude/Optional/build/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/build/1A.dhall +++ /dev/null @@ -1,7 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/build/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/concat/0A.dhall b/tests/typecheck/success/prelude/Optional/concat/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/concat/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/concat/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/concat/1A.dhall b/tests/typecheck/success/prelude/Optional/concat/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/concat/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/concat/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/concat/2A.dhall b/tests/typecheck/success/prelude/Optional/concat/2A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/concat/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/concat/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/filter/0A.dhall b/tests/typecheck/success/prelude/Optional/filter/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/filter/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/filter/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/filter/1A.dhall b/tests/typecheck/success/prelude/Optional/filter/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/filter/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/filter/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/fold/0A.dhall b/tests/typecheck/success/prelude/Optional/fold/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/fold/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/fold/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Optional/fold/1A.dhall b/tests/typecheck/success/prelude/Optional/fold/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/fold/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/fold/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Optional/head/0A.dhall b/tests/typecheck/success/prelude/Optional/head/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/head/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/head/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/head/1A.dhall b/tests/typecheck/success/prelude/Optional/head/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/head/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/head/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/head/2A.dhall b/tests/typecheck/success/prelude/Optional/head/2A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/head/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/head/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/last/0A.dhall b/tests/typecheck/success/prelude/Optional/last/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/last/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/last/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/last/1A.dhall b/tests/typecheck/success/prelude/Optional/last/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/last/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/last/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/last/2A.dhall b/tests/typecheck/success/prelude/Optional/last/2A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/last/2A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/last/2B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Natural diff --git a/tests/typecheck/success/prelude/Optional/length/0A.dhall b/tests/typecheck/success/prelude/Optional/length/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/length/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/length/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Optional/length/1A.dhall b/tests/typecheck/success/prelude/Optional/length/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/length/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/length/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Natural diff --git a/tests/typecheck/success/prelude/Optional/map/0A.dhall b/tests/typecheck/success/prelude/Optional/map/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/map/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/map/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Bool diff --git a/tests/typecheck/success/prelude/Optional/map/1A.dhall b/tests/typecheck/success/prelude/Optional/map/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/map/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/map/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Optional Bool diff --git a/tests/typecheck/success/prelude/Optional/null/0A.dhall b/tests/typecheck/success/prelude/Optional/null/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/null/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/null/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Optional/null/1A.dhall b/tests/typecheck/success/prelude/Optional/null/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/null/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/null/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Bool diff --git a/tests/typecheck/success/prelude/Optional/toList/0A.dhall b/tests/typecheck/success/prelude/Optional/toList/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/toList/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/toList/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/Optional/toList/1A.dhall b/tests/typecheck/success/prelude/Optional/toList/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/toList/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/toList/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -List Natural diff --git a/tests/typecheck/success/prelude/Optional/unzip/0A.dhall b/tests/typecheck/success/prelude/Optional/unzip/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/unzip/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/unzip/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/unzip/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Optional/unzip/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ _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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concat/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concat/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Text/concat/1A.dhall b/tests/typecheck/success/prelude/Text/concat/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concat/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concat/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Text/concatMap/0A.dhall b/tests/typecheck/success/prelude/Text/concatMap/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatMap/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatMap/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Text/concatMap/1A.dhall b/tests/typecheck/success/prelude/Text/concatMap/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatMap/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatMap/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall b/tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatMapSep/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall b/tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatMapSep/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Text/concatSep/0A.dhall b/tests/typecheck/success/prelude/Text/concatSep/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatSep/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatSep/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/prelude/Text/concatSep/1A.dhall b/tests/typecheck/success/prelude/Text/concatSep/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatSep/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -../../../../../../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 deleted file mode 100644 --- a/tests/typecheck/success/prelude/Text/concatSep/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Text diff --git a/tests/typecheck/success/recordOfRecordOfTypesA.dhall b/tests/typecheck/success/recordOfRecordOfTypesA.dhall deleted file mode 100644 --- a/tests/typecheck/success/recordOfRecordOfTypesA.dhall +++ /dev/null @@ -1,3 +0,0 @@ -let types = { Scopes = < Public : {} | Private : {} >} -let prelude = { types = types } -in prelude.types.Scopes.Public {=} diff --git a/tests/typecheck/success/recordOfRecordOfTypesB.dhall b/tests/typecheck/success/recordOfRecordOfTypesB.dhall deleted file mode 100644 --- a/tests/typecheck/success/recordOfRecordOfTypesB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -< Public : {} | Private : {} > diff --git a/tests/typecheck/success/recordOfTypesA.dhall b/tests/typecheck/success/recordOfTypesA.dhall deleted file mode 100644 --- a/tests/typecheck/success/recordOfTypesA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ x = Text, y = List } diff --git a/tests/typecheck/success/recordOfTypesB.dhall b/tests/typecheck/success/recordOfTypesB.dhall deleted file mode 100644 --- a/tests/typecheck/success/recordOfTypesB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ x : Type, y : Type → Type } diff --git a/tests/typecheck/success/simple/access/0A.dhall b/tests/typecheck/success/simple/access/0A.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/access/0A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ x = Text }.x diff --git a/tests/typecheck/success/simple/access/0B.dhall b/tests/typecheck/success/simple/access/0B.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/access/0B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -Type diff --git a/tests/typecheck/success/simple/access/1A.dhall b/tests/typecheck/success/simple/access/1A.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/access/1A.dhall +++ /dev/null @@ -1,1 +0,0 @@ -< Foo : Text | Bar : Natural >.Foo diff --git a/tests/typecheck/success/simple/access/1B.dhall b/tests/typecheck/success/simple/access/1B.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/access/1B.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(Foo : Text) → < Bar : Natural | Foo : Text > diff --git a/tests/typecheck/success/simple/alternativesAreTypesA.dhall b/tests/typecheck/success/simple/alternativesAreTypesA.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/alternativesAreTypesA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -< Left = List | Right : Type > diff --git a/tests/typecheck/success/simple/alternativesAreTypesB.dhall b/tests/typecheck/success/simple/alternativesAreTypesB.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/alternativesAreTypesB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -< Left : Type → Type | Right : Type > diff --git a/tests/typecheck/success/simple/anonymousFunctionsInTypesA.dhall b/tests/typecheck/success/simple/anonymousFunctionsInTypesA.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/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/success/simple/anonymousFunctionsInTypesB.dhall b/tests/typecheck/success/simple/anonymousFunctionsInTypesB.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/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/success/simple/fieldsAreTypesA.dhall b/tests/typecheck/success/simple/fieldsAreTypesA.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/fieldsAreTypesA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ x = Bool, y = Text, z = List } diff --git a/tests/typecheck/success/simple/fieldsAreTypesB.dhall b/tests/typecheck/success/simple/fieldsAreTypesB.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/fieldsAreTypesB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -{ x : Type, y : Type, z : Type → Type } diff --git a/tests/typecheck/success/simple/kindParameterA.dhall b/tests/typecheck/success/simple/kindParameterA.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/kindParameterA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -λ(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 deleted file mode 100644 --- a/tests/typecheck/success/simple/kindParameterB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(k : Kind) → (k → k → Type) → k → k → Type diff --git a/tests/typecheck/success/simple/mergeEquivalenceA.dhall b/tests/typecheck/success/simple/mergeEquivalenceA.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/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/success/simple/mergeEquivalenceB.dhall b/tests/typecheck/success/simple/mergeEquivalenceB.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/mergeEquivalenceB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -∀(a : Type) → ∀(f : {} → a) → ∀(ts : < Bar : {} | Baz : {} >) → a diff --git a/tests/typecheck/success/simple/mixedFieldAccessA.dhall b/tests/typecheck/success/simple/mixedFieldAccessA.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/mixedFieldAccessA.dhall +++ /dev/null @@ -1,7 +0,0 @@ --- 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 deleted file mode 100644 --- a/tests/typecheck/success/simple/mixedFieldAccessB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -< Private : {} | Public : {} > diff --git a/tests/typecheck/success/simple/unionsOfTypesA.dhall b/tests/typecheck/success/simple/unionsOfTypesA.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/unionsOfTypesA.dhall +++ /dev/null @@ -1,1 +0,0 @@ -< Left = List | Right : Type > diff --git a/tests/typecheck/success/simple/unionsOfTypesB.dhall b/tests/typecheck/success/simple/unionsOfTypesB.dhall deleted file mode 100644 --- a/tests/typecheck/success/simple/unionsOfTypesB.dhall +++ /dev/null @@ -1,1 +0,0 @@ -< Left : Type → Type | Right : Type >