packages feed

dhall 1.18.0 → 1.19.0

raw patch · 1123 files changed

+5502/−1851 lines, 1123 filesdep +uri-encodedep ~optparse-applicativePVP ok

version bump matches the API change (PVP)

Dependencies added: uri-encode

Dependency ranges changed: optparse-applicative

API changes (from Hackage documentation)

- Dhall: instance Dhall.Inject Data.Scientific.Scientific
- Dhall: instance Dhall.Inject a => Dhall.Inject (GHC.Base.Maybe a)
- Dhall: instance Dhall.Interpret a => Dhall.Interpret (GHC.Base.Maybe a)
- Dhall: instance GHC.Exception.Exception Dhall.InvalidType
- Dhall.Binary: V_3_0_0 :: StandardVersion
- Dhall.Binary: instance GHC.Exception.Exception Dhall.Binary.DecodingFailure
- Dhall.Import: instance GHC.Exception.Exception Dhall.Import.CannotImportHTTPURL
- Dhall.Import: instance GHC.Exception.Exception Dhall.Import.Cycle
- Dhall.Import: instance GHC.Exception.Exception Dhall.Import.HashMismatch
- Dhall.Import: instance GHC.Exception.Exception Dhall.Import.ImportResolutionDisabled
- Dhall.Import: instance GHC.Exception.Exception Dhall.Import.MissingEnvironmentVariable
- Dhall.Import: instance GHC.Exception.Exception Dhall.Import.MissingFile
- Dhall.Import: instance GHC.Exception.Exception Dhall.Import.MissingImports
- Dhall.Import: instance GHC.Exception.Exception Dhall.Import.ReferentiallyOpaque
- Dhall.Import: instance GHC.Exception.Exception e => GHC.Exception.Exception (Dhall.Import.Imported e)
- Dhall.Parser: instance GHC.Exception.Exception Dhall.Parser.ParseError
- Dhall.TypeCheck: NotARecord :: Text -> (Expr s a) -> (Expr s a) -> TypeMessage s a
- Dhall.TypeCheck: instance (GHC.Classes.Eq a, Data.Text.Prettyprint.Doc.Internal.Pretty s, Data.Text.Prettyprint.Doc.Internal.Pretty a, Data.Typeable.Internal.Typeable s, Data.Typeable.Internal.Typeable a) => GHC.Exception.Exception (Dhall.TypeCheck.DetailedTypeError s a)
- Dhall.TypeCheck: instance (GHC.Classes.Eq a, Data.Text.Prettyprint.Doc.Internal.Pretty s, Data.Text.Prettyprint.Doc.Internal.Pretty a, Data.Typeable.Internal.Typeable s, Data.Typeable.Internal.Typeable a) => GHC.Exception.Exception (Dhall.TypeCheck.TypeError s a)
+ Dhall: instance Dhall.Inject a => Dhall.Inject (GHC.Maybe.Maybe a)
+ Dhall: instance Dhall.Interpret a => Dhall.Interpret (GHC.Maybe.Maybe a)
+ Dhall: instance GHC.Exception.Type.Exception Dhall.InvalidType
+ Dhall.Binary: V_4_0_0 :: StandardVersion
+ Dhall.Binary: instance GHC.Exception.Type.Exception Dhall.Binary.DecodingFailure
+ Dhall.Core: Binding :: Text -> Maybe (Expr s a) -> Expr s a -> Binding s a
+ Dhall.Core: [annotation] :: Binding s a -> Maybe (Expr s a)
+ Dhall.Core: [value] :: Binding s a -> Expr s a
+ Dhall.Core: [variable] :: Binding s a -> Text
+ Dhall.Core: data Binding s a
+ Dhall.Core: instance (Data.Data.Data s, Data.Data.Data a) => Data.Data.Data (Dhall.Core.Binding s a)
+ Dhall.Core: instance (GHC.Classes.Eq s, GHC.Classes.Eq a) => GHC.Classes.Eq (Dhall.Core.Binding s a)
+ Dhall.Core: instance (GHC.Show.Show s, GHC.Show.Show a) => GHC.Show.Show (Dhall.Core.Binding s a)
+ Dhall.Core: instance Data.Bifunctor.Bifunctor Dhall.Core.Binding
+ Dhall.Core: instance Data.Foldable.Foldable (Dhall.Core.Binding s)
+ Dhall.Core: instance Data.Traversable.Traversable (Dhall.Core.Binding s)
+ Dhall.Core: instance GHC.Base.Functor (Dhall.Core.Binding s)
+ Dhall.Core: instance GHC.Generics.Generic (Dhall.Core.Binding s a)
+ Dhall.Core: normalizeWithM :: (Eq a, Monad m) => NormalizerM m a -> Expr s a -> m (Expr t a)
+ Dhall.Core: pathCharacter :: Char -> Bool
+ Dhall.Core: subExpressions :: Applicative f => (Expr s a -> f (Expr s a)) -> Expr s a -> f (Expr s a)
+ Dhall.Core: type NormalizerM m a = forall s. Expr s a -> m (Maybe (Expr s a))
+ Dhall.Import: instance GHC.Exception.Type.Exception Dhall.Import.CannotImportHTTPURL
+ Dhall.Import: instance GHC.Exception.Type.Exception Dhall.Import.Cycle
+ Dhall.Import: instance GHC.Exception.Type.Exception Dhall.Import.HashMismatch
+ Dhall.Import: instance GHC.Exception.Type.Exception Dhall.Import.ImportResolutionDisabled
+ Dhall.Import: instance GHC.Exception.Type.Exception Dhall.Import.MissingEnvironmentVariable
+ Dhall.Import: instance GHC.Exception.Type.Exception Dhall.Import.MissingFile
+ Dhall.Import: instance GHC.Exception.Type.Exception Dhall.Import.MissingImports
+ Dhall.Import: instance GHC.Exception.Type.Exception Dhall.Import.ReferentiallyOpaque
+ Dhall.Import: instance GHC.Exception.Type.Exception e => GHC.Exception.Type.Exception (Dhall.Import.Imported e)
+ Dhall.Parser: instance GHC.Exception.Type.Exception Dhall.Parser.ParseError
+ Dhall.Set: Set :: Set a -> Seq a -> Set a
+ Dhall.Set: append :: Ord a => a -> Set a -> Set a
+ Dhall.Set: data Set a
+ Dhall.Set: difference :: Ord a => Set a -> Set a -> [a]
+ Dhall.Set: empty :: Set a
+ Dhall.Set: fromList :: Ord a => [a] -> Set a
+ Dhall.Set: instance (Data.Data.Data a, GHC.Classes.Ord a) => Data.Data.Data (Dhall.Set.Set a)
+ Dhall.Set: instance Data.Foldable.Foldable Dhall.Set.Set
+ Dhall.Set: instance GHC.Classes.Eq a => GHC.Classes.Eq (Dhall.Set.Set a)
+ Dhall.Set: instance GHC.Classes.Ord a => GHC.Classes.Ord (Dhall.Set.Set a)
+ Dhall.Set: instance GHC.Generics.Generic (Dhall.Set.Set a)
+ Dhall.Set: instance GHC.Show.Show a => GHC.Show.Show (Dhall.Set.Set a)
+ Dhall.Set: toList :: Set a -> [a]
+ Dhall.Set: toSeq :: Set a -> Seq a
+ Dhall.Set: toSet :: Set a -> Set a
+ Dhall.TypeCheck: CantAccess :: Text -> Expr s a -> Expr s a -> TypeMessage s a
+ Dhall.TypeCheck: CantProject :: Text -> Expr s a -> Expr s a -> TypeMessage s a
+ Dhall.TypeCheck: instance (GHC.Classes.Eq a, Data.Text.Prettyprint.Doc.Internal.Pretty s, Data.Text.Prettyprint.Doc.Internal.Pretty a, Data.Typeable.Internal.Typeable s, Data.Typeable.Internal.Typeable a) => GHC.Exception.Type.Exception (Dhall.TypeCheck.DetailedTypeError s a)
+ Dhall.TypeCheck: instance (GHC.Classes.Eq a, Data.Text.Prettyprint.Doc.Internal.Pretty s, Data.Text.Prettyprint.Doc.Internal.Pretty a, Data.Typeable.Internal.Typeable s, Data.Typeable.Internal.Typeable a) => GHC.Exception.Type.Exception (Dhall.TypeCheck.TypeError s a)
- Dhall: (>$<) :: Contravariant f => a -> b -> f b -> f a
+ Dhall: (>$<) :: Contravariant f => (a -> b) -> f b -> f a
- Dhall: InputType :: a -> Expr Src X -> Expr Src X -> InputType a
+ Dhall: InputType :: (a -> Expr Src X) -> Expr Src X -> InputType a
- Dhall: InterpretOptions :: Text -> Text -> Text -> Text -> InterpretOptions
+ Dhall: InterpretOptions :: (Text -> Text) -> (Text -> Text) -> InterpretOptions
- Dhall: RecordInputType :: (Map Text (InputType a)) -> RecordInputType a
+ Dhall: RecordInputType :: Map Text (InputType a) -> RecordInputType a
- Dhall: RecordType :: (Product (Const (Map Text (Expr Src X))) (Compose ((->) (Expr Src X)) Maybe) a) -> RecordType a
+ Dhall: RecordType :: Product (Const (Map Text (Expr Src X))) (Compose ((->) (Expr Src X)) Maybe) a -> RecordType a
- Dhall: Type :: Expr Src X -> Maybe a -> Expr Src X -> Type a
+ Dhall: Type :: (Expr Src X -> Maybe a) -> Expr Src X -> Type a
- Dhall: rootDirectory :: (Functor f) => LensLike' f InputSettings FilePath
+ Dhall: rootDirectory :: Functor f => LensLike' f InputSettings FilePath
- Dhall: sourceName :: (Functor f) => LensLike' f InputSettings FilePath
+ Dhall: sourceName :: Functor f => LensLike' f InputSettings FilePath
- Dhall.Core: Annot :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: Annot :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: App :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: App :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: BoolAnd :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: BoolAnd :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: BoolEQ :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: BoolEQ :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: BoolIf :: (Expr s a) -> (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: BoolIf :: Expr s a -> Expr s a -> Expr s a -> Expr s a
- Dhall.Core: BoolNE :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: BoolNE :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: BoolOr :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: BoolOr :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: Combine :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: Combine :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: CombineTypes :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: CombineTypes :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: Constructors :: (Expr s a) -> Expr s a
+ Dhall.Core: Constructors :: Expr s a -> Expr s a
- Dhall.Core: DoubleLit :: Scientific -> Expr s a
+ Dhall.Core: DoubleLit :: Double -> Expr s a
- Dhall.Core: Field :: (Expr s a) -> Text -> Expr s a
+ Dhall.Core: Field :: Expr s a -> Text -> Expr s a
- Dhall.Core: ImportAlt :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: ImportAlt :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: Lam :: Text -> (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: Lam :: Text -> Expr s a -> Expr s a -> Expr s a
- Dhall.Core: Let :: Text -> (Maybe (Expr s a)) -> (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: Let :: NonEmpty (Binding s a) -> Expr s a -> Expr s a
- Dhall.Core: ListAppend :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: ListAppend :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: ListLit :: (Maybe (Expr s a)) -> (Seq (Expr s a)) -> Expr s a
+ Dhall.Core: ListLit :: Maybe (Expr s a) -> Seq (Expr s a) -> Expr s a
- Dhall.Core: Merge :: (Expr s a) -> (Expr s a) -> (Maybe (Expr s a)) -> Expr s a
+ Dhall.Core: Merge :: Expr s a -> Expr s a -> Maybe (Expr s a) -> Expr s a
- Dhall.Core: NaturalPlus :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: NaturalPlus :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: NaturalTimes :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: NaturalTimes :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: Note :: s -> (Expr s a) -> Expr s a
+ Dhall.Core: Note :: s -> Expr s a -> Expr s a
- Dhall.Core: OptionalLit :: (Expr s a) -> (Maybe (Expr s a)) -> Expr s a
+ Dhall.Core: OptionalLit :: Expr s a -> Maybe (Expr s a) -> Expr s a
- Dhall.Core: Pi :: Text -> (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: Pi :: Text -> Expr s a -> Expr s a -> Expr s a
- Dhall.Core: Prefer :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: Prefer :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: Project :: (Expr s a) -> (Set Text) -> Expr s a
+ Dhall.Core: Project :: Expr s a -> Set Text -> Expr s a
- Dhall.Core: Record :: (Map Text (Expr s a)) -> Expr s a
+ Dhall.Core: Record :: Map Text (Expr s a) -> Expr s a
- Dhall.Core: RecordLit :: (Map Text (Expr s a)) -> Expr s a
+ Dhall.Core: RecordLit :: Map Text (Expr s a) -> Expr s a
- Dhall.Core: Some :: (Expr s a) -> Expr s a
+ Dhall.Core: Some :: Expr s a -> Expr s a
- Dhall.Core: TextAppend :: (Expr s a) -> (Expr s a) -> Expr s a
+ Dhall.Core: TextAppend :: Expr s a -> Expr s a -> Expr s a
- Dhall.Core: TextLit :: (Chunks s a) -> Expr s a
+ Dhall.Core: TextLit :: Chunks s a -> Expr s a
- Dhall.Core: Union :: (Map Text (Expr s a)) -> Expr s a
+ Dhall.Core: Union :: Map Text (Expr s a) -> Expr s a
- Dhall.Core: UnionLit :: Text -> (Expr s a) -> (Map Text (Expr s a)) -> Expr s a
+ Dhall.Core: UnionLit :: Text -> Expr s a -> Map Text (Expr s a) -> Expr s a
- Dhall.Core: type Normalizer a = forall s. Expr s a -> Maybe (Expr s a)
+ Dhall.Core: type Normalizer a = NormalizerM Identity a
- Dhall.Import: hashExpression :: StandardVersion -> Expr s X -> (Digest SHA256)
+ Dhall.Import: hashExpression :: StandardVersion -> Expr s X -> Digest SHA256
- Dhall.TypeCheck: AnnotMismatch :: (Expr s a) -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: AnnotMismatch :: Expr s a -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: CantAdd :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: CantAdd :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: CantAnd :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: CantAnd :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: CantEQ :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: CantEQ :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: CantInterpolate :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: CantInterpolate :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: CantListAppend :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: CantListAppend :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: CantMultiply :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: CantMultiply :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: CantNE :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: CantNE :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: CantOr :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: CantOr :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: CantTextAppend :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: CantTextAppend :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: CombineTypesRequiresRecordType :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: CombineTypesRequiresRecordType :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: ConstructorsRequiresAUnionType :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: ConstructorsRequiresAUnionType :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: DetailedTypeError :: (TypeError s a) -> DetailedTypeError s a
+ Dhall.TypeCheck: DetailedTypeError :: TypeError s a -> DetailedTypeError s a
- Dhall.TypeCheck: FieldAnnotationMismatch :: Text -> (Expr s a) -> Const -> Text -> (Expr s a) -> Const -> TypeMessage s a
+ Dhall.TypeCheck: FieldAnnotationMismatch :: Text -> Expr s a -> Const -> Text -> Expr s a -> Const -> TypeMessage s a
- Dhall.TypeCheck: FieldMismatch :: Text -> (Expr s a) -> Const -> Text -> (Expr s a) -> Const -> TypeMessage s a
+ Dhall.TypeCheck: FieldMismatch :: Text -> Expr s a -> Const -> Text -> Expr s a -> Const -> TypeMessage s a
- Dhall.TypeCheck: HandlerInputTypeMismatch :: Text -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: HandlerInputTypeMismatch :: Text -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: HandlerNotAFunction :: Text -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: HandlerNotAFunction :: Text -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: HandlerOutputTypeMismatch :: Text -> (Expr s a) -> Text -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: HandlerOutputTypeMismatch :: Text -> Expr s a -> Text -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: IfBranchMismatch :: (Expr s a) -> (Expr s a) -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: IfBranchMismatch :: Expr s a -> Expr s a -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: IfBranchMustBeTerm :: Bool -> (Expr s a) -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: IfBranchMustBeTerm :: Bool -> Expr s a -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidAlternative :: Text -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidAlternative :: Text -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidAlternativeType :: Text -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidAlternativeType :: Text -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidField :: Text -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidField :: Text -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidFieldType :: Text -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidFieldType :: Text -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidHandlerOutputType :: Text -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidHandlerOutputType :: Text -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidInputType :: (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidInputType :: Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidListElement :: Int -> (Expr s a) -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidListElement :: Int -> Expr s a -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidListType :: (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidListType :: Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidOptionalElement :: (Expr s a) -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidOptionalElement :: Expr s a -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidOptionalType :: (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidOptionalType :: Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidOutputType :: (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidOutputType :: Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidPredicate :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidPredicate :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidSome :: (Expr s a) -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: InvalidSome :: Expr s a -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: ListAppendMismatch :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: ListAppendMismatch :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: MismatchedListElements :: Int -> (Expr s a) -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: MismatchedListElements :: Int -> Expr s a -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: MissingField :: Text -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: MissingField :: Text -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: MissingHandler :: (Set Text) -> TypeMessage s a
+ Dhall.TypeCheck: MissingHandler :: Set Text -> TypeMessage s a
- Dhall.TypeCheck: MustCombineARecord :: Char -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: MustCombineARecord :: Char -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: MustMergeARecord :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: MustMergeARecord :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: MustMergeUnion :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: MustMergeUnion :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: NoDependentTypes :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: NoDependentTypes :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: NotAFunction :: (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: NotAFunction :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: RecordMismatch :: Char -> (Expr s a) -> (Expr s a) -> Const -> Const -> TypeMessage s a
+ Dhall.TypeCheck: RecordMismatch :: Char -> Expr s a -> Expr s a -> Const -> Const -> TypeMessage s a
- Dhall.TypeCheck: RecordTypeMismatch :: Const -> Const -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: RecordTypeMismatch :: Const -> Const -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: TypeMismatch :: (Expr s a) -> (Expr s a) -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: TypeMismatch :: Expr s a -> Expr s a -> Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: UnusedHandler :: (Set Text) -> TypeMessage s a
+ Dhall.TypeCheck: UnusedHandler :: Set Text -> TypeMessage s a
- Dhall.TypeCheck: X :: forall a. a -> X
+ Dhall.TypeCheck: X :: (forall a. a) -> X

Files

CHANGELOG.md view
@@ -1,3 +1,46 @@+1.19.0++* Supports version 4.0.0 of the language standard+    * See: https://github.com/dhall-lang/dhall-lang/releases/tag/v4.0.0+* BREAKING CHANGE TO THE LANGUAGE AND API: Prevent Hurkens' paradox+    * This fixes a type-checking soundness bug which permitted infinite loops+    * This is a breaking change because infinite loops are no longer possible+    * This is also a breaking change because a record of types is now treated as+      a kind instead of a type+    * See: https://github.com/dhall-lang/dhall-haskell/pull/680+* BREAKING CHANGE TO THE LANGUAGE AND API: `Double`s are now double-precision+  floating point numbers+    * This restricts the range of `Double`s to IEEE 754 double-precision+      floating point+    * This also implies that you can no longer convert `Scientific` values to+      `Dhall` expressions (i.e. no `Inject` instance for `Scientific`)+    * See: https://github.com/dhall-lang/dhall-haskell/pull/667+* BREAKING CHANGE TO THE API: Preserve field order for record projection+    * The API uses a new `Dhall.Set.Set` type instead of `Data.Set.Set`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/670+* BREAKING CHANGE TO THE API: Add support for multi-`let` expressions+    * This changes the `Let` constructor to now support storing multiple+      bindings per `let` expression+    * See: https://github.com/dhall-lang/dhall-haskell/pull/675+* Support GHC 8.6+    * See: https://github.com/dhall-lang/dhall-haskell/pull/669+* Add support for quoted path components+    * i.e. `/"foo"/bar/"baz qux"` or `https://example.com/foo/"bar?baz"?qux`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/690+* Fix parsing of `//\\` operator+    * See: https://github.com/dhall-lang/dhall-haskell/commit/9d0fd42d95ab69fa64da4afd8b60d69aca8e65a6+* Preserve Unicode characters when formatting code+    * See: https://github.com/dhall-lang/dhall-haskell/pull/679+* Allow identifier names to begin with `Some`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/658+* Add `subExpressions` `Traversal`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/660+* Add `normalizeWithM` for monadic normalization+    * See: https://github.com/dhall-lang/dhall-haskell/pull/371+* Custom normalizers now take precedence over default normalization logic+    * This allows one to override the implementation of built-in operators+    * See: https://github.com/dhall-lang/dhall-haskell/pull/684+ 1.18.0  * Supports version 3.0.0 of the language standard:
LICENSE view
@@ -1,24 +1,27 @@-Copyright (c) 2017 Gabriel Gonzalez+Copyright (c) 2018 Gabriel Gonzalez All rights reserved. -Redistribution and use in source and binary forms, with or without modification,-are permitted provided that the following conditions are met:-    * Redistributions of source code must retain the above copyright notice,-      this list of conditions and the following disclaimer.-    * Redistributions in binary form must reproduce the above copyright notice,-      this list of conditions and the following disclaimer in the documentation-      and/or other materials provided with the distribution.-    * Neither the name of Gabriel Gonzalez nor the names of other contributors-      may be used to endorse or promote products derived from this software-      without specific prior written permission.+Redistribution and use in source and binary forms, with or without+modification, are permitted provided that the following conditions are met: -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.+1. Redistributions of source code must retain the above copyright notice, this+list of conditions and the following disclaimer.++2. Redistributions in binary form must reproduce the above copyright notice,+this list of conditions and the following disclaimer in the documentation+and/or other materials provided with the distribution.++3. Neither the name of the author nor the names of its contributors may be+used to endorse or promote products derived from this software without+specific prior written permission.++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Prelude/Monoid view
@@ -1,1 +1,1 @@-https://raw.githubusercontent.com/dhall-lang/Prelude/a22da69657b9316a3c51ba0bf80c9d4024db3fce/Monoid sha256:7c753f458fb433ef50e2fc517c0eaffbf21afd07186cefa92ea77173fe83304e+https://raw.githubusercontent.com/dhall-lang/Prelude/a22da69657b9316a3c51ba0bf80c9d4024db3fce/Monoid sha256:c4ff4f04ce9d3b7b579ff2ac7fe00258d665c701f895493b73082b750b28553d
Prelude/package.dhall view
@@ -1,1 +1,1 @@-https://raw.githubusercontent.com/dhall-lang/Prelude/e9c90396c02f9eb0fe66c00c544615cbfa068f34/package.dhall sha256:9fbb8a6db3360fa30086ea8462dc36087f0e4f87af2a1f802a8befdc5a08f809+https://raw.githubusercontent.com/dhall-lang/Prelude/e9c90396c02f9eb0fe66c00c544615cbfa068f34/package.dhall sha256:534e4a9e687ba74bfac71b30fc27aa269c0465087ef79bf483e876781602a454
benchmark/deep-nested-large-record/Main.hs view
@@ -25,7 +25,7 @@ issue412 prelude = Criterion.whnf TypeCheck.typeOf expr   where     expr-      = Core.Let "prelude" Nothing prelude+      = Core.Let (pure (Core.Binding "prelude" Nothing prelude))       $ Core.ListLit Nothing       $ Seq.replicate 5       $ Core.Var (Core.V "prelude" 0) `Core.Field` "types" `Core.Field` "Little" `Core.Field` "Foo"@@ -33,12 +33,15 @@ unionPerformance :: Core.Expr s TypeCheck.X -> Criterion.Benchmarkable unionPerformance prelude = Criterion.whnf TypeCheck.typeOf expr   where-    expr =-        Core.Let "x" Nothing-            (Core.Let "big" Nothing (prelude `Core.Field` "types" `Core.Field` "Big")-                (Core.Prefer "big" "big")-            )-            "x"+    innerBinding =+        Core.Binding "big" Nothing+            (prelude `Core.Field` "types" `Core.Field` "Big")++    outerBinding =+        Core.Binding "x" Nothing+            (Core.Let (pure innerBinding) (Core.Prefer "big" "big"))++    expr = Core.Let (pure outerBinding) "x"  main :: IO () main = do
dhall.cabal view
@@ -1,5 +1,5 @@ Name: dhall-Version: 1.18.0+Version: 1.19.0 Cabal-Version: >=1.10 Build-Type: Simple Tested-With: GHC == 8.0.1@@ -23,87 +23,268 @@     Read "Dhall.Tutorial" to learn how to use this library Category: Compiler Extra-Source-Files:+    benchmark/deep-nested-large-record/*.dhall+    benchmark/examples/*.dhall     CHANGELOG.md-    Prelude/package.dhall     Prelude/Monoid+    Prelude/package.dhall     tests/format/*.dhall-    tests/normalization/tutorial/combineTypes/*.dhall-    tests/normalization/tutorial/projection/*.dhall-    tests/normalization/*.dhall-    tests/normalization/examples/Bool/and/*.dhall-    tests/normalization/examples/Bool/build/*.dhall-    tests/normalization/examples/Bool/even/*.dhall-    tests/normalization/examples/Bool/fold/*.dhall-    tests/normalization/examples/Bool/not/*.dhall-    tests/normalization/examples/Bool/odd/*.dhall-    tests/normalization/examples/Bool/or/*.dhall-    tests/normalization/examples/Bool/show/*.dhall-    tests/normalization/examples/Double/show/*.dhall-    tests/normalization/examples/Integer/show/*.dhall-    tests/normalization/examples/Integer/toDouble/*.dhall-    tests/normalization/examples/List/all/*.dhall-    tests/normalization/examples/List/any/*.dhall-    tests/normalization/examples/List/build/*.dhall-    tests/normalization/examples/List/concat/*.dhall-    tests/normalization/examples/List/concatMap/*.dhall-    tests/normalization/examples/List/filter/*.dhall-    tests/normalization/examples/List/fold/*.dhall-    tests/normalization/examples/List/generate/*.dhall-    tests/normalization/examples/List/head/*.dhall-    tests/normalization/examples/List/indexed/*.dhall-    tests/normalization/examples/List/iterate/*.dhall-    tests/normalization/examples/List/last/*.dhall-    tests/normalization/examples/List/length/*.dhall-    tests/normalization/examples/List/map/*.dhall-    tests/normalization/examples/List/null/*.dhall-    tests/normalization/examples/List/replicate/*.dhall-    tests/normalization/examples/List/reverse/*.dhall-    tests/normalization/examples/List/shifted/*.dhall-    tests/normalization/examples/List/unzip/*.dhall-    tests/normalization/examples/Natural/build/*.dhall-    tests/normalization/examples/Natural/enumerate/*.dhall-    tests/normalization/examples/Natural/even/*.dhall-    tests/normalization/examples/Natural/fold/*.dhall-    tests/normalization/examples/Natural/isZero/*.dhall-    tests/normalization/examples/Natural/odd/*.dhall-    tests/normalization/examples/Natural/product/*.dhall-    tests/normalization/examples/Natural/show/*.dhall-    tests/normalization/examples/Natural/sum/*.dhall-    tests/normalization/examples/Natural/toDouble/*.dhall-    tests/normalization/examples/Natural/toInteger/*.dhall-    tests/normalization/examples/Optional/all/*.dhall-    tests/normalization/examples/Optional/any/*.dhall-    tests/normalization/examples/Optional/build/*.dhall-    tests/normalization/examples/Optional/concat/*.dhall-    tests/normalization/examples/Optional/filter/*.dhall-    tests/normalization/examples/Optional/fold/*.dhall-    tests/normalization/examples/Optional/head/*.dhall-    tests/normalization/examples/Optional/last/*.dhall-    tests/normalization/examples/Optional/length/*.dhall-    tests/normalization/examples/Optional/map/*.dhall-    tests/normalization/examples/Optional/null/*.dhall-    tests/normalization/examples/Optional/toList/*.dhall-    tests/normalization/examples/Optional/unzip/*.dhall-    tests/normalization/examples/Text/concat/*.dhall-    tests/normalization/examples/Text/concatMap/*.dhall-    tests/normalization/examples/Text/concatMapSep/*.dhall-    tests/normalization/examples/Text/concatSep/*.dhall-    tests/normalization/simplifications/*.dhall-    tests/parser/*.dhall+    tests/import/data/fieldOrder/*.dhall+    tests/import/data/foo/bar/*.dhall+    tests/import/failure/*.dhall+    tests/import/success/*.dhall+    tests/normalization/success/*.dhall+    tests/normalization/success/haskell-tutorial/access/*.dhall+    tests/normalization/success/haskell-tutorial/combineTypes/*.dhall+    tests/normalization/success/haskell-tutorial/prefer/*.dhall+    tests/normalization/success/haskell-tutorial/projection/*.dhall+    tests/normalization/success/prelude/Bool/and/*.dhall+    tests/normalization/success/prelude/Bool/and/*.dhall+    tests/normalization/success/prelude/Bool/build/*.dhall+    tests/normalization/success/prelude/Bool/build/*.dhall+    tests/normalization/success/prelude/Bool/even/*.dhall+    tests/normalization/success/prelude/Bool/even/*.dhall+    tests/normalization/success/prelude/Bool/fold/*.dhall+    tests/normalization/success/prelude/Bool/fold/*.dhall+    tests/normalization/success/prelude/Bool/not/*.dhall+    tests/normalization/success/prelude/Bool/not/*.dhall+    tests/normalization/success/prelude/Bool/odd/*.dhall+    tests/normalization/success/prelude/Bool/odd/*.dhall+    tests/normalization/success/prelude/Bool/or/*.dhall+    tests/normalization/success/prelude/Bool/or/*.dhall+    tests/normalization/success/prelude/Bool/show/*.dhall+    tests/normalization/success/prelude/Bool/show/*.dhall+    tests/normalization/success/prelude/Double/show/*.dhall+    tests/normalization/success/prelude/Double/show/*.dhall+    tests/normalization/success/prelude/Integer/show/*.dhall+    tests/normalization/success/prelude/Integer/show/*.dhall+    tests/normalization/success/prelude/Integer/toDouble/*.dhall+    tests/normalization/success/prelude/Integer/toDouble/*.dhall+    tests/normalization/success/prelude/List/all/*.dhall+    tests/normalization/success/prelude/List/all/*.dhall+    tests/normalization/success/prelude/List/any/*.dhall+    tests/normalization/success/prelude/List/any/*.dhall+    tests/normalization/success/prelude/List/build/*.dhall+    tests/normalization/success/prelude/List/build/*.dhall+    tests/normalization/success/prelude/List/concat/*.dhall+    tests/normalization/success/prelude/List/concat/*.dhall+    tests/normalization/success/prelude/List/concatMap/*.dhall+    tests/normalization/success/prelude/List/concatMap/*.dhall+    tests/normalization/success/prelude/List/filter/*.dhall+    tests/normalization/success/prelude/List/filter/*.dhall+    tests/normalization/success/prelude/List/fold/*.dhall+    tests/normalization/success/prelude/List/fold/*.dhall+    tests/normalization/success/prelude/List/generate/*.dhall+    tests/normalization/success/prelude/List/generate/*.dhall+    tests/normalization/success/prelude/List/head/*.dhall+    tests/normalization/success/prelude/List/head/*.dhall+    tests/normalization/success/prelude/List/indexed/*.dhall+    tests/normalization/success/prelude/List/indexed/*.dhall+    tests/normalization/success/prelude/List/iterate/*.dhall+    tests/normalization/success/prelude/List/iterate/*.dhall+    tests/normalization/success/prelude/List/last/*.dhall+    tests/normalization/success/prelude/List/last/*.dhall+    tests/normalization/success/prelude/List/length/*.dhall+    tests/normalization/success/prelude/List/length/*.dhall+    tests/normalization/success/prelude/List/map/*.dhall+    tests/normalization/success/prelude/List/map/*.dhall+    tests/normalization/success/prelude/List/null/*.dhall+    tests/normalization/success/prelude/List/null/*.dhall+    tests/normalization/success/prelude/List/replicate/*.dhall+    tests/normalization/success/prelude/List/replicate/*.dhall+    tests/normalization/success/prelude/List/reverse/*.dhall+    tests/normalization/success/prelude/List/reverse/*.dhall+    tests/normalization/success/prelude/List/shifted/*.dhall+    tests/normalization/success/prelude/List/shifted/*.dhall+    tests/normalization/success/prelude/List/unzip/*.dhall+    tests/normalization/success/prelude/List/unzip/*.dhall+    tests/normalization/success/prelude/Natural/build/*.dhall+    tests/normalization/success/prelude/Natural/build/*.dhall+    tests/normalization/success/prelude/Natural/enumerate/*.dhall+    tests/normalization/success/prelude/Natural/enumerate/*.dhall+    tests/normalization/success/prelude/Natural/even/*.dhall+    tests/normalization/success/prelude/Natural/even/*.dhall+    tests/normalization/success/prelude/Natural/fold/*.dhall+    tests/normalization/success/prelude/Natural/fold/*.dhall+    tests/normalization/success/prelude/Natural/isZero/*.dhall+    tests/normalization/success/prelude/Natural/isZero/*.dhall+    tests/normalization/success/prelude/Natural/odd/*.dhall+    tests/normalization/success/prelude/Natural/odd/*.dhall+    tests/normalization/success/prelude/Natural/product/*.dhall+    tests/normalization/success/prelude/Natural/product/*.dhall+    tests/normalization/success/prelude/Natural/show/*.dhall+    tests/normalization/success/prelude/Natural/show/*.dhall+    tests/normalization/success/prelude/Natural/sum/*.dhall+    tests/normalization/success/prelude/Natural/sum/*.dhall+    tests/normalization/success/prelude/Natural/toDouble/*.dhall+    tests/normalization/success/prelude/Natural/toDouble/*.dhall+    tests/normalization/success/prelude/Natural/toInteger/*.dhall+    tests/normalization/success/prelude/Natural/toInteger/*.dhall+    tests/normalization/success/prelude/Optional/all/*.dhall+    tests/normalization/success/prelude/Optional/all/*.dhall+    tests/normalization/success/prelude/Optional/any/*.dhall+    tests/normalization/success/prelude/Optional/any/*.dhall+    tests/normalization/success/prelude/Optional/build/*.dhall+    tests/normalization/success/prelude/Optional/build/*.dhall+    tests/normalization/success/prelude/Optional/concat/*.dhall+    tests/normalization/success/prelude/Optional/concat/*.dhall+    tests/normalization/success/prelude/Optional/filter/*.dhall+    tests/normalization/success/prelude/Optional/filter/*.dhall+    tests/normalization/success/prelude/Optional/fold/*.dhall+    tests/normalization/success/prelude/Optional/fold/*.dhall+    tests/normalization/success/prelude/Optional/head/*.dhall+    tests/normalization/success/prelude/Optional/head/*.dhall+    tests/normalization/success/prelude/Optional/last/*.dhall+    tests/normalization/success/prelude/Optional/last/*.dhall+    tests/normalization/success/prelude/Optional/length/*.dhall+    tests/normalization/success/prelude/Optional/length/*.dhall+    tests/normalization/success/prelude/Optional/map/*.dhall+    tests/normalization/success/prelude/Optional/map/*.dhall+    tests/normalization/success/prelude/Optional/null/*.dhall+    tests/normalization/success/prelude/Optional/null/*.dhall+    tests/normalization/success/prelude/Optional/toList/*.dhall+    tests/normalization/success/prelude/Optional/toList/*.dhall+    tests/normalization/success/prelude/Optional/unzip/*.dhall+    tests/normalization/success/prelude/Optional/unzip/*.dhall+    tests/normalization/success/prelude/Text/concat/*.dhall+    tests/normalization/success/prelude/Text/concat/*.dhall+    tests/normalization/success/prelude/Text/concatMap/*.dhall+    tests/normalization/success/prelude/Text/concatMap/*.dhall+    tests/normalization/success/prelude/Text/concatMapSep/*.dhall+    tests/normalization/success/prelude/Text/concatMapSep/*.dhall+    tests/normalization/success/prelude/Text/concatSep/*.dhall+    tests/normalization/success/prelude/Text/concatSep/*.dhall+    tests/normalization/success/simple/*.dhall+    tests/normalization/success/simplifications/*.dhall     tests/parser/failure/*.dhall+    tests/parser/success/*.dhall     tests/regression/*.dhall     tests/tutorial/*.dhall-    tests/typecheck/*.dhall     tests/typecheck/failure/*.dhall-    tests/typecheck/examples/Monoid/*.dhall-    tests/import/*.dhall-    tests/import/data/foo/bar/a.dhall-    benchmark/examples/*.dhall-    benchmark/deep-nested-large-record/*.dhall+    tests/typecheck/success/*.dhall+    tests/typecheck/success/prelude/Bool/and/*.dhall+    tests/typecheck/success/prelude/Bool/and/*.dhall+    tests/typecheck/success/prelude/Bool/build/*.dhall+    tests/typecheck/success/prelude/Bool/build/*.dhall+    tests/typecheck/success/prelude/Bool/even/*.dhall+    tests/typecheck/success/prelude/Bool/even/*.dhall+    tests/typecheck/success/prelude/Bool/fold/*.dhall+    tests/typecheck/success/prelude/Bool/fold/*.dhall+    tests/typecheck/success/prelude/Bool/not/*.dhall+    tests/typecheck/success/prelude/Bool/not/*.dhall+    tests/typecheck/success/prelude/Bool/odd/*.dhall+    tests/typecheck/success/prelude/Bool/odd/*.dhall+    tests/typecheck/success/prelude/Bool/or/*.dhall+    tests/typecheck/success/prelude/Bool/or/*.dhall+    tests/typecheck/success/prelude/Bool/show/*.dhall+    tests/typecheck/success/prelude/Bool/show/*.dhall+    tests/typecheck/success/prelude/Double/show/*.dhall+    tests/typecheck/success/prelude/Double/show/*.dhall+    tests/typecheck/success/prelude/Integer/show/*.dhall+    tests/typecheck/success/prelude/Integer/show/*.dhall+    tests/typecheck/success/prelude/Integer/toDouble/*.dhall+    tests/typecheck/success/prelude/Integer/toDouble/*.dhall+    tests/typecheck/success/prelude/List/all/*.dhall+    tests/typecheck/success/prelude/List/all/*.dhall+    tests/typecheck/success/prelude/List/any/*.dhall+    tests/typecheck/success/prelude/List/any/*.dhall+    tests/typecheck/success/prelude/List/build/*.dhall+    tests/typecheck/success/prelude/List/build/*.dhall+    tests/typecheck/success/prelude/List/concat/*.dhall+    tests/typecheck/success/prelude/List/concat/*.dhall+    tests/typecheck/success/prelude/List/concatMap/*.dhall+    tests/typecheck/success/prelude/List/concatMap/*.dhall+    tests/typecheck/success/prelude/List/filter/*.dhall+    tests/typecheck/success/prelude/List/filter/*.dhall+    tests/typecheck/success/prelude/List/fold/*.dhall+    tests/typecheck/success/prelude/List/fold/*.dhall+    tests/typecheck/success/prelude/List/generate/*.dhall+    tests/typecheck/success/prelude/List/generate/*.dhall+    tests/typecheck/success/prelude/List/head/*.dhall+    tests/typecheck/success/prelude/List/head/*.dhall+    tests/typecheck/success/prelude/List/indexed/*.dhall+    tests/typecheck/success/prelude/List/indexed/*.dhall+    tests/typecheck/success/prelude/List/iterate/*.dhall+    tests/typecheck/success/prelude/List/iterate/*.dhall+    tests/typecheck/success/prelude/List/last/*.dhall+    tests/typecheck/success/prelude/List/last/*.dhall+    tests/typecheck/success/prelude/List/length/*.dhall+    tests/typecheck/success/prelude/List/length/*.dhall+    tests/typecheck/success/prelude/List/map/*.dhall+    tests/typecheck/success/prelude/List/map/*.dhall+    tests/typecheck/success/prelude/List/null/*.dhall+    tests/typecheck/success/prelude/List/null/*.dhall+    tests/typecheck/success/prelude/List/replicate/*.dhall+    tests/typecheck/success/prelude/List/replicate/*.dhall+    tests/typecheck/success/prelude/List/reverse/*.dhall+    tests/typecheck/success/prelude/List/reverse/*.dhall+    tests/typecheck/success/prelude/List/shifted/*.dhall+    tests/typecheck/success/prelude/List/shifted/*.dhall+    tests/typecheck/success/prelude/List/unzip/*.dhall+    tests/typecheck/success/prelude/List/unzip/*.dhall+    tests/typecheck/success/prelude/Monoid/*.dhall+    tests/typecheck/success/prelude/Natural/build/*.dhall+    tests/typecheck/success/prelude/Natural/build/*.dhall+    tests/typecheck/success/prelude/Natural/enumerate/*.dhall+    tests/typecheck/success/prelude/Natural/enumerate/*.dhall+    tests/typecheck/success/prelude/Natural/even/*.dhall+    tests/typecheck/success/prelude/Natural/even/*.dhall+    tests/typecheck/success/prelude/Natural/fold/*.dhall+    tests/typecheck/success/prelude/Natural/fold/*.dhall+    tests/typecheck/success/prelude/Natural/isZero/*.dhall+    tests/typecheck/success/prelude/Natural/isZero/*.dhall+    tests/typecheck/success/prelude/Natural/odd/*.dhall+    tests/typecheck/success/prelude/Natural/odd/*.dhall+    tests/typecheck/success/prelude/Natural/product/*.dhall+    tests/typecheck/success/prelude/Natural/product/*.dhall+    tests/typecheck/success/prelude/Natural/show/*.dhall+    tests/typecheck/success/prelude/Natural/show/*.dhall+    tests/typecheck/success/prelude/Natural/sum/*.dhall+    tests/typecheck/success/prelude/Natural/sum/*.dhall+    tests/typecheck/success/prelude/Natural/toDouble/*.dhall+    tests/typecheck/success/prelude/Natural/toDouble/*.dhall+    tests/typecheck/success/prelude/Natural/toInteger/*.dhall+    tests/typecheck/success/prelude/Natural/toInteger/*.dhall+    tests/typecheck/success/prelude/Optional/all/*.dhall+    tests/typecheck/success/prelude/Optional/all/*.dhall+    tests/typecheck/success/prelude/Optional/any/*.dhall+    tests/typecheck/success/prelude/Optional/any/*.dhall+    tests/typecheck/success/prelude/Optional/build/*.dhall+    tests/typecheck/success/prelude/Optional/build/*.dhall+    tests/typecheck/success/prelude/Optional/concat/*.dhall+    tests/typecheck/success/prelude/Optional/concat/*.dhall+    tests/typecheck/success/prelude/Optional/filter/*.dhall+    tests/typecheck/success/prelude/Optional/filter/*.dhall+    tests/typecheck/success/prelude/Optional/fold/*.dhall+    tests/typecheck/success/prelude/Optional/fold/*.dhall+    tests/typecheck/success/prelude/Optional/head/*.dhall+    tests/typecheck/success/prelude/Optional/head/*.dhall+    tests/typecheck/success/prelude/Optional/last/*.dhall+    tests/typecheck/success/prelude/Optional/last/*.dhall+    tests/typecheck/success/prelude/Optional/length/*.dhall+    tests/typecheck/success/prelude/Optional/length/*.dhall+    tests/typecheck/success/prelude/Optional/map/*.dhall+    tests/typecheck/success/prelude/Optional/map/*.dhall+    tests/typecheck/success/prelude/Optional/null/*.dhall+    tests/typecheck/success/prelude/Optional/null/*.dhall+    tests/typecheck/success/prelude/Optional/toList/*.dhall+    tests/typecheck/success/prelude/Optional/toList/*.dhall+    tests/typecheck/success/prelude/Optional/unzip/*.dhall+    tests/typecheck/success/prelude/Optional/unzip/*.dhall+    tests/typecheck/success/prelude/Text/concat/*.dhall+    tests/typecheck/success/prelude/Text/concat/*.dhall+    tests/typecheck/success/prelude/Text/concatMap/*.dhall+    tests/typecheck/success/prelude/Text/concatMap/*.dhall+    tests/typecheck/success/prelude/Text/concatMapSep/*.dhall+    tests/typecheck/success/prelude/Text/concatMapSep/*.dhall+    tests/typecheck/success/prelude/Text/concatSep/*.dhall+    tests/typecheck/success/prelude/Text/concatSep/*.dhall+    tests/typecheck/success/simple/access/*.dhall+    tests/typecheck/success/simple/*.dhall  Source-Repository head     Type: git-    Location: https://github.com/dhall-lang/dhall-haskell+    Location: https://github.com/dhall-lang/dhall-haskell/tree/master/dhall  Flag with-http   Description: Include support for importing dhall modules from HTTP URLs@@ -130,7 +311,7 @@         megaparsec                  >= 7.0.0    && < 7.1 ,         memory                      >= 0.14     && < 0.15,         mtl                         >= 2.2.1    && < 2.3 ,-        optparse-applicative                       < 0.15,+        optparse-applicative        >= 0.14.0.0 && < 0.15,         parsers                     >= 0.12.4   && < 0.13,         prettyprinter               >= 1.2.0.1  && < 1.3 ,         prettyprinter-ansi-terminal >= 1.1.1    && < 1.2 ,@@ -141,6 +322,7 @@         text                        >= 0.11.1.0 && < 1.3 ,         transformers                >= 0.2.0.0  && < 0.6 ,         unordered-containers        >= 0.1.3.0  && < 0.3 ,+        uri-encode                                 < 1.6 ,         vector                      >= 0.11.0.0 && < 0.13     if flag(with-http)       Build-Depends:@@ -164,6 +346,7 @@         Dhall.Lint,         Dhall.Main,         Dhall.Map,+        Dhall.Set,         Dhall.Parser,         Dhall.Pretty,         Dhall.Repl,
src/Dhall.hs view
@@ -211,7 +211,7 @@ defaultEvaluateSettings :: EvaluateSettings defaultEvaluateSettings = EvaluateSettings   { _startingContext = Dhall.Context.empty-  , _normalizer      = Dhall.Core.ReifiedNormalizer (const Nothing)+  , _normalizer      = Dhall.Core.ReifiedNormalizer (const (pure Nothing))   , _standardVersion = Dhall.Binary.defaultStandardVersion   } @@ -616,16 +616,11 @@  {-| Decode a `Scientific` ->>> input scientific "1e1000000000"-1.0e1000000000+>>> input scientific "1e100"+1.0e100 -} scientific :: Type Scientific-scientific = Type {..}-  where-    extract (DoubleLit n) = pure n-    extract  _            = empty--    expected = Double+scientific = fmap Data.Scientific.fromFloatDigits double  {-| Decode a `Double` @@ -633,8 +628,13 @@ 42.0 -} double :: Type Double-double = fmap Data.Scientific.toRealFloat scientific+double = Type {..}+  where+    extract (DoubleLit n) = pure n+    extract  _            = empty +    expected = Double+ {-| Decode lazy `Text`  >>> input lazyText "\"Test\""@@ -1103,16 +1103,12 @@          declared = Integer -instance Inject Scientific where+instance Inject Double where     injectWith _ = InputType {..}       where         embed = DoubleLit          declared = Double--instance Inject Double where-    injectWith =-        fmap (contramap (Data.Scientific.fromFloatDigits :: Double -> Scientific)) injectWith  instance Inject () where     injectWith _ = InputType {..}
src/Dhall/Binary.hs view
@@ -24,7 +24,8 @@ import Control.Applicative (empty) import Control.Exception (Exception) import Dhall.Core-    ( Chunks(..)+    ( Binding(..)+    , Chunks(..)     , Const(..)     , Directory(..)     , Expr(..)@@ -38,26 +39,28 @@     , URL(..)     , Var(..)     )+import Data.Foldable (toList)+import Data.List.NonEmpty (NonEmpty(..)) import Data.Monoid ((<>)) import Data.Text (Text) import Options.Applicative (Parser) import Prelude hiding (exponent)+import GHC.Float (double2Float, float2Double)+import Codec.CBOR.Magic (floatToWord16, wordToFloat16) -import qualified Data.Foldable-import qualified Data.Scientific import qualified Data.Sequence-import qualified Data.Set import qualified Data.Text import qualified Dhall.Map+import qualified Dhall.Set import qualified Options.Applicative  -- | Supported version strings data StandardVersion-    = V_3_0_0-    -- ^ Version "3.0.0"+    = V_4_0_0+    -- ^ Version "4.0.0"  defaultStandardVersion :: StandardVersion-defaultStandardVersion = V_3_0_0+defaultStandardVersion = V_4_0_0  parseStandardVersion :: Parser StandardVersion parseStandardVersion =@@ -71,7 +74,7 @@     readVersion = do         string <- Options.Applicative.str         case string :: Text of-            "3.0.0" -> return V_3_0_0+            "4.0.0" -> return V_4_0_0             _       -> fail "Unsupported version"  {-| Convert a function applied to multiple arguments to the base function and@@ -297,7 +300,7 @@     TList ([ TInt 10, t₁ ] ++ xs₁)   where     t₁  = encode t₀-    xs₁ = map TString (Data.Foldable.toList xs₀)+    xs₁ = map TString (Dhall.Set.toList xs₀) encode (Union xTs₀) =     TList [ TInt 11, TMap xTs₁ ]   where@@ -332,14 +335,17 @@     TList [ TInt 15, TInteger (fromIntegral n) ] encode (IntegerLit n) =     TList [ TInt 16, TInteger n ]-encode (DoubleLit n) =-    TList [ TInt 17, TTagged 4 (TList [ TInt exponent, TInteger mantissa ]) ]+encode (DoubleLit n64)+    -- cborg always encodes NaN as "7e00"+    | isNaN n64 = THalf n32+    | useHalf   = THalf n32+    | useFloat  = TFloat n32+    | otherwise = TDouble n64   where-    normalized = Data.Scientific.normalize n--    exponent = Data.Scientific.base10Exponent normalized--    mantissa = Data.Scientific.coefficient normalized+    n32      = double2Float n64+    n16      = floatToWord16 n32+    useFloat = n64 == float2Double n32+    useHalf  = n64 == (float2Double . wordToFloat16 . fromIntegral) n16 encode (TextLit (Chunks xys₀ z₀)) =     TList ([ TInt 18 ] ++ xys₁ ++ [ z₁ ])   where@@ -352,17 +358,21 @@     z₁ = TString z₀ encode (Embed x) =     importToTerm x-encode (Let x Nothing a₀ b₀) =-    TList [ TInt 25, TString x, a₁, b₁ ]+encode (Let as₀ b₀) =+    TList ([ TInt 25 ] ++ as₁ ++ [ b₁ ])   where-    a₁ = encode a₀+    as₁ = do+        Binding x mA₀ a₀ <- toList as₀++        let mA₁ = case mA₀ of+                Nothing  -> TNull+                Just _A₀ -> encode _A₀++        let a₁ = encode a₀++        [ TString x, mA₁, a₁ ]+     b₁ = encode b₀-encode (Let x (Just _A₀) a₀ b₀) =-    TList [ TInt 25, TString x, _A₁, a₁, b₁ ]-  where-    a₁  = encode a₀-    _A₁ = encode _A₀-    b₁  = encode b₀ encode (Annot t₀ _T₀) =     TList [ TInt 26, t₁, _T₁ ]   where@@ -585,7 +595,7 @@      xs₀ <- traverse process xs₁ -    return (Project t₀ (Data.Set.fromList xs₀))+    return (Project t₀ (Dhall.Set.fromList xs₀)) decode (TList [ TInt 11, TMap xTs₁ ]) = do     let process (TString x, _T₁) = do             _T₀ <- decode _T₁@@ -630,10 +640,12 @@     return (IntegerLit (fromIntegral n)) decode (TList [ TInt 16, TInteger n ]) = do     return (IntegerLit n)-decode (TList [ TInt 17, TTagged 4 (TList [ TInt exponent, TInteger mantissa ]) ]) = do-    return (DoubleLit (Data.Scientific.scientific mantissa exponent))-decode (TList [ TInt 17, TTagged 4 (TList [ TInt exponent, TInt mantissa ]) ]) = do-    return (DoubleLit (Data.Scientific.scientific (fromIntegral mantissa) exponent))+decode (THalf n) = do+    return (DoubleLit (float2Double n))+decode (TFloat n) = do+    return (DoubleLit (float2Double n))+decode (TDouble n) = do+    return (DoubleLit n) decode (TList (TInt 18 : xs)) = do     let process (TString x : y₁ : zs) = do             y₀ <- decode y₁@@ -722,15 +734,29 @@     let importHashed = ImportHashed {..}     let importMode   = Code     return (Embed (Import {..}))-decode (TList [ TInt 25, TString x, a₁, b₁ ]) = do-    a₀ <- decode a₁-    b₀ <- decode b₁-    return (Let x Nothing a₀ b₀)-decode (TList [ TInt 25, TString x, _A₁, a₁, b₁ ]) = do-    _A₀ <- decode _A₁-    a₀  <- decode a₁-    b₀  <- decode b₁-    return (Let x (Just _A₀) a₀ b₀)+decode (TList (TInt 25 : xs)) = do+    let process (TString x : _A₁ : a₁ : ls₁) = do+            mA₀ <- case _A₁ of+                TNull -> return Nothing+                _     -> fmap Just (decode _A₁)++            a₀  <- decode a₁++            let binding = Binding x mA₀ a₀++            case ls₁ of+                [ b₁ ] -> do+                    b₀ <- decode b₁++                    return (Let (binding :| []) b₀)+                _ -> do+                    Let (l₀ :| ls₀) b₀ <- process ls₁++                    return (Let (binding :| (l₀ : ls₀)) b₀)+        process _ = do+            empty++    process xs decode (TList [ TInt 26, t₁, _T₁ ]) = do     t₀  <- decode t₁     _T₀ <- decode _T₁@@ -752,7 +778,7 @@             fail ("Cannot decode the version from this decoded CBOR expression: " <> show term)      case version of-        "3.0.0" -> do+        "4.0.0" -> do             return ()         _ -> do             fail ("This decoded version is not supported: " <> Data.Text.unpack version)@@ -765,8 +791,8 @@  -- | Encode a Dhall expression using the specified `Version` encodeWithVersion :: StandardVersion -> Expr s Import -> Term-encodeWithVersion V_3_0_0 expression =-    TList [ TString "3.0.0", encode expression ]+encodeWithVersion V_4_0_0 expression =+    TList [ TString "4.0.0", encode expression ]  data DecodingFailure     = CannotDecodeVersionString Term
src/Dhall/Core.hs view
@@ -29,6 +29,7 @@     , Path     , Scheme(..)     , Var(..)+    , Binding(..)     , Chunks(..)     , Expr(..) @@ -36,7 +37,9 @@     , alphaNormalize     , normalize     , normalizeWith+    , normalizeWithM     , Normalizer+    , NormalizerM     , ReifiedNormalizer (..)     , judgmentallyEqual     , subst@@ -53,6 +56,8 @@     , internalError     , reservedIdentifiers     , escapeText+    , subExpressions+    , pathCharacter     ) where  #if MIN_VERSION_base(4,8,0)@@ -64,16 +69,17 @@ import Data.Bifunctor (Bifunctor(..)) import Data.Data (Data) import Data.Foldable+import Data.Functor.Identity (Identity(..)) import Data.HashSet (HashSet)+import Data.List.NonEmpty (NonEmpty(..)) import Data.String (IsString(..))-import Data.Scientific (Scientific) import Data.Semigroup (Semigroup(..)) import Data.Sequence (Seq, ViewL(..), ViewR(..))-import Data.Set (Set) import Data.Text (Text)-import Data.Text.Prettyprint.Doc (Pretty)+import Data.Text.Prettyprint.Doc (Doc, Pretty) import Data.Traversable import Dhall.Map (Map)+import Dhall.Set (Set) import {-# SOURCE #-} Dhall.Pretty.Internal import GHC.Generics (Generic) import Numeric.Natural (Natural)@@ -83,10 +89,10 @@ import qualified Crypto.Hash import qualified Data.HashSet import qualified Data.Sequence-import qualified Data.Set import qualified Data.Text import qualified Data.Text.Prettyprint.Doc  as Pretty import qualified Dhall.Map+import qualified Dhall.Set  {-| Constants for a pure type system @@ -98,13 +104,11 @@     ... and the valid rule pairs are:  > ⊦ Type ↝ Type : Type  -- Functions from terms to terms (ordinary functions)-> ⊦ Kind ↝ Type : Type  -- Functions from types to terms (polymorphic functions)-> ⊦ Kind ↝ Kind : Kind  -- Functions from types to types (type constructors)-> ⊦ Sort ↝ Type : Type  -- Functions from kinds to terms (kind-polymorphic functions)-> ⊦ Sort ↝ Kind : Kind  -- Functions from kinds to types (polymorphic type constructors)-> ⊦ Sort ↝ Sort : Sort  -- Functions from kinds to kinds (kind constructors)--    These are the same rule pairs as System Fω+> ⊦ Kind ↝ Type : Type  -- Functions from types to terms (type-polymorphic functions)+> ⊦ Sort ↝ Type : Type  -- Functions from kinds to terms+> ⊦ Kind ↝ Kind : Kind  -- Functions from types to types (type-level functions)+> ⊦ Sort ↝ Kind : Sort  -- Functions from kinds to types (kind-polymorphic functions)+> ⊦ Sort ↝ Sort : Sort  -- Functions from kinds to kinds (kind-level functions)      Note that Dhall does not support functions from terms to types and therefore     Dhall is not a dependently typed language@@ -128,10 +132,7 @@         Directory (components₁ <> components₀)  instance Pretty Directory where-    pretty (Directory {..}) =-        foldMap prettyComponent (reverse components)-      where-        prettyComponent text = "/" <> Pretty.pretty text+    pretty (Directory {..}) = foldMap prettyPathComponent (reverse components)  {-| A `File` is a `directory` followed by one additional path component     representing the `file` name@@ -142,7 +143,9 @@     } deriving (Eq, Generic, Ord, Show)  instance Pretty File where-    pretty (File {..}) = Pretty.pretty directory <> "/" <> Pretty.pretty file+    pretty (File {..}) =+            Pretty.pretty directory+        <>  prettyPathComponent file  instance Semigroup File where     File directory₀ _ <> File directory₁ file =@@ -329,9 +332,9 @@     | Pi  Text (Expr s a) (Expr s a)     -- | > App f a                                  ~  f a     | App (Expr s a) (Expr s a)-    -- | > Let x Nothing  r e                       ~  let x     = r in e-    --   > Let x (Just t) r e                       ~  let x : t = r in e-    | Let Text (Maybe (Expr s a)) (Expr s a) (Expr s a)+    -- | > Let [Binding x Nothing  r] e             ~  let x     = r in e+    --   > Let [Binding x (Just t) r] e             ~  let x : t = r in e+    | Let (NonEmpty (Binding s a)) (Expr s a)     -- | > Annot x t                                ~  x : t     | Annot (Expr s a) (Expr s a)     -- | > Bool                                     ~  Bool@@ -381,7 +384,7 @@     -- | > Double                                   ~  Double     | Double     -- | > DoubleLit n                              ~  n-    | DoubleLit Scientific+    | DoubleLit Double     -- | > DoubleShow                               ~  Double/show     | DoubleShow     -- | > Text                                     ~  Text@@ -436,7 +439,7 @@     | Combine (Expr s a) (Expr s a)     -- | > CombineTypes x y                         ~  x ⩓ y     | CombineTypes (Expr s a) (Expr s a)-    -- | > CombineRight x y                         ~  x ⫽ y+    -- | > Prefer x y                               ~  x ⫽ y     | Prefer (Expr s a) (Expr s a)     -- | > Merge x y (Just t )                      ~  merge x y : t     --   > Merge x y  Nothing                       ~  merge x y@@ -465,7 +468,7 @@   fmap f (Lam v e1 e2) = Lam v (fmap f e1) (fmap f e2)   fmap f (Pi v e1 e2) = Pi v (fmap f e1) (fmap f e2)   fmap f (App e1 e2) = App (fmap f e1) (fmap f e2)-  fmap f (Let v maybeE e1 e2) = Let v (fmap (fmap f) maybeE) (fmap f e1) (fmap f e2)+  fmap f (Let as b) = Let (fmap (fmap f) as) (fmap f b)   fmap f (Annot e1 e2) = Annot (fmap f e1) (fmap f e2)   fmap _ Bool = Bool   fmap _ (BoolLit b) = BoolLit b@@ -540,7 +543,9 @@     Lam a b c            >>= k = Lam a (b >>= k) (c >>= k)     Pi  a b c            >>= k = Pi a (b >>= k) (c >>= k)     App a b              >>= k = App (a >>= k) (b >>= k)-    Let a b c d          >>= k = Let a (fmap (>>= k) b) (c >>= k) (d >>= k)+    Let as b             >>= k = Let (fmap f as) (b >>= k)+      where+        f (Binding c d e) = Binding c (fmap (>>= k) d) (e >>= k)     Annot a b            >>= k = Annot (a >>= k) (b >>= k)     Bool                 >>= _ = Bool     BoolLit a            >>= _ = BoolLit a@@ -607,7 +612,7 @@     first k (Lam a b c           ) = Lam a (first k b) (first k c)     first k (Pi a b c            ) = Pi a (first k b) (first k c)     first k (App a b             ) = App (first k a) (first k b)-    first k (Let a b c d         ) = Let a (fmap (first k) b) (first k c) (first k d)+    first k (Let as b            ) = Let (fmap (first k) as) (first k b)     first k (Annot a b           ) = Annot (first k a) (first k b)     first _  Bool                  = Bool     first _ (BoolLit a           ) = BoolLit a@@ -673,6 +678,17 @@ instance IsString (Expr s a) where     fromString str = Var (fromString str) +data Binding s a = Binding+    { variable   :: Text+    , annotation :: Maybe (Expr s a)+    , value      :: Expr s a+    } deriving (Functor, Foldable, Generic, Traversable, Show, Eq, Data)++instance Bifunctor Binding where+    first k (Binding a b c) = Binding a (fmap (first k) b) (first k c)++    second = fmap+ -- | The body of an interpolated @Text@ literal data Chunks s a = Chunks [(Text, Expr s a)] Text     deriving (Functor, Foldable, Generic, Traversable, Show, Eq, Data)@@ -790,14 +806,24 @@   where     f' = shift d v f     a' = shift d v a-shift d (V x n) (Let f mt r e) = Let f mt' r' e'+shift d (V x₀ n₀) (Let (Binding x₁ mA₀ a₀ :| []) b₀) =+    Let (Binding x₁ mA₁ a₁ :| []) b₁   where-    e' = shift d (V x n') e-      where-        n' = if x == f then n + 1 else n+    n₁ = if x₀ == x₁ then n₀ + 1 else n₀ -    mt' = fmap (shift d (V x n)) mt-    r'  =       shift d (V x n)  r+    mA₁ = fmap (shift d (V x₀ n₀)) mA₀+    a₁  =       shift d (V x₀ n₀)   a₀++    b₁  =       shift d (V x₀ n₁)   b₀+shift d (V x₀ n₀) (Let (Binding x₁ mA₀ a₀ :| (l₀ : ls₀)) b₀) =+    Let (Binding x₁ mA₁ a₁ :| (l₁ : ls₁)) b₁+  where+    n₁ = if x₀ == x₁ then n₀ + 1 else n₀++    mA₁ = fmap (shift d (V x₀ n₀)) mA₀+    a₁  =       shift d (V x₀ n₀)   a₀++    Let (l₁ :| ls₁) b₁ = shift d (V x₀ n₁) (Let (l₀ :| ls₀) b₀) shift d v (Annot a b) = Annot a' b'   where     a' = shift d v a@@ -955,14 +981,28 @@     f' = subst v e f     a' = subst v e a subst v e (Var v') = if v == v' then e else Var v'-subst (V x n) e (Let f mt r b) = Let f mt' r' b'+subst (V x₀ n₀) e₀ (Let (Binding x₁ mA₀ a₀ :| []) b₀) =+    Let (Binding x₁ mA₁ a₁ :| []) b₁   where-    b' = subst (V x n') (shift 1 (V f 0) e) b-      where-        n' = if x == f then n + 1 else n+    n₁ = if x₀ == x₁ then n₀ + 1 else n₀ -    mt' = fmap (subst (V x n) e) mt-    r'  =       subst (V x n) e  r+    e₁ = shift 1 (V x₁ 0) e₀++    mA₁ = fmap (subst (V x₀ n₀) e₀) mA₀+    a₁  =       subst (V x₀ n₀) e₀   a₀++    b₁  =       subst (V x₀ n₁) e₁   b₀+subst (V x₀ n₀) e₀ (Let (Binding x₁ mA₀ a₀ :| (l₀ : ls₀)) b₀) =+    Let (Binding x₁ mA₁ a₁ :| (l₁ : ls₁)) b₁+  where+    n₁ = if x₀ == x₁ then n₀ + 1 else n₀++    e₁ = shift 1 (V x₁ 0) e₀++    mA₁ = fmap (subst (V x₀ n₀) e₀) mA₀+    a₁  =       subst (V x₀ n₀) e₀   a₀++    Let (l₁ :| ls₁) b₁ = subst (V x₀ n₁) e₁ (Let (l₀ :| ls₀) b₀) subst x e (Annot a b) = Annot a' b'   where     a' = subst x e a@@ -1141,22 +1181,41 @@     f₁ = alphaNormalize f₀      a₁ = alphaNormalize a₀-alphaNormalize (Let "_" mA₀ a₀ b₀) =-    Let "_" mA₁ a₁ b₁+alphaNormalize (Let (Binding "_" mA₀ a₀ :| []) b₀) =+    Let (Binding "_" mA₁ a₁ :| []) b₁   where     mA₁ = fmap alphaNormalize mA₀     a₁  =      alphaNormalize a₀+     b₁  =      alphaNormalize b₀-alphaNormalize (Let x mA₀ a₀ b₀) =-    Let "_" mA₁ a₁ b₄+alphaNormalize (Let (Binding "_" mA₀ a₀ :| (l₀ : ls₀)) b₀) =+    Let (Binding "_" mA₁ a₁ :| (l₁ : ls₁)) b₁   where     mA₁ = fmap alphaNormalize mA₀+    a₁  =      alphaNormalize  a₀++    Let (l₁ :| ls₁) b₁ = alphaNormalize (Let (l₀ :| ls₀) b₀)+alphaNormalize (Let (Binding x mA₀ a₀ :| []) b₀) =+    Let (Binding "_" mA₁ a₁ :| []) b₄+  where+    mA₁ = fmap alphaNormalize mA₀     a₁  =      alphaNormalize a₀      b₁ = shift 1 (V "_" 0) b₀     b₂ = subst (V x 0) (Var (V "_" 0)) b₁     b₃ = shift (-1) (V x 0) b₂     b₄ = alphaNormalize b₃+alphaNormalize (Let (Binding x mA₀ a₀ :| (l₀ : ls₀)) b₀) =+    Let (Binding "_" mA₁ a₁ :| (l₁ : ls₁)) b₄+  where+    mA₁ = fmap alphaNormalize mA₀+    a₁  =      alphaNormalize a₀++    b₁ = shift 1 (V "_" 0) b₀+    b₂ = subst (V x 0) (Var (V "_" 0)) b₁+    b₃ = shift (-1) (V x 0) b₂++    Let (l₁ :| ls₁) b₄ = alphaNormalize (Let (l₀ :| ls₀) b₃) alphaNormalize (Annot t₀ _T₀) =     Annot t₁ _T₁   where@@ -1384,7 +1443,7 @@     leave ill-typed sub-expressions unevaluated. -} normalize :: Eq a => Expr s a -> Expr t a-normalize = normalizeWith (const Nothing)+normalize = normalizeWith (const (pure Nothing))  {-| This function is used to determine whether folds like @Natural/fold@ or     @List/fold@ should be lazy or strict in their accumulator based on the type@@ -1416,7 +1475,9 @@ denote (Lam a b c           ) = Lam a (denote b) (denote c) denote (Pi a b c            ) = Pi a (denote b) (denote c) denote (App a b             ) = App (denote a) (denote b)-denote (Let a b c d         ) = Let a (fmap denote b) (denote c) (denote d)+denote (Let as b            ) = Let (fmap f as) (denote b)+  where+    f (Binding c d e) = Binding c (fmap denote d) (denote e) denote (Annot a b           ) = Annot (denote a) (denote b) denote  Bool                  = Bool denote (BoolLit a           ) = BoolLit a@@ -1492,149 +1553,168 @@  -} normalizeWith :: Eq a => Normalizer a -> Expr s a -> Expr t a-normalizeWith ctx e0 = loop (denote e0)+normalizeWith ctx = runIdentity . normalizeWithM ctx++normalizeWithM :: (Eq a, Monad m) => NormalizerM m a -> Expr s a -> m (Expr t a)+normalizeWithM ctx e0 = loop (denote e0)  where  loop e =  case e of-    Const k -> Const k-    Var v -> Var v-    Lam x _A b -> Lam x _A' b'+    Const k -> pure (Const k)+    Var v -> pure (Var v)+    Lam x _A b -> Lam x <$> _A' <*> b'       where         _A' = loop _A         b'  = loop b-    Pi  x _A _B -> Pi  x _A' _B'+    Pi x _A _B -> Pi x <$> _A' <*> _B'       where         _A' = loop _A         _B' = loop _B-    App f a -> case loop f of-        Lam x _A b -> loop b''  -- Beta reduce-          where-            a'  = shift   1  (V x 0) a-            b'  = subst (V x 0) a' b-            b'' = shift (-1) (V x 0) b'-        f' -> case App f' a' of-            -- build/fold fusion for `List`-            App (App ListBuild _) (App (App ListFold _) e') -> loop e'+    App f a -> do+      res <- ctx (App f a)+      case res of+          Just e1 -> loop e1+          Nothing -> do+              f' <- loop f+              case f' of+                Lam x _A b -> loop b''+                  where+                    a'  = shift   1  (V x 0) a+                    b'  = subst (V x 0) a' b+                    b'' = shift (-1) (V x 0) b'+                _ -> do+                  a' <- loop a+                  case App f' a' of+                    -- build/fold fusion for `List`+                    App (App ListBuild _) (App (App ListFold _) e') -> loop e' -            -- build/fold fusion for `Natural`-            App NaturalBuild (App NaturalFold e') -> loop e'+                    -- build/fold fusion for `Natural`+                    App NaturalBuild (App NaturalFold e') -> loop e' -            -- build/fold fusion for `Optional`-            App (App OptionalBuild _) (App (App OptionalFold _) e') -> loop e'+                    -- build/fold fusion for `Optional`+                    App (App OptionalBuild _) (App (App OptionalFold _) e') -> loop e' -            App (App (App (App NaturalFold (NaturalLit n0)) t) succ') zero ->-                if boundedType (loop t) then strict else lazy-              where-                strict =       strictLoop n0-                lazy   = loop (  lazyLoop n0)+                    App (App (App (App NaturalFold (NaturalLit n0)) t) succ') zero -> do+                      t' <- loop t+                      if boundedType t' then strict else lazy+                      where+                        strict =       strictLoop n0+                        lazy   = loop (  lazyLoop n0) -                strictLoop !0 = loop zero-                strictLoop !n = loop (App succ' (strictLoop (n - 1)))+                        strictLoop !0 = loop zero+                        strictLoop !n = App succ' <$> strictLoop (n - 1) >>= loop -                lazyLoop !0 = zero-                lazyLoop !n = App succ' (lazyLoop (n - 1))-            App NaturalBuild g -> loop (App (App (App g Natural) succ) zero)-              where-                succ = Lam "x" Natural (NaturalPlus "x" (NaturalLit 1))+                        lazyLoop !0 = zero+                        lazyLoop !n = App succ' (lazyLoop (n - 1))+                    App NaturalBuild g -> loop (App (App (App g Natural) succ) zero)+                      where+                        succ = Lam "x" Natural (NaturalPlus "x" (NaturalLit 1)) -                zero = NaturalLit 0-            App NaturalIsZero (NaturalLit n) -> BoolLit (n == 0)-            App NaturalEven (NaturalLit n) -> BoolLit (even n)-            App NaturalOdd (NaturalLit n) -> BoolLit (odd n)-            App NaturalToInteger (NaturalLit n) -> IntegerLit (toInteger n)-            App NaturalShow (NaturalLit n) ->-                TextLit (Chunks [] (Data.Text.pack (show n)))-            App IntegerShow (IntegerLit n)-                | 0 <= n    -> TextLit (Chunks [] ("+" <> Data.Text.pack (show n)))-                | otherwise -> TextLit (Chunks [] (Data.Text.pack (show n)))-            App IntegerToDouble (IntegerLit n) -> DoubleLit (fromInteger n)-            App DoubleShow (DoubleLit n) ->-                TextLit (Chunks [] (Data.Text.pack (show n)))-            App (App OptionalBuild _A₀) g ->-                loop (App (App (App g optional) just) nothing)-              where-                optional = App Optional _A₀+                        zero = NaturalLit 0+                    App NaturalIsZero (NaturalLit n) -> pure (BoolLit (n == 0))+                    App NaturalEven (NaturalLit n) -> pure (BoolLit (even n))+                    App NaturalOdd (NaturalLit n) -> pure (BoolLit (odd n))+                    App NaturalToInteger (NaturalLit n) -> pure (IntegerLit (toInteger n))+                    App NaturalShow (NaturalLit n) ->+                        pure (TextLit (Chunks [] (Data.Text.pack (show n))))+                    App IntegerShow (IntegerLit n)+                        | 0 <= n    -> pure (TextLit (Chunks [] ("+" <> Data.Text.pack (show n))))+                        | otherwise -> pure (TextLit (Chunks [] (Data.Text.pack (show n))))+                    -- `(read . show)` is used instead of `fromInteger` because `read` uses the correct rounding rule+                    App IntegerToDouble (IntegerLit n) -> pure (DoubleLit ((read . show) n))+                    App DoubleShow (DoubleLit n) ->+                        pure (TextLit (Chunks [] (Data.Text.pack (show n))))+                    App (App OptionalBuild _A₀) g ->+                        loop (App (App (App g optional) just) nothing)+                      where+                        optional = App Optional _A₀ -                just = Lam "a" _A₀ (Some "a")+                        just = Lam "a" _A₀ (Some "a") -                nothing = App None _A₀-            App (App ListBuild _A₀) g -> loop (App (App (App g list) cons) nil)-              where-                _A₁ = shift 1 "a" _A₀+                        nothing = App None _A₀+                    App (App ListBuild _A₀) g -> loop (App (App (App g list) cons) nil)+                      where+                        _A₁ = shift 1 "a" _A₀ -                list = App List _A₀+                        list = App List _A₀ -                cons =-                    Lam "a" _A₀-                        (Lam "as"-                            (App List _A₁)-                            (ListAppend (ListLit Nothing (pure "a")) "as")-                        )+                        cons =+                            Lam "a" _A₀+                                (Lam "as"+                                    (App List _A₁)+                                    (ListAppend (ListLit Nothing (pure "a")) "as")+                                ) -                nil = ListLit (Just _A₀) empty-            App (App (App (App (App ListFold _) (ListLit _ xs)) t) cons) nil ->-                if boundedType (loop t) then strict else lazy-              where-                strict =       foldr strictCons strictNil xs-                lazy   = loop (foldr   lazyCons   lazyNil xs)+                        nil = ListLit (Just _A₀) empty+                    App (App (App (App (App ListFold _) (ListLit _ xs)) t) cons) nil -> do+                      t' <- loop t+                      if boundedType t' then strict else lazy+                      where+                        strict =       foldr strictCons strictNil xs+                        lazy   = loop (foldr   lazyCons   lazyNil xs) -                strictNil = loop nil-                lazyNil   =      nil+                        strictNil = loop nil+                        lazyNil   =      nil -                strictCons y ys = loop (App (App cons y) ys)-                lazyCons   y ys =       App (App cons y) ys-            App (App ListLength _) (ListLit _ ys) ->-                NaturalLit (fromIntegral (Data.Sequence.length ys))-            App (App ListHead t) (ListLit _ ys) -> loop o-              where-                o = case Data.Sequence.viewl ys of-                        y :< _ -> Some y-                        _      -> App None t-            App (App ListLast t) (ListLit _ ys) -> loop o-              where-                o = case Data.Sequence.viewr ys of-                        _ :> y -> Some y-                        _      -> App None t-            App (App ListIndexed _A₀) (ListLit _A₁ as₀) -> loop (ListLit t as₁)-              where-                as₁ = Data.Sequence.mapWithIndex adapt as₀+                        strictCons y ys = do+                          App (App cons y) <$> ys >>= loop+                        lazyCons   y ys =       App (App cons y) ys+                    App (App ListLength _) (ListLit _ ys) ->+                        pure (NaturalLit (fromIntegral (Data.Sequence.length ys)))+                    App (App ListHead t) (ListLit _ ys) -> loop o+                      where+                        o = case Data.Sequence.viewl ys of+                                y :< _ -> Some y+                                _      -> App None t+                    App (App ListLast t) (ListLit _ ys) -> loop o+                      where+                        o = case Data.Sequence.viewr ys of+                                _ :> y -> Some y+                                _      -> App None t+                    App (App ListIndexed _A₀) (ListLit _A₁ as₀) -> loop (ListLit t as₁)+                      where+                        as₁ = Data.Sequence.mapWithIndex adapt as₀ -                _A₂ = Record (Dhall.Map.fromList kts)-                  where-                    kts = [ ("index", Natural)-                          , ("value", _A₀)-                          ]+                        _A₂ = Record (Dhall.Map.fromList kts)+                          where+                            kts = [ ("index", Natural)+                                  , ("value", _A₀)+                                  ] -                t | null as₀  = Just _A₂-                  | otherwise = Nothing+                        t | null as₀  = Just _A₂+                          | otherwise = Nothing -                adapt n a_ =-                    RecordLit (Dhall.Map.fromList kvs)-                  where-                    kvs = [ ("index", NaturalLit (fromIntegral n))-                          , ("value", a_)-                          ]-            App (App ListReverse t) (ListLit _ xs) ->-                loop (ListLit m (Data.Sequence.reverse xs))-              where-                m = if Data.Sequence.null xs then Just t else Nothing-            App (App (App (App (App OptionalFold _) (App None _)) _) _) nothing ->-                loop nothing-            App (App (App (App (App OptionalFold _) (Some x)) _) just) _ ->-                loop (App just x)-            _ ->  case ctx (App f' a') of-                    Nothing -> App f' a'-                    Just app' -> loop app'-          where-            a' = loop a-    Let f _ r b -> loop b''+                        adapt n a_ =+                            RecordLit (Dhall.Map.fromList kvs)+                          where+                            kvs = [ ("index", NaturalLit (fromIntegral n))+                                  , ("value", a_)+                                  ]+                    App (App ListReverse t) (ListLit _ xs) ->+                        loop (ListLit m (Data.Sequence.reverse xs))+                      where+                        m = if Data.Sequence.null xs then Just t else Nothing+                    App (App (App (App (App OptionalFold _) (App None _)) _) _) nothing ->+                        loop nothing+                    App (App (App (App (App OptionalFold _) (Some x)) _) just) _ ->+                        loop (App just x)+                    _ -> do+                        res2 <- ctx (App f' a')+                        case res2 of+                            Nothing -> pure (App f' a')+                            Just app' -> loop app'+    Let (Binding x _ a₀ :| ls₀) b₀ -> loop b₂       where-        r'  = shift   1  (V f 0) r-        b'  = subst (V f 0) r' b-        b'' = shift (-1) (V f 0) b'+        rest = case ls₀ of+            []       -> b₀+            l₁ : ls₁ -> Let (l₁ :| ls₁) b₀++        a₁ = shift 1 (V x 0) a₀+        b₁ = subst (V x 0) a₁ rest+        b₂ = shift (-1) (V x 0) b₁     Annot x _ -> loop x-    Bool -> Bool-    BoolLit b -> BoolLit b-    BoolAnd x y -> decide (loop x) (loop y)+    Bool -> pure Bool+    BoolLit b -> pure (BoolLit b)+    BoolAnd x y -> decide <$> loop x <*> loop y       where         decide (BoolLit True )  r              = r         decide (BoolLit False)  _              = BoolLit False@@ -1643,7 +1723,7 @@         decide  l               r             | judgmentallyEqual l r = l             | otherwise             = BoolAnd l r-    BoolOr x y -> decide (loop x) (loop y)+    BoolOr x y -> decide <$> loop x <*> loop y       where         decide (BoolLit False)  r              = r         decide (BoolLit True )  _              = BoolLit True@@ -1652,21 +1732,21 @@         decide  l               r             | judgmentallyEqual l r = l             | otherwise             = BoolOr l r-    BoolEQ x y -> decide (loop x) (loop y)+    BoolEQ x y -> decide <$> loop x <*> loop y       where         decide (BoolLit True )  r              = r         decide  l              (BoolLit True ) = l         decide  l               r             | judgmentallyEqual l r = BoolLit True             | otherwise             = BoolEQ l r-    BoolNE x y -> decide (loop x) (loop y)+    BoolNE x y -> decide <$> loop x <*> loop y       where         decide (BoolLit False)  r              = r         decide  l              (BoolLit False) = l         decide  l               r             | judgmentallyEqual l r = BoolLit False             | otherwise             = BoolNE l r-    BoolIf bool true false -> decide (loop bool) (loop true) (loop false)+    BoolIf bool true false -> decide <$> loop bool <*> loop true <*> loop false       where         decide (BoolLit True )  l              _              = l         decide (BoolLit False)  _              r              = r@@ -1674,22 +1754,22 @@         decide  b               l              r             | judgmentallyEqual l r = l             | otherwise             = BoolIf b l r-    Natural -> Natural-    NaturalLit n -> NaturalLit n-    NaturalFold -> NaturalFold-    NaturalBuild -> NaturalBuild-    NaturalIsZero -> NaturalIsZero-    NaturalEven -> NaturalEven-    NaturalOdd -> NaturalOdd-    NaturalToInteger -> NaturalToInteger-    NaturalShow -> NaturalShow-    NaturalPlus x y -> decide (loop x) (loop y)+    Natural -> pure Natural+    NaturalLit n -> pure (NaturalLit n)+    NaturalFold -> pure NaturalFold+    NaturalBuild -> pure NaturalBuild+    NaturalIsZero -> pure NaturalIsZero+    NaturalEven -> pure NaturalEven+    NaturalOdd -> pure NaturalOdd+    NaturalToInteger -> pure NaturalToInteger+    NaturalShow -> pure NaturalShow+    NaturalPlus x y -> decide <$> loop x <*> loop y       where         decide (NaturalLit 0)  r             = r         decide  l             (NaturalLit 0) = l         decide (NaturalLit m) (NaturalLit n) = NaturalLit (m + n)         decide  l              r             = NaturalPlus l r-    NaturalTimes x y -> decide (loop x) (loop y)+    NaturalTimes x y -> decide <$> loop x <*> loop y       where         decide (NaturalLit 1)  r             = r         decide  l             (NaturalLit 1) = l@@ -1697,25 +1777,29 @@         decide  _             (NaturalLit 0) = NaturalLit 0         decide (NaturalLit m) (NaturalLit n) = NaturalLit (m * n)         decide  l              r             = NaturalTimes l r-    Integer -> Integer-    IntegerLit n -> IntegerLit n-    IntegerShow -> IntegerShow-    IntegerToDouble -> IntegerToDouble-    Double -> Double-    DoubleLit n -> DoubleLit n-    DoubleShow -> DoubleShow-    Text -> Text-    TextLit (Chunks xys z) ->-        case mconcat chunks of-            Chunks [("", x)] "" -> x-            c                   -> TextLit c+    Integer -> pure Integer+    IntegerLit n -> pure (IntegerLit n)+    IntegerShow -> pure IntegerShow+    IntegerToDouble -> pure IntegerToDouble+    Double -> pure Double+    DoubleLit n -> pure (DoubleLit n)+    DoubleShow -> pure DoubleShow+    Text -> pure Text+    TextLit (Chunks xys z) -> do+        chunks' <- mconcat <$> chunks+        case chunks' of+            Chunks [("", x)] "" -> pure x+            c                   -> pure (TextLit c)       where-        chunks = concatMap process xys ++ [Chunks [] z]+        chunks =+          ((++ [Chunks [] z]) . concat) <$> traverse process xys -        process (x, y) = case loop y of-            TextLit c -> [Chunks [] x, c]-            y'        -> [Chunks [(x, y')] mempty]-    TextAppend x y -> decide (loop x) (loop y)+        process (x, y) = do+          y' <- loop y+          case y' of+            TextLit c -> pure [Chunks [] x, c]+            _         -> pure [Chunks [(x, y')] mempty]+    TextAppend x y -> decide <$> loop x <*> loop y       where         isEmpty (Chunks [] "") = True         isEmpty  _             = False@@ -1724,49 +1808,49 @@         decide  l          (TextLit n) | isEmpty n = l         decide (TextLit m) (TextLit n)             = TextLit (m <> n)         decide  l           r                      = TextAppend l r-    List -> List+    List -> pure List     ListLit t es-        | Data.Sequence.null es -> ListLit t' es'-        | otherwise             -> ListLit Nothing es'+        | Data.Sequence.null es -> ListLit <$> t' <*> es'+        | otherwise             -> ListLit Nothing <$> es'       where-        t'  = fmap loop t-        es' = fmap loop es-    ListAppend x y -> decide (loop x) (loop y)+        t'  = traverse loop t+        es' = traverse loop es+    ListAppend x y -> decide <$> loop x <*> loop y       where         decide (ListLit _ m)  r            | Data.Sequence.null m = r         decide  l            (ListLit _ n) | Data.Sequence.null n = l         decide (ListLit t m) (ListLit _ n)                        = ListLit t (m <> n)         decide  l             r                                   = ListAppend l r-    ListBuild -> ListBuild-    ListFold -> ListFold-    ListLength -> ListLength-    ListHead -> ListHead-    ListLast -> ListLast-    ListIndexed -> ListIndexed-    ListReverse -> ListReverse-    Optional -> Optional+    ListBuild -> pure ListBuild+    ListFold -> pure ListFold+    ListLength -> pure ListLength+    ListHead -> pure ListHead+    ListLast -> pure ListLast+    ListIndexed -> pure ListIndexed+    ListReverse -> pure ListReverse+    Optional -> pure Optional     OptionalLit _A Nothing -> loop (App None _A)     OptionalLit _ (Just a) -> loop (Some a)-    Some a -> Some a'+    Some a -> Some <$> a'       where         a' = loop a-    None -> None-    OptionalFold -> OptionalFold-    OptionalBuild -> OptionalBuild-    Record kts -> Record (Dhall.Map.sort kts')+    None -> pure None+    OptionalFold -> pure OptionalFold+    OptionalBuild -> pure OptionalBuild+    Record kts -> Record . Dhall.Map.sort <$> kts'       where-        kts' = fmap loop kts-    RecordLit kvs -> RecordLit (Dhall.Map.sort kvs')+        kts' = traverse loop kts+    RecordLit kvs -> RecordLit . Dhall.Map.sort <$> kvs'       where-        kvs' = fmap loop kvs-    Union kts -> Union (Dhall.Map.sort kts')+        kvs' = traverse loop kvs+    Union kts -> Union . Dhall.Map.sort <$> kts'       where-        kts' = fmap loop kts-    UnionLit k v kvs -> UnionLit k v' (Dhall.Map.sort kvs')+        kts' = traverse loop kts+    UnionLit k v kvs -> UnionLit k <$> v' <*> (Dhall.Map.sort <$> kvs')       where-        v'   =      loop v-        kvs' = fmap loop kvs-    Combine x y -> decide (loop x) (loop y)+        v'   =          loop v+        kvs' = traverse loop kvs+    Combine x y -> decide <$> loop x <*> loop y       where         decide (RecordLit m) r | Data.Foldable.null m =             r@@ -1776,7 +1860,7 @@             RecordLit (Dhall.Map.sort (Dhall.Map.unionWith decide m n))         decide l r =             Combine l r-    CombineTypes x y -> decide (loop x) (loop y)+    CombineTypes x y -> decide <$> loop x <*> loop y       where         decide (Record m) r | Data.Foldable.null m =             r@@ -1786,8 +1870,7 @@             Record (Dhall.Map.sort (Dhall.Map.unionWith decide m n))         decide l r =             CombineTypes l r--    Prefer x y -> decide (loop x) (loop y)+    Prefer x y -> decide <$> loop x <*> loop y       where         decide (RecordLit m) r | Data.Foldable.null m =             r@@ -1797,57 +1880,65 @@             RecordLit (Dhall.Map.sort (Dhall.Map.union n m))         decide l r =             Prefer l r-    Merge x y t      ->+    Merge x y t      -> do+        x' <- loop x+        y' <- loop y         case x' of             RecordLit kvsX ->                 case y' of                     UnionLit kY vY _ ->                         case Dhall.Map.lookup kY kvsX of                             Just vX -> loop (App vX vY)-                            Nothing -> Merge x' y' t'-                    _ -> Merge x' y' t'-            _ -> Merge x' y' t'+                            Nothing -> Merge x' y' <$> t'+                    _ -> Merge x' y' <$> t'+            _ -> Merge x' y' <$> t'       where-        x' =      loop x-        y' =      loop y-        t' = fmap loop t-    Constructors t   ->+        t' = traverse loop t+    Constructors t   -> do+        t' <- loop t         case t' of-            Union kts -> RecordLit kvs+            Union kts -> pure (RecordLit kvs)               where                 kvs = Dhall.Map.mapWithKey adapt kts                  adapt k t_ = Lam k t_ (UnionLit k (Var (V k 0)) rest)                   where                     rest = Dhall.Map.delete k kts-            _ -> Constructors t'-      where-        t' = loop t-    Field r x        ->-        case loop r of+            _ -> pure (Constructors t')+    Field r x        -> do+        r' <- loop r+        case r' of             RecordLit kvs ->                 case Dhall.Map.lookup x kvs of                     Just v  -> loop v-                    Nothing -> Field (RecordLit (fmap loop kvs)) x-            r' -> Field r' x-    Project r xs     ->-        case loop r of+                    Nothing -> Field <$> (RecordLit <$> traverse loop kvs) <*> pure x+            Union kvs ->+                case Dhall.Map.lookup x kvs of+                    Just t_ -> Lam x <$> t' <*> pure (UnionLit x (Var (V x 0)) rest)+                      where+                        t' = loop t_+                        rest = Dhall.Map.delete x kvs+                    Nothing -> Field <$> (Union <$> traverse loop kvs) <*> pure x+            _ -> pure (Field r' x)+    Project r xs     -> do+        r' <- loop r+        case r' of             RecordLit kvs ->-                case traverse adapt (Data.Set.toList xs) of+                case traverse adapt (Dhall.Set.toList xs) of                     Just s  ->                         loop (RecordLit kvs')                       where                         kvs' = Dhall.Map.fromList s                     Nothing ->-                        Project (RecordLit (fmap loop kvs)) xs+                        Project <$> (RecordLit <$> traverse loop kvs) <*> pure xs               where                 adapt x = do                     v <- Dhall.Map.lookup x kvs                     return (x, v)-            r' -> Project r' xs+            _ -> pure (Project r' xs)     Note _ e' -> loop e'     ImportAlt l _r -> loop l-    Embed a -> Embed a+    Embed a -> pure (Embed a)  {-| Returns `True` if two expressions are α-equivalent and β-equivalent and     `False` otherwise@@ -1860,8 +1951,10 @@  -- | Use this to wrap you embedded functions (see `normalizeWith`) to make them --   polymorphic enough to be used.-type Normalizer a = forall s. Expr s a -> Maybe (Expr s a)+type NormalizerM m a = forall s. Expr s a -> m (Maybe (Expr s a)) +type Normalizer a = NormalizerM Identity a+ -- | A reified 'Normalizer', which can be stored in structures without -- running into impredicative polymorphism. data ReifiedNormalizer a = ReifiedNormalizer@@ -1872,8 +1965,7 @@ -- --   It is much more efficient to use `isNormalized`. isNormalizedWith :: (Eq s, Eq a) => Normalizer a -> Expr s a -> Bool-isNormalizedWith ctx e = e == (normalizeWith ctx e)-+isNormalizedWith ctx e = e == normalizeWith ctx e  -- | Quickly check if an expression is in normal form isNormalized :: Eq a => Expr s a -> Bool@@ -1920,7 +2012,7 @@           App (App (App (App (App OptionalFold _) (App None _)) _) _) _ ->               False           _ -> True-      Let _ _ _ _ -> False+      Let _ _ -> False       Annot _ _ -> False       Bool -> True       BoolLit _ -> True@@ -2060,6 +2152,10 @@                   case Dhall.Map.lookup x kvs of                       Just _  -> False                       Nothing -> True+              Union kvs ->+                  case Dhall.Map.lookup x kvs of+                      Just _  -> False+                      Nothing -> True               _ -> True       Project r xs -> loop r &&           case r of@@ -2160,5 +2256,103 @@         , "None"         , "Optional/build"         , "Optional/fold"+        , "NaN"+        , "Infinity"         ] ++-- | A traversal over the immediate sub-expressions of an expression.+subExpressions :: Applicative f => (Expr s a -> f (Expr s a)) -> Expr s a -> f (Expr s a)+subExpressions _ (Const c) = pure (Const c)+subExpressions _ (Var v) = pure (Var v)+subExpressions f (Lam a b c) = Lam a <$> f b <*> f c+subExpressions f (Pi a b c) = Pi a <$> f b <*> f c+subExpressions f (App a b) = App <$> f a <*> f b+subExpressions f (Let as b) = Let <$> traverse g as <*> f b+  where+    g (Binding c d e) = Binding c <$> traverse f d <*> f e+subExpressions f (Annot a b) = Annot <$> f a <*> f b+subExpressions _ Bool = pure Bool+subExpressions _ (BoolLit b) = pure (BoolLit b)+subExpressions f (BoolAnd a b) = BoolAnd <$> f a <*> f b+subExpressions f (BoolOr a b) = BoolOr <$> f a <*> f b+subExpressions f (BoolEQ a b) = BoolEQ <$> f a <*> f b+subExpressions f (BoolNE a b) = BoolNE <$> f a <*> f b+subExpressions f (BoolIf a b c) = BoolIf <$> f a <*> f b <*> f c+subExpressions _ Natural = pure Natural+subExpressions _ (NaturalLit n) = pure (NaturalLit n)+subExpressions _ NaturalFold = pure NaturalFold+subExpressions _ NaturalBuild = pure NaturalBuild+subExpressions _ NaturalIsZero = pure NaturalIsZero+subExpressions _ NaturalEven = pure NaturalEven+subExpressions _ NaturalOdd = pure NaturalOdd+subExpressions _ NaturalToInteger = pure NaturalToInteger+subExpressions _ NaturalShow = pure NaturalShow+subExpressions f (NaturalPlus a b) = NaturalPlus <$> f a <*> f b+subExpressions f (NaturalTimes a b) = NaturalTimes <$> f a <*> f b+subExpressions _ Integer = pure Integer+subExpressions _ (IntegerLit n) = pure (IntegerLit n)+subExpressions _ IntegerShow = pure IntegerShow+subExpressions _ IntegerToDouble = pure IntegerToDouble+subExpressions _ Double = pure Double+subExpressions _ (DoubleLit n) = pure (DoubleLit n)+subExpressions _ DoubleShow = pure DoubleShow+subExpressions _ Text = pure Text+subExpressions f (TextLit (Chunks a b)) =+    TextLit <$> (Chunks <$> traverse (traverse f) a <*> pure b)+subExpressions f (TextAppend a b) = TextAppend <$> f a <*> f b+subExpressions _ List = pure List+subExpressions f (ListLit a b) = ListLit <$> traverse f a <*> traverse f b+subExpressions f (ListAppend a b) = ListAppend <$> f a <*> f b+subExpressions _ ListBuild = pure ListBuild+subExpressions _ ListFold = pure ListFold+subExpressions _ ListLength = pure ListLength+subExpressions _ ListHead = pure ListHead+subExpressions _ ListLast = pure ListLast+subExpressions _ ListIndexed = pure ListIndexed+subExpressions _ ListReverse = pure ListReverse+subExpressions _ Optional = pure Optional+subExpressions f (OptionalLit a b) = OptionalLit <$> f a <*> traverse f b+subExpressions f (Some a) = Some <$> f a+subExpressions _ None = pure None+subExpressions _ OptionalFold = pure OptionalFold+subExpressions _ OptionalBuild = pure OptionalBuild+subExpressions f (Record a) = Record <$> traverse f a+subExpressions f ( RecordLit a ) = RecordLit <$> traverse f a+subExpressions f (Union a) = Union <$> traverse f a+subExpressions f (UnionLit a b c) = UnionLit a <$> f b <*> traverse f c+subExpressions f (Combine a b) = Combine <$> f a <*> f b+subExpressions f (CombineTypes a b) = CombineTypes <$> f a <*> f b+subExpressions f (Prefer a b) = Prefer <$> f a <*> f b+subExpressions f (Merge a b t) = Merge <$> f a <*> f b <*> traverse f t+subExpressions f (Constructors a) = Constructors <$> f a+subExpressions f (Field a b) = Field <$> f a <*> pure b+subExpressions f (Project a b) = Project <$> f a <*> pure b+subExpressions f (Note a b) = Note a <$> f b+subExpressions f (ImportAlt l r) = ImportAlt <$> f l <*> f r+subExpressions _ (Embed a) = pure (Embed a)++{-| Returns `True` if the given `Char` is valid within an unquoted path+    component++    This is exported for reuse within the @"Dhall.Parser.Token"@ module+-}+pathCharacter :: Char -> Bool+pathCharacter c =+         '\x21' == c+    ||  ('\x24' <= c && c <= '\x27')+    ||  ('\x2A' <= c && c <= '\x2B')+    ||  ('\x2D' <= c && c <= '\x2E')+    ||  ('\x30' <= c && c <= '\x3B')+    ||  c == '\x3D'+    ||  ('\x40' <= c && c <= '\x5A')+    ||  ('\x5E' <= c && c <= '\x7A')+    ||  c == '\x7C'+    ||  c == '\x7E'++prettyPathComponent :: Text -> Doc ann+prettyPathComponent text+    | Data.Text.all pathCharacter text =+        "/" <> Pretty.pretty text+    | otherwise =+        "/\"" <> Pretty.pretty text <> "\""
src/Dhall/Diff.hs view
@@ -19,15 +19,14 @@ import Data.Function (on) import Data.List.NonEmpty (NonEmpty(..)) import Data.Monoid (Any(..))-import Data.Scientific (Scientific) import Data.Semigroup import Data.Sequence (Seq)-import Data.Set (Set) import Data.String (IsString(..)) import Data.Text (Text) import Data.Text.Prettyprint.Doc (Doc, Pretty)-import Dhall.Core (Chunks (..), Const(..), Expr(..), Var(..))+import Dhall.Core (Binding(..), Chunks (..), Const(..), Expr(..), Var(..)) import Dhall.Map (Map)+import Dhall.Set (Set) import Dhall.Pretty.Internal (Ann) import Numeric.Natural (Natural) @@ -38,6 +37,7 @@ import qualified Data.Text.Prettyprint.Doc  as Pretty import qualified Dhall.Core import qualified Dhall.Map+import qualified Dhall.Set import qualified Dhall.Pretty.Internal      as Internal  data Diff =@@ -175,20 +175,22 @@ diffLabels ksL ksR =     braced (diffFieldNames <> (if anyEqual then [ ignore ] else []))   where-    extraL = Data.Set.difference ksL ksR-    extraR = Data.Set.difference ksR ksL+    extraL = Dhall.Set.difference ksL ksR+    extraR = Dhall.Set.difference ksR ksL      diffFieldNames = foldMap (adapt minus) extraL <> foldMap (adapt plus) extraR       where         adapt sign key = [ sign (token (Internal.prettyLabel key)) ] -    anyEqual = not (Data.Set.null (Data.Set.intersection ksL ksR))+    anyEqual = not (Data.Set.null (Data.Set.intersection+                                   (Dhall.Set.toSet ksL)+                                   (Dhall.Set.toSet ksR)))  diffNatural :: Natural -> Natural -> Diff diffNatural = diffPrimitive (token . Internal.prettyNatural) -diffScientific :: Scientific -> Scientific -> Diff-diffScientific = diffPrimitive (token . Internal.prettyScientific)+diffDouble :: Double -> Double -> Diff+diffDouble = diffPrimitive (token . Internal.prettyDouble)  diffConst :: Const -> Const -> Diff diffConst = diffPrimitive (token . Internal.prettyConst)@@ -698,20 +700,21 @@     mismatch l r diffExpression l r@(BoolIf {}) =     mismatch l r-diffExpression l@(Let {}) r@(Let {}) =-    enclosed' "    " (keyword "in" <> "  ") (docs l r)+diffExpression (Let asL bL ) (Let asR bR) =+    enclosed' "" (keyword "in" <> "  ")+        (Data.List.NonEmpty.zipWith docA asL asR <> pure docB)   where-    docs (Let aL bL cL dL) (Let aR bR cR dR) =-        Data.List.NonEmpty.cons (align doc) (docs dL dR)+    docA (Binding cL dL eL) (Binding cR dR eR) = align doc       where         doc =   keyword "let"             <>  " "-            <>  format " " (diffLabel aL aR)-            <>  format " " (diffMaybe (colon <> " ") diffExpression bL bR)+            <>  format " " (diffLabel cL cR)+            <>  format " " (diffMaybe (colon <> " ") diffExpression dL dR)             <>  equals             <>  " "-            <>  diffExpression cL cR-    docs aL aR = pure (diffExpression aL aR)+            <>  diffExpression eL eR++    docB = diffExpression bL bR diffExpression l@(Let {}) r =     mismatch l r diffExpression l r@(Let {}) =@@ -1243,7 +1246,7 @@ diffPrimitiveExpression l r@(NaturalLit {}) =     mismatch l r diffPrimitiveExpression (DoubleLit aL) (DoubleLit aR) =-    diffScientific aL aR+    diffDouble aL aR diffPrimitiveExpression l@(DoubleLit {}) r =     mismatch l r diffPrimitiveExpression l r@(DoubleLit {}) =
src/Dhall/Import.hs view
@@ -148,6 +148,7 @@ import Dhall.Binary (StandardVersion(..)) import Dhall.Core     ( Expr(..)+    , Binding(..)     , Chunks(..)     , Directory(..)     , File(..)@@ -188,6 +189,7 @@ import qualified Dhall.Parser import qualified Dhall.Pretty.Internal import qualified Dhall.TypeCheck+import qualified Network.URI.Encode import qualified System.Environment import qualified System.Directory                 as Directory import qualified System.FilePath                  as FilePath@@ -609,14 +611,23 @@              return (path, text) -        Remote (URL scheme authority file query fragment maybeHeaders) -> do+        Remote (URL scheme authority path query fragment maybeHeaders) -> do             let prefix =                         (case scheme of HTTP -> "http"; HTTPS -> "https")                     <>  "://"                     <>  authority -            let fileText = Dhall.Pretty.Internal.prettyToStrictText file+            let File {..} = path+            let Directory {..} = directory +            let pathComponentToText component =+                    "/" <> Network.URI.Encode.encodeText component++            let fileText =+                       Text.concat+                           (map pathComponentToText (reverse components))+                    <> pathComponentToText file+             let suffix =                         (case query    of Nothing -> ""; Just q -> "?" <> q)                     <>  (case fragment of Nothing -> ""; Just f -> "#" <> f)@@ -801,7 +812,9 @@   Lam a b c            -> Lam <$> pure a <*> loadWith b <*> loadWith c   Pi a b c             -> Pi <$> pure a <*> loadWith b <*> loadWith c   App a b              -> App <$> loadWith a <*> loadWith b-  Let a b c d          -> Let <$> pure a <*> mapM loadWith b <*> loadWith c <*> loadWith d+  Let as b             -> Let <$> traverse f as <*> loadWith b+    where+      f (Binding c d e) = Binding c <$> traverse loadWith d <*> loadWith e   Annot a b            -> Annot <$> loadWith a <*> loadWith b   Bool                 -> pure Bool   BoolLit a            -> pure (BoolLit a)
src/Dhall/Import/Types.hs view
@@ -73,7 +73,7 @@      _standardVersion = Dhall.Binary.defaultStandardVersion -    _normalizer = ReifiedNormalizer (const Nothing)+    _normalizer = ReifiedNormalizer (const (pure Nothing))      _startingContext = Dhall.Context.empty
src/Dhall/Lint.hs view
@@ -5,7 +5,9 @@       lint     ) where -import Dhall.Core (Chunks(..), Expr(..), Import, Var(..))+import Dhall.Core (Binding(..), Chunks(..), Expr(..), Import, Var(..))+import Data.Semigroup ((<>))+import Data.List.NonEmpty (NonEmpty(..)) import Dhall.TypeCheck (X(..))  import qualified Dhall.Core@@ -15,6 +17,7 @@     Currently this:      * removes unused @let@ bindings+    * consolidates nested @let@ bindings to use a multiple-@let@ binding     * switches legacy @List@-like @Optional@ literals to use @Some@ / @None@ instead -} lint :: Expr s Import -> Expr t Import@@ -36,15 +39,32 @@       where         a' = loop a         b' = loop b-    loop (Let a b c d)++    -- Consolidate nested `let` expresssions+    loop (Let a (Let b c)) = loop (Let (a <> b) c)++    -- Remove unused bindings+    loop (Let (Binding a b c :| []) d)         | not (V a 0 `Dhall.Core.freeIn` d') =             d'         | otherwise =-            Let a b' c' d'+            Let (Binding a b' c' :| [])  d'       where         b' = fmap loop b         c' =      loop c-        d' =      loop d++        d' = loop d+    loop (Let (Binding a b c :| (l : ls)) d)+        | not (V a 0 `Dhall.Core.freeIn` d') =+            Let (l' :| ls') d'+        | otherwise =+            Let (Binding a b' c' :| (l' : ls'))  d'+      where+        b' = fmap loop b+        c' =      loop c++        Let (l' :| ls') d' = loop (Let (l :| ls) d)+     loop (Annot a b) =         Annot a' b'       where
src/Dhall/Parser/Combinators.hs view
@@ -10,12 +10,12 @@ import           Data.Data                  (Data) import           Data.Semigroup             (Semigroup (..)) import           Data.Sequence              (ViewL (..))-import           Data.Set                   (Set) import           Data.String                (IsString (..)) import           Data.Text                  (Text) import           Data.Text.Prettyprint.Doc  (Pretty (..)) import           Data.Void                  (Void)-import           Dhall.Map (Map)+import           Dhall.Map                  (Map)+import           Dhall.Set                  (Set) import           Prelude                    hiding (const, pi) import           Text.Parser.Combinators    (try, (<?>)) import           Text.Parser.Token          (TokenParsing (..))@@ -27,6 +27,7 @@ import qualified Data.Text import qualified Dhall.Map import qualified Dhall.Util+import qualified Dhall.Set import qualified Text.Megaparsec import qualified Text.Megaparsec.Char import qualified Text.Parser.Char@@ -237,13 +238,13 @@ takeWhile1 predicate = Parser (Text.Megaparsec.takeWhile1P Nothing predicate)  noDuplicates :: Ord a => [a] -> Parser (Set a)-noDuplicates = go Data.Set.empty+noDuplicates = go Dhall.Set.empty   where     go found    []  = return found     go found (x:xs) =-        if Data.Set.member x found+        if Data.Set.member x (Dhall.Set.toSet found)         then fail "Duplicate key"-        else go (Data.Set.insert x found) xs+        else go (Dhall.Set.append x found) xs  toMap :: [(Text, a)] -> Parser (Map Text a) toMap kvs = do
src/Dhall/Parser/Expression.hs view
@@ -20,6 +20,7 @@ import qualified Data.ByteArray.Encoding import qualified Data.ByteString import qualified Data.Char+import qualified Data.List.NonEmpty import qualified Data.Sequence import qualified Data.Text import qualified Data.Text.Encoding@@ -82,17 +83,28 @@             return (BoolIf a b c)          alternative2 = do-            _let-            a <- label-            b <- optional (do-                _colon-                expression )-            _equal-            c <- expression+            let binding = do+                    _let++                    c <- label+                    d <- optional (do+                        _colon+                        expression )++                    _equal++                    e <- expression++                    return (Binding c d e)++            as <- Data.List.NonEmpty.some1 binding+             _in-            d <- expression-            return (Let a b c d) +            b <- expression++            return (Let as b)+         alternative3 = do             _forall             _openParens@@ -158,8 +170,8 @@             <|> Combine     <$ _combine      precedence2Operator =-                Prefer       <$ _prefer-            <|> CombineTypes <$ _combineTypes+                CombineTypes <$ _combineTypes+            <|> Prefer       <$ _prefer             <|> NaturalTimes <$ _times             <|> BoolNE       <$ _notEqual @@ -218,6 +230,7 @@                     , alternative06                     , alternative07                     , alternative37+                    , alternative09                      , builtin <?> "built-in expression"                     ]@@ -225,8 +238,12 @@             <|> alternative38           where             alternative00 = do+                n <- Text.Megaparsec.getOffset                 a <- try doubleLiteral-                return (DoubleLit a)+                b <- if isInfinite a+                       then Text.Megaparsec.setOffset n *> fail "double out of bounds"+                       else return a+                return (DoubleLit b)              alternative01 = do                 a <- try naturalLiteral@@ -258,6 +275,10 @@                 b <- importExpression                 return (Merge a b Nothing) +            alternative09 = do+                a <- try doubleInfinity+                return (DoubleLit a)+             builtin = do                 let predicate c =                             c == 'N'@@ -271,6 +292,8 @@                         ||  c == 'F'                         ||  c == 'K' +                let nan = (0.0/0.0)+                 c <- Text.Megaparsec.lookAhead (Text.Megaparsec.satisfy predicate)                  case c of@@ -286,6 +309,7 @@                             , NaturalShow      <$ _NaturalShow                             , Natural          <$ _Natural                             , None             <$ _None+                            , DoubleLit nan    <$ _NaN                             ]                     'I' ->                         choice
src/Dhall/Parser/Token.hs view
@@ -14,6 +14,7 @@     identifier,     hexNumber,     doubleLiteral,+    doubleInfinity,     naturalLiteral,     integerLiteral,     _Optional,@@ -55,6 +56,7 @@     _List,     _True,     _False,+    _NaN,     _Type,     _Kind,     _Sort,@@ -95,9 +97,9 @@ import Control.Applicative (Alternative(..), optional) import Data.Functor (void) import Data.Semigroup (Semigroup(..))-import Data.Set (Set) import Data.Text (Text) import Dhall.Core+import Dhall.Set (Set) import Prelude hiding (const, pi) import Text.Parser.Combinators (choice, try, (<?>)) @@ -105,12 +107,12 @@ import qualified Data.Char import qualified Data.HashSet import qualified Data.List.NonEmpty-import qualified Data.Set import qualified Data.Text+import qualified Dhall.Set+import qualified Text.Megaparsec import qualified Text.Parser.Char import qualified Text.Parser.Combinators -import Data.Scientific (Scientific) import Numeric.Natural (Natural) import Prelude hiding (const, pi) @@ -135,18 +137,28 @@     ||  ('A' <= c && c <= 'F')     ||  ('a' <= c && c <= 'f') -doubleLiteral :: Parser Scientific+signPrefix :: Num a => Parser (a -> a)+signPrefix = (do+    let positive = fmap (\_ -> id    ) (Text.Parser.Char.char '+')+    let negative = fmap (\_ -> negate) (Text.Parser.Char.char '-')+    positive <|> negative ) <?> "sign"++doubleLiteral :: Parser Double doubleLiteral = (do-    sign <-  fmap (\_ -> negate) (Text.Parser.Char.char '-')-         <|> pure id-    a    <-  Text.Parser.Token.scientific+    sign <- signPrefix <|> pure id+    a <- Text.Parser.Token.double     return (sign a) ) <?> "double literal" +doubleInfinity :: Parser Double+doubleInfinity = (do+    let negative = fmap (\_ -> negate) (Text.Parser.Char.char '-')+    sign <- negative <|> pure id+    a <- Text.Parser.Char.text "Infinity" >> whitespace >> return (1.0/0.0)+    return (sign a) ) <?> "double infinity"+ integerLiteral :: Parser Integer integerLiteral = (do-    let positive = fmap (\_ -> id    ) (Text.Parser.Char.char '+')-    let negative = fmap (\_ -> negate) (Text.Parser.Char.char '-')-    sign <- positive <|> negative+    sign <- signPrefix     a <- Text.Parser.Token.natural     return (sign a) ) <?> "integer literal" @@ -278,7 +290,7 @@     _closeBrace     return xs   where-    emptyLabels = pure Data.Set.empty+    emptyLabels = pure Dhall.Set.empty      nonEmptyLabels = do         x  <- label@@ -314,26 +326,26 @@         ||  ('\x3E' <= c && c <= '\x5B')         ||  ('\x5D' <= c && c <= '\x7E') -pathCharacter :: Char -> Bool-pathCharacter c =-        ('\x21' <= c && c <= '\x22')-    ||  ('\x24' <= c && c <= '\x27')-    ||  ('\x2A' <= c && c <= '\x2B')-    ||  ('\x2D' <= c && c <= '\x2E')-    ||  ('\x30' <= c && c <= '\x3B')-    ||  c == '\x3D'-    ||  ('\x40' <= c && c <= '\x5A')-    ||  ('\x5E' <= c && c <= '\x7A')-    ||  c == '\x7C'-    ||  c == '\x7E'+quotedPathCharacter :: Char -> Bool+quotedPathCharacter c =+        ('\x20' <= c && c <= '\x21')+    ||  ('\x23' <= c && c <= '\x2E')+    ||  ('\x30' <= c && c <= '\x7E')  pathComponent :: Parser Text pathComponent = do     _      <- "/" :: Parser Text-    string <- some (Text.Parser.Char.satisfy pathCharacter) -    return (Data.Text.pack string)+    let pathData = Text.Megaparsec.takeWhile1P Nothing Dhall.Core.pathCharacter +    let quotedPathData = do+            _    <- Text.Parser.Char.char '"'+            text <- Text.Megaparsec.takeWhile1P Nothing quotedPathCharacter+            _    <- Text.Parser.Char.char '"'+            return text++    pathData <|> quotedPathData+ file_ :: Parser File file_ = do     path <- Data.List.NonEmpty.some1 pathComponent@@ -529,7 +541,7 @@ _constructors = keyword "constructors"  _Some :: Parser ()-_Some = reserved "Some"+_Some = keyword "Some"  _None :: Parser () _None = reserved "None"@@ -617,6 +629,9 @@  _False :: Parser () _False = reserved "False"++_NaN :: Parser ()+_NaN = reserved "NaN"  _Type :: Parser () _Type = reserved "Type"
src/Dhall/Pretty/Internal.hs view
@@ -23,7 +23,7 @@     , prettyLabels     , prettyNatural     , prettyNumber-    , prettyScientific+    , prettyDouble     , prettyToStrictText     , prettyToString @@ -53,7 +53,7 @@     , rparen     ) where -import {-# SOURCE #-} Dhall.Core+import Dhall.Core  #if MIN_VERSION_base(4,8,0) #else@@ -61,11 +61,10 @@ #endif import Data.Foldable import Data.Monoid ((<>))-import Data.Scientific (Scientific)-import Data.Set (Set) import Data.Text (Text) import Data.Text.Prettyprint.Doc (Doc, Pretty, space) import Dhall.Map (Map)+import Dhall.Set (Set) import Numeric.Natural (Natural) import Prelude hiding (succ) import qualified Data.Text.Prettyprint.Doc.Render.Terminal as Terminal@@ -79,6 +78,7 @@ import qualified Data.Text.Prettyprint.Doc.Render.Text   as Pretty import qualified Data.Text.Prettyprint.Doc.Render.String as Pretty import qualified Dhall.Map+import qualified Dhall.Set  {-| Annotation type used to tag elements in a pretty-printed document for     syntax highlighting purposes@@ -294,10 +294,10 @@  prettyLabels :: Set Text -> Doc Ann prettyLabels a-    | Data.Set.null a =+    | Data.Set.null (Dhall.Set.toSet a) =         lbrace <> rbrace     | otherwise =-        braces (map (duplicate . prettyLabel) (Data.Set.toList a))+        braces (map (duplicate . prettyLabel) (Dhall.Set.toList a))  prettyNumber :: Integer -> Doc Ann prettyNumber = literal . Pretty.pretty@@ -305,8 +305,8 @@ prettyNatural :: Natural -> Doc Ann prettyNatural = literal . Pretty.pretty -prettyScientific :: Scientific -> Doc Ann-prettyScientific = literal . Pretty.pretty . show+prettyDouble :: Double -> Doc Ann+prettyDouble = literal . Pretty.pretty  prettyConst :: Const -> Doc Ann prettyConst Type = builtin "Type"@@ -386,50 +386,51 @@                 ]         docsShort (Note  _    c) = docsShort c         docsShort             c  = [ prettyExpression c ]-    prettyExpression a0@(Let _ _ _ _) =-        enclose' "" "    " (space <> keyword "in" <> space) (Pretty.hardline <> keyword "in" <> "  ")-            (fmap duplicate (docs a0))+    prettyExpression (Let as b) =+        enclose' "" "" space Pretty.hardline+            (fmap duplicate (fmap docA (toList as)) ++ [ docB ])       where-        docs (Let a Nothing c d) =-            Pretty.group (Pretty.flatAlt long short) : docs d+        docA (Binding c Nothing e) =+            Pretty.group (Pretty.flatAlt long short)           where             long =  keyword "let" <> space                 <>  Pretty.align-                    (   prettyLabel a+                    (   prettyLabel c                     <>  space <> equals                     <>  Pretty.hardline                     <>  "  "-                    <>  prettyExpression c+                    <>  prettyExpression e                     )              short = keyword "let" <> space-                <>  prettyLabel a+                <>  prettyLabel c                 <>  (space <> equals <> space)-                <>  prettyExpression c-        docs (Let a (Just b) c d) =-            Pretty.group (Pretty.flatAlt long short) : docs d+                <>  prettyExpression e+        docA (Binding c (Just d) e) =+            Pretty.group (Pretty.flatAlt long short)           where             long = keyword "let" <> space                 <>  Pretty.align-                    (   prettyLabel a+                    (   prettyLabel c                     <>  Pretty.hardline                     <>  colon <> space-                    <>  prettyExpression b+                    <>  prettyExpression d                     <>  Pretty.hardline                     <>  equals <> space-                    <>  prettyExpression c+                    <>  prettyExpression e                     )              short = keyword "let" <> space-                <>  prettyLabel a+                <>  prettyLabel c                 <>  space <> colon <> space-                <>  prettyExpression b+                <>  prettyExpression d                 <>  space <> equals <> space-                <>  prettyExpression c-        docs (Note _ d)  =-            docs d-        docs d =-            [ prettyExpression d ]+                <>  prettyExpression e++        docB =+            ( keyword "in" <> " " <> prettyExpression b+            , keyword "in" <> "  "  <> prettyExpression b+            )     prettyExpression a0@(Pi _ _ _) =         arrows characterSet (fmap duplicate (docs a0))       where@@ -784,7 +785,7 @@     prettyPrimitiveExpression (NaturalLit a) =         prettyNatural a     prettyPrimitiveExpression (DoubleLit a) =-        prettyScientific a+        prettyDouble a     prettyPrimitiveExpression (TextLit a) =         prettyChunks a     prettyPrimitiveExpression (Record a) =@@ -809,15 +810,15 @@         short = lparen <> prettyExpression a <> rparen      prettyKeyValue :: Pretty a => Doc Ann -> (Text, Expr s a) -> (Doc Ann, Doc Ann)-    prettyKeyValue separator (key, value) =-        (   prettyLabel key <> " " <> separator <> " " <> prettyExpression value+    prettyKeyValue separator (key, val) =+        (   prettyLabel key <> " " <> separator <> " " <> prettyExpression val         ,       prettyLabel key             <>  " "             <>  separator             <>  long         )       where-        long = Pretty.hardline <> "    " <> prettyExpression value+        long = Pretty.hardline <> "    " <> prettyExpression val      prettyRecord :: Pretty a => Map Text (Expr s a) -> Doc Ann     prettyRecord =@@ -909,22 +910,22 @@ escapeText text = Text.concatMap adapt text   where     adapt c-        | '\x20' <= c && c <= '\x21' = Text.singleton c+        | '\x20' <= c && c <= '\x21'     = Text.singleton c         -- '\x22' == '"'-        | '\x23' == c                = Text.singleton c+        | '\x23' == c                    = Text.singleton c         -- '\x24' == '$'-        | '\x25' <= c && c <= '\x5B' = Text.singleton c+        | '\x25' <= c && c <= '\x5B'     = Text.singleton c         -- '\x5C' == '\\'-        | '\x5D' <= c && c <= '\x7F' = Text.singleton c-        | c == '"'                   = "\\\""-        | c == '$'                   = "\\$"-        | c == '\\'                  = "\\\\"-        | c == '\b'                  = "\\b"-        | c == '\f'                  = "\\f"-        | c == '\n'                  = "\\n"-        | c == '\r'                  = "\\r"-        | c == '\t'                  = "\\t"-        | otherwise                  = "\\u" <> showDigits (Data.Char.ord c)+        | '\x5D' <= c && c <= '\x10FFFF' = Text.singleton c+        | c == '"'                       = "\\\""+        | c == '$'                       = "\\$"+        | c == '\\'                      = "\\\\"+        | c == '\b'                      = "\\b"+        | c == '\f'                      = "\\f"+        | c == '\n'                      = "\\n"+        | c == '\r'                      = "\\r"+        | c == '\t'                      = "\\t"+        | otherwise                      = "\\u" <> showDigits (Data.Char.ord c)      showDigits r0 = Text.pack (map showDigit [q1, q2, q3, r3])       where
src/Dhall/Repl.hs view
@@ -26,6 +26,7 @@ import qualified Dhall import qualified Dhall.Binary import qualified Dhall.Context+import qualified Dhall.Core import qualified Dhall.Core as Dhall ( Var(V), Expr, normalize ) import qualified Dhall.Pretty import qualified Dhall.Core as Expr ( Expr(..) )@@ -159,7 +160,7 @@     ( Dhall.normalize         ( foldl'             ( \a (k, Binding { bindingType, bindingExpr }) ->-                Expr.Let k ( Just bindingType ) bindingExpr a+                Expr.Let (pure (Dhall.Core.Binding k (Just bindingType) bindingExpr)) a             )             e             ( Dhall.Context.toList ( envToContext env ) )
+ src/Dhall/Set.hs view
@@ -0,0 +1,64 @@+{-# LANGUAGE DeriveDataTypeable #-}+{-# LANGUAGE DeriveGeneric #-}++-- | This module only exports ways of constructing a Set,+-- retrieving List, Set, and Seq representations of the same data,+-- as well as a novel "difference" function.+-- Any other Set-like or List-like functionality+-- should be obtained through toSet and toList, respectively.+module Dhall.Set (+      Set(..)+    , toList+    , toSet+    , toSeq+    , fromList+    , append+    , empty+    , difference+    ) where++import Prelude+import Data.List (foldl')+import Data.Sequence (Seq, (|>))+import Data.Data (Data)+import GHC.Generics (Generic)++import qualified Data.Set+import qualified Data.Sequence+import qualified Data.Foldable++data Set a = Set (Data.Set.Set a) (Seq a)+    deriving (Eq, Generic, Ord, Show, Data)++instance Foldable Set where+    foldMap f = foldMap f . toSeq++toSet :: Set a -> Data.Set.Set a+toSet (Set s _) = s++toSeq :: Set a -> Seq a+toSeq (Set _ xs) = xs++toList :: Set a -> [a]+toList = Data.Foldable.toList++-- O(n log n) time complexity, O(n) space complexity.+-- Implementing it this way is a little silly, but is faster than (nub xs).+-- n.b. toList . fromList = id, only if the list elements are unique+fromList :: Ord a => [a] -> Set a+fromList = foldl' (flip append) empty++-- O(log n) time complexity.+append :: Ord a => a -> Set a -> Set a+append x os@(Set s xs)+    | Data.Set.member x s = os+    | otherwise = Set (Data.Set.insert x s) (xs |> x)++empty :: Set a+empty = Set Data.Set.empty Data.Sequence.empty++-- | Returns, in order, all elements of the first Set not present in the second.+-- (It doesn't matter in what order the elements appear in the second Set.)+difference :: Ord a => Set a -> Set a -> [a]+difference os (Set s _) =+    filter (\ x -> not (Data.Set.member x s)) (toList os)
src/Dhall/TypeCheck.hs view
@@ -24,6 +24,7 @@ import Control.Exception (Exception) import Data.Data (Data(..)) import Data.Foldable (forM_, toList)+import Data.List.NonEmpty (NonEmpty(..)) import Data.Sequence (Seq, ViewL(..)) import Data.Semigroup (Semigroup(..)) import Data.Set (Set)@@ -31,7 +32,7 @@ import Data.Text.Prettyprint.Doc (Doc, Pretty(..)) import Data.Traversable (forM) import Data.Typeable (Typeable)-import Dhall.Core (Const(..), Chunks(..), Expr(..), Var(..))+import Dhall.Core (Binding(..), Const(..), Chunks(..), Expr(..), Var(..)) import Dhall.Context (Context) import Dhall.Pretty (Ann, layoutOpts) @@ -45,6 +46,7 @@ import qualified Dhall.Core import qualified Dhall.Diff import qualified Dhall.Map+import qualified Dhall.Set import qualified Dhall.Pretty.Internal import qualified Dhall.Util @@ -60,9 +62,9 @@ rule :: Const -> Const -> Either () Const rule Type Type = return Type rule Kind Type = return Type-rule Kind Kind = return Kind rule Sort Type = return Type-rule Sort Kind = return Kind+rule Kind Kind = return Kind+rule Sort Kind = return Sort rule Sort Sort = return Sort -- This forbids dependent types. If this ever changes, then the fast -- path in the Let case of typeWithA will become unsound.@@ -146,7 +148,7 @@                 let nf_A  = Dhall.Core.normalize _A                 let nf_A' = Dhall.Core.normalize _A'                 Left (TypeError ctx e (TypeMismatch f nf_A a nf_A'))-    loop ctx e@(Let x mA a0 b0) = do+    loop ctx e@(Let (Binding x mA a0 :| ls) b0) = do         _A1 <- loop ctx a0         case mA of             Just _A0 -> do@@ -163,6 +165,10 @@         let a1 = Dhall.Core.normalize a0         let a2 = Dhall.Core.shift 1 (V x 0) a1 +        let rest = case ls of+                []       -> b0+                l' : ls' -> Let (l' :| ls') b0+         -- The catch-all branch directly implements the Dhall         -- specification as written; it is necessary to substitute in         -- types in order to get 'dependent let' behaviour and to@@ -175,13 +181,13 @@         case Dhall.Core.normalize t of           Const Type -> do             let ctx' = fmap (Dhall.Core.shift 1 (V x 0)) (Dhall.Context.insert x (Dhall.Core.normalize _A1) ctx)-            _B0 <- loop ctx' b0+            _B0 <- loop ctx' rest             let _B1 = Dhall.Core.subst (V x 0) a2 _B0             let _B2 = Dhall.Core.shift (-1) (V x 0) _B1             return _B2            _ -> do-            let b1 = Dhall.Core.subst (V x 0) a2 b0+            let b1 = Dhall.Core.subst (V x 0) a2 rest             let b2 = Dhall.Core.shift (-1) (V x 0) b1             loop ctx b2 @@ -505,7 +511,11 @@                             _ ->                                 Left (TypeError ctx e (InvalidFieldType k t))                 Dhall.Map.traverseWithKey_ process rest-                return (Const c)++                case c of+                    Type -> return (Const Type)+                    Kind -> return (Const Sort)+                    Sort -> return (Const Sort)     loop ctx e@(RecordLit kvs   ) = do         case Dhall.Map.toList kvs of             []         -> return (Record mempty)@@ -770,6 +780,9 @@         return (Record (Dhall.Map.mapWithKey adapt kts))     loop ctx e@(Field r x       ) = do         t <- fmap Dhall.Core.normalize (loop ctx r)++        let text = Dhall.Pretty.Internal.docToStrictText (Dhall.Pretty.Internal.prettyLabel x)+         case t of             Record kts -> do                 _ <- loop ctx t@@ -777,9 +790,15 @@                 case Dhall.Map.lookup x kts of                     Just t' -> return t'                     Nothing -> Left (TypeError ctx e (MissingField x t))+            Const Type -> do+                case Dhall.Core.normalize r of+                  Union kts ->+                    case Dhall.Map.lookup x kts of+                        Just t' -> return (Pi x t' (Union kts))+                        Nothing -> Left (TypeError ctx e (MissingField x t))+                  r' -> Left (TypeError ctx e (CantAccess text r' t))             _ -> do-                let text = Dhall.Pretty.Internal.docToStrictText (Dhall.Pretty.Internal.prettyLabel x)-                Left (TypeError ctx e (NotARecord text r t))+                Left (TypeError ctx e (CantAccess text r t))     loop ctx e@(Project r xs    ) = do         t <- fmap Dhall.Core.normalize (loop ctx r)         case t of@@ -791,10 +810,10 @@                             Just t' -> return (k, t')                             Nothing -> Left (TypeError ctx e (MissingField k t))                 let adapt = Record . Dhall.Map.fromList-                fmap adapt (traverse process (Data.Set.toList xs))+                fmap adapt (traverse process (Dhall.Set.toList xs))             _ -> do                 let text = Dhall.Pretty.Internal.docToStrictText (Dhall.Pretty.Internal.prettyLabels xs)-                Left (TypeError ctx e (NotARecord text r t))+                Left (TypeError ctx e (CantProject text r t))     loop ctx   (Note s e'       ) = case loop ctx e' of         Left (TypeError ctx' (Note s' e'') m) -> Left (TypeError ctx' (Note s' e'') m)         Left (TypeError ctx'          e''  m) -> Left (TypeError ctx' (Note s  e'') m)@@ -869,7 +888,8 @@     | MissingMergeType     | HandlerNotAFunction Text (Expr s a)     | ConstructorsRequiresAUnionType (Expr s a) (Expr s a)-    | NotARecord Text (Expr s a) (Expr s a)+    | CantAccess Text (Expr s a) (Expr s a)+    | CantProject Text (Expr s a) (Expr s a)     | MissingField Text (Expr s a)     | CantAnd (Expr s a) (Expr s a)     | CantOr (Expr s a) (Expr s a)@@ -3242,18 +3262,18 @@       where         txt0 = insert expr0         txt1 = insert expr1- -prettyTypeMessage (NotARecord lazyText0 expr0 expr1) = ErrorMessages {..}++prettyTypeMessage (CantAccess lazyText0 expr0 expr1) = ErrorMessages {..}   where-    short = "Not a record"+    short = "Not a record or a union"      long =-        "Explanation: You can only access fields on records, like this:                  \n\+        "Explanation: You can only access fields on records or unions, like this:        \n\         \                                                                                \n\         \                                                                                \n\-        \    ┌─────────────────────────────────┐                                         \n\+        \    ┌───────────────────────────────────┐                                       \n\         \    │ { foo = True, bar = \"ABC\" }.foo │  This is valid ...                    \n\-        \    └─────────────────────────────────┘                                         \n\+        \    └───────────────────────────────────┘                                       \n\         \                                                                                \n\         \                                                                                \n\         \    ┌───────────────────────────────────────────┐                               \n\@@ -3261,6 +3281,16 @@         \    └───────────────────────────────────────────┘                               \n\         \                                                                                \n\         \                                                                                \n\+        \    ┌─────────────────────────────────┐                                         \n\+        \    │ < foo : Bool | bar : Text >.foo │  ... and so is this                     \n\+        \    └─────────────────────────────────┘                                         \n\+        \                                                                                \n\+        \                                                                                \n\+        \    ┌────────────────────────────────────────────┐                              \n\+        \    │ λ(r : < foo : Bool | bar : Text >) → r.foo │  ... and so is this          \n\+        \    └────────────────────────────────────────────┘                              \n\+        \                                                                                \n\+        \                                                                                \n\         \... but you cannot access fields on non-record expressions                      \n\         \                                                                                \n\         \For example, the following expression is " <> _NOT <> " valid:                  \n\@@ -3273,22 +3303,70 @@         \      Invalid: Not a record                                                     \n\         \                                                                                \n\         \                                                                                \n\+        \────────────────────────────────────────────────────────────────────────────────\n\+        \                                                                                \n\+        \You tried to access the field:                                                  \n\+        \                                                                                \n\+        \" <> txt0 <> "\n\+        \                                                                                \n\+        \... on the following expression which is not a record nor a union type:         \n\+        \                                                                                \n\+        \" <> txt1 <> "\n\+        \                                                                                \n\+        \... but is actually an expression of type:                                      \n\+        \                                                                                \n\+        \" <> txt2 <> "\n"+      where+        txt0 = insert lazyText0+        txt1 = insert expr0+        txt2 = insert expr1++prettyTypeMessage (CantProject lazyText0 expr0 expr1) = ErrorMessages {..}+  where+    short = "Not a record"++    long =+        "Explanation: You can only project fields on records, like this:                 \n\+        \                                                                                \n\+        \                                                                                \n\+        \    ┌─────────────────────────────────────────────────────┐                     \n\+        \    │ { foo = True, bar = \"ABC\", baz = 1 }.{ foo, bar } │  This is valid ...  \n\+        \    └─────────────────────────────────────────────────────┘                     \n\+        \                                                                                \n\+        \                                                                                \n\+        \    ┌────────────────────────────────────────────────────────────────────┐      \n\+        \    │ λ(r : { foo : Bool, bar : Text , baz : Natural }) → r.{ foo, bar } │  ... and so is this           \n\+        \    └────────────────────────────────────────────────────────────────────┘      \n\+        \                                                                                \n\+        \                                                                                \n\+        \... but you cannot project fields on non-record expressions                     \n\+        \                                                                                \n\+        \For example, the following expression is " <> _NOT <> " valid:                  \n\+        \                                                                                \n\+        \                                                                                \n\+        \    ┌────────────────┐                                                          \n\+        \    │ 1.{ foo, bar } │                                                          \n\+        \    └────────────────┘                                                          \n\+        \      ⇧                                                                         \n\+        \      Invalid: Not a record                                                     \n\+        \                                                                                \n\+        \                                                                                \n\         \Some common reasons why you might get this error:                               \n\         \                                                                                \n\-        \● You accidentally try to access a field of a union instead of a record, like   \n\+        \● You accidentally try to project fields of a union instead of a record, like   \n\         \  this:                                                                         \n\         \                                                                                \n\         \                                                                                \n\-        \    ┌─────────────────┐                                                         \n\-        \    │ < foo : a >.foo │                                                         \n\-        \    └─────────────────┘                                                         \n\+        \    ┌────────────────────────────────────┐                                      \n\+        \    │ < foo : a | bar : b >.{ foo, bar } │                                      \n\+        \    └────────────────────────────────────┘                                      \n\         \      ⇧                                                                         \n\         \      This is a union, not a record                                             \n\         \                                                                                \n\         \                                                                                \n\         \────────────────────────────────────────────────────────────────────────────────\n\         \                                                                                \n\-        \You tried to access the field(s):                                               \n\+        \You tried to access the fields:                                               \n\         \                                                                                \n\         \" <> txt0 <> "\n\         \                                                                                \n\
tests/Format.hs view
@@ -34,6 +34,10 @@             "fieldOrder"         , should             Unicode+            "preserve the original order of projections"+            "projectionOrder"+        , should+            Unicode             "escape numeric labels correctly"             "escapeNumericLabel"         , should@@ -42,6 +46,10 @@             "largeExponent"         , should             Unicode+            "round a double to the nearest representable value. Ties go to even least significant bit"+            "doubleRound"+        , should+            Unicode             "correctly format the empty record literal"             "emptyRecord"         , should@@ -72,6 +80,10 @@             ASCII             "be able to format with ASCII characters"             "ascii"+        , should+            Unicode+            "preserve Unicode characters"+            "unicode"         ]  should :: CharacterSet -> Text -> Text -> TestTree
tests/Import.hs view
@@ -23,38 +23,38 @@             [ shouldFail                 3                 "alternative of several unset env variables"-                "./tests/import/alternativeEnv.dhall"+                "./tests/import/failure/alternativeEnv.dhall"             , shouldFail                 1                 "alternative of env variable and missing"-                "./tests/import/alternativeEnvMissing.dhall"+                "./tests/import/failure/alternativeEnvMissing.dhall"             , shouldFail                 0                 "just missing"-                "./tests/import/missing.dhall"+                "./tests/import/failure/missing.dhall"             , shouldNotFail                 "alternative of env variable, missing, and a Natural"-                "./tests/import/alternativeEnvNatural.dhall"+                "./tests/import/success/alternativeEnvNaturalA.dhall"             , shouldNotFail                 "alternative of env variable and a Natural"-                "./tests/import/alternativeEnvSimple.dhall"+                "./tests/import/success/alternativeEnvSimpleA.dhall"             , shouldNotFail                 "alternative of a Natural and missing"-                "./tests/import/alternativeNatural.dhall"+                "./tests/import/success/alternativeNaturalA.dhall"             ]         , Test.Tasty.testGroup "import relative to argument"             [ shouldNotFailRelative                 "works"                 "./tests/import/data/foo/bar"-                "./tests/import/relative.dhall"+                "./tests/import/success/relative.dhall"             , shouldNotFailRelative                 "a semantic integrity check if fields are reordered"-                "./tests/import/"-                "./tests/import/fieldOrderC.dhall"+                "./tests/import/success/"+                "./tests/import/success/fieldOrderA.dhall"             , shouldNotFailRelative                 "a semantic integrity check when importing an expression using `constructors`"-                "./tests/import/"-                "./tests/import/issue553B.dhall"+                "./tests/import/success/"+                "./tests/import/success/issue553B.dhall"             ]         ]
tests/Normalization.hs view
@@ -29,176 +29,181 @@         , simplifications         , constantFolding         , conversions-        , shouldNormalize "Optional build/fold fusion" "optionalBuildFold"+        , shouldNormalize "Optional build/fold fusion" "success/simple/optionalBuildFold"         , customization-        , shouldNormalize "a remote-systems.conf builder" "remoteSystems"-        , shouldNormalize "multi-line strings correctly" "multiLine"-        , shouldNormalize "the // operator and sort the fields" "sortOperator"+        , shouldNormalize "a remote-systems.conf builder" "success/remoteSystems"+        , shouldNormalize "multi-line strings correctly" "success/simple/multiLine"+        , shouldNormalize "the // operator and sort the fields" "success/simple/sortOperator"         ]  tutorialExamples :: TestTree tutorialExamples =     testGroup "Tutorial examples"-        [ shouldNormalize "⩓" "./tutorial/combineTypes/0"-        , shouldNormalize "projection" "./tutorial/projection/0"+        [ shouldNormalize "⩓" "./success/haskell-tutorial/combineTypes/0"+        , shouldNormalize "//\\\\" "./success/haskell-tutorial/combineTypes/1"+        , shouldNormalize "//" "./success/haskell-tutorial/prefer/0"+        , shouldNormalize "projection" "./success/haskell-tutorial/projection/0"+        , shouldNormalize "access record" "./success/haskell-tutorial/access/0"+        , shouldNormalize "access union" "./success/haskell-tutorial/access/1"         ]  preludeExamples :: TestTree preludeExamples =     testGroup "Prelude examples"-        [ shouldNormalize "Bool/and" "./examples/Bool/and/0"-        , shouldNormalize "Bool/and" "./examples/Bool/and/1"-        , shouldNormalize "Bool/build" "./examples/Bool/build/0"-        , shouldNormalize "Bool/build" "./examples/Bool/build/1"-        , shouldNormalize "Bool/even" "./examples/Bool/even/0"-        , shouldNormalize "Bool/even" "./examples/Bool/even/1"-        , shouldNormalize "Bool/even" "./examples/Bool/even/2"-        , shouldNormalize "Bool/even" "./examples/Bool/even/3"-        , shouldNormalize "Bool/fold" "./examples/Bool/fold/0"-        , shouldNormalize "Bool/fold" "./examples/Bool/fold/1"-        , shouldNormalize "Bool/not" "./examples/Bool/not/0"-        , shouldNormalize "Bool/not" "./examples/Bool/not/1"-        , shouldNormalize "Bool/odd" "./examples/Bool/odd/0"-        , shouldNormalize "Bool/odd" "./examples/Bool/odd/1"-        , shouldNormalize "Bool/odd" "./examples/Bool/odd/2"-        , shouldNormalize "Bool/odd" "./examples/Bool/odd/3"-        , shouldNormalize "Bool/or" "./examples/Bool/or/0"-        , shouldNormalize "Bool/or" "./examples/Bool/or/1"-        , shouldNormalize "Bool/show" "./examples/Bool/show/0"-        , shouldNormalize "Bool/show" "./examples/Bool/show/1"-        , shouldNormalize "Double/show" "./examples/Double/show/0"-        , shouldNormalize "Double/show" "./examples/Double/show/1"-        , shouldNormalize "Integer/show" "./examples/Integer/show/0"-        , shouldNormalize "Integer/show" "./examples/Integer/show/1"-        , shouldNormalize "Integer/toDouble" "./examples/Integer/toDouble/0"-        , shouldNormalize "Integer/toDouble" "./examples/Integer/toDouble/1"-        , shouldNormalize "List/all" "./examples/List/all/0"-        , shouldNormalize "List/all" "./examples/List/all/1"-        , shouldNormalize "List/any" "./examples/List/any/0"-        , shouldNormalize "List/any" "./examples/List/any/1"-        , shouldNormalize "List/build" "./examples/List/build/0"-        , shouldNormalize "List/build" "./examples/List/build/1"-        , shouldNormalize "List/concat" "./examples/List/concat/0"-        , shouldNormalize "List/concat" "./examples/List/concat/1"-        , shouldNormalize "List/concatMap" "./examples/List/concatMap/0"-        , shouldNormalize "List/concatMap" "./examples/List/concatMap/1"-        , shouldNormalize "List/filter" "./examples/List/filter/0"-        , shouldNormalize "List/filter" "./examples/List/filter/1"-        , shouldNormalize "List/fold" "./examples/List/fold/0"-        , shouldNormalize "List/fold" "./examples/List/fold/1"-        , shouldNormalize "List/fold" "./examples/List/fold/2"-        , shouldNormalize "List/generate" "./examples/List/generate/0"-        , shouldNormalize "List/generate" "./examples/List/generate/1"-        , shouldNormalize "List/head" "./examples/List/head/0"-        , shouldNormalize "List/head" "./examples/List/head/1"-        , shouldNormalize "List/indexed" "./examples/List/indexed/0"-        , shouldNormalize "List/indexed" "./examples/List/indexed/1"-        , shouldNormalize "List/iterate" "./examples/List/iterate/0"-        , shouldNormalize "List/iterate" "./examples/List/iterate/1"-        , shouldNormalize "List/last" "./examples/List/last/0"-        , shouldNormalize "List/last" "./examples/List/last/1"-        , shouldNormalize "List/length" "./examples/List/length/0"-        , shouldNormalize "List/length" "./examples/List/length/1"-        , shouldNormalize "List/map" "./examples/List/map/0"-        , shouldNormalize "List/map" "./examples/List/map/1"-        , shouldNormalize "List/null" "./examples/List/null/0"-        , shouldNormalize "List/null" "./examples/List/null/1"-        , shouldNormalize "List/replicate" "./examples/List/replicate/0"-        , shouldNormalize "List/replicate" "./examples/List/replicate/1"-        , shouldNormalize "List/reverse" "./examples/List/reverse/0"-        , shouldNormalize "List/reverse" "./examples/List/reverse/1"-        , shouldNormalize "List/shifted" "./examples/List/shifted/0"-        , shouldNormalize "List/shifted" "./examples/List/shifted/1"-        , shouldNormalize "List/unzip" "./examples/List/unzip/0"-        , shouldNormalize "List/unzip" "./examples/List/unzip/1"-        , shouldNormalize "Natural/build" "./examples/Natural/build/0"-        , shouldNormalize "Natural/build" "./examples/Natural/build/1"-        , shouldNormalize "Natural/enumerate" "./examples/Natural/enumerate/0"-        , shouldNormalize "Natural/enumerate" "./examples/Natural/enumerate/1"-        , shouldNormalize "Natural/even" "./examples/Natural/even/0"-        , shouldNormalize "Natural/even" "./examples/Natural/even/1"-        , shouldNormalize "Natural/fold" "./examples/Natural/fold/0"-        , shouldNormalize "Natural/fold" "./examples/Natural/fold/1"-        , shouldNormalize "Natural/fold" "./examples/Natural/fold/2"-        , shouldNormalize "Natural/isZero" "./examples/Natural/isZero/0"-        , shouldNormalize "Natural/isZero" "./examples/Natural/isZero/1"-        , shouldNormalize "Natural/odd" "./examples/Natural/odd/0"-        , shouldNormalize "Natural/odd" "./examples/Natural/odd/1"-        , shouldNormalize "Natural/product" "./examples/Natural/product/0"-        , shouldNormalize "Natural/product" "./examples/Natural/product/1"-        , shouldNormalize "Natural/show" "./examples/Natural/show/0"-        , shouldNormalize "Natural/show" "./examples/Natural/show/1"-        , shouldNormalize "Natural/sum" "./examples/Natural/sum/0"-        , shouldNormalize "Natural/sum" "./examples/Natural/sum/1"-        , shouldNormalize "Natural/toDouble" "./examples/Natural/toDouble/0"-        , shouldNormalize "Natural/toDouble" "./examples/Natural/toDouble/1"-        , shouldNormalize "Natural/toInteger" "./examples/Natural/toInteger/0"-        , shouldNormalize "Natural/toInteger" "./examples/Natural/toInteger/1"-        , shouldNormalize "Optional/all" "./examples/Optional/all/0"-        , shouldNormalize "Optional/all" "./examples/Optional/all/1"-        , shouldNormalize "Optional/any" "./examples/Optional/any/0"-        , shouldNormalize "Optional/any" "./examples/Optional/any/1"-        , shouldNormalize "Optional/build" "./examples/Optional/build/0"-        , shouldNormalize "Optional/build" "./examples/Optional/build/1"-        , shouldNormalize "Optional/concat" "./examples/Optional/concat/0"-        , shouldNormalize "Optional/concat" "./examples/Optional/concat/1"-        , shouldNormalize "Optional/concat" "./examples/Optional/concat/2"-        , shouldNormalize "Optional/filter" "./examples/Optional/filter/0"-        , shouldNormalize "Optional/filter" "./examples/Optional/filter/1"-        , shouldNormalize "Optional/fold" "./examples/Optional/fold/0"-        , shouldNormalize "Optional/fold" "./examples/Optional/fold/1"-        , shouldNormalize "Optional/head" "./examples/Optional/head/0"-        , shouldNormalize "Optional/head" "./examples/Optional/head/1"-        , shouldNormalize "Optional/head" "./examples/Optional/head/2"-        , shouldNormalize "Optional/last" "./examples/Optional/last/0"-        , shouldNormalize "Optional/last" "./examples/Optional/last/1"-        , shouldNormalize "Optional/last" "./examples/Optional/last/2"-        , shouldNormalize "Optional/length" "./examples/Optional/length/0"-        , shouldNormalize "Optional/length" "./examples/Optional/length/1"-        , shouldNormalize "Optional/map" "./examples/Optional/map/0"-        , shouldNormalize "Optional/map" "./examples/Optional/map/1"-        , shouldNormalize "Optional/null" "./examples/Optional/null/0"-        , shouldNormalize "Optional/null" "./examples/Optional/null/1"-        , shouldNormalize "Optional/toList" "./examples/Optional/toList/0"-        , shouldNormalize "Optional/toList" "./examples/Optional/toList/1"-        , shouldNormalize "Optional/unzip" "./examples/Optional/unzip/0"-        , shouldNormalize "Optional/unzip" "./examples/Optional/unzip/1"-        , shouldNormalize "Text/concat" "./examples/Text/concat/0"-        , shouldNormalize "Text/concat" "./examples/Text/concat/1"-        , shouldNormalize "Text/concatMap" "./examples/Text/concatMap/0"-        , shouldNormalize "Text/concatMap" "./examples/Text/concatMap/1"-        , shouldNormalize "Text/concatMapSep" "./examples/Text/concatMapSep/0"-        , shouldNormalize "Text/concatMapSep" "./examples/Text/concatMapSep/1"-        , shouldNormalize "Text/concatSep" "./examples/Text/concatSep/0"-        , shouldNormalize "Text/concatSep" "./examples/Text/concatSep/1"+        [ shouldNormalize "Bool/and" "./success/prelude/Bool/and/0"+        , shouldNormalize "Bool/and" "./success/prelude/Bool/and/1"+        , shouldNormalize "Bool/build" "./success/prelude/Bool/build/0"+        , shouldNormalize "Bool/build" "./success/prelude/Bool/build/1"+        , shouldNormalize "Bool/even" "./success/prelude/Bool/even/0"+        , shouldNormalize "Bool/even" "./success/prelude/Bool/even/1"+        , shouldNormalize "Bool/even" "./success/prelude/Bool/even/2"+        , shouldNormalize "Bool/even" "./success/prelude/Bool/even/3"+        , shouldNormalize "Bool/fold" "./success/prelude/Bool/fold/0"+        , shouldNormalize "Bool/fold" "./success/prelude/Bool/fold/1"+        , shouldNormalize "Bool/not" "./success/prelude/Bool/not/0"+        , shouldNormalize "Bool/not" "./success/prelude/Bool/not/1"+        , shouldNormalize "Bool/odd" "./success/prelude/Bool/odd/0"+        , shouldNormalize "Bool/odd" "./success/prelude/Bool/odd/1"+        , shouldNormalize "Bool/odd" "./success/prelude/Bool/odd/2"+        , shouldNormalize "Bool/odd" "./success/prelude/Bool/odd/3"+        , shouldNormalize "Bool/or" "./success/prelude/Bool/or/0"+        , shouldNormalize "Bool/or" "./success/prelude/Bool/or/1"+        , shouldNormalize "Bool/show" "./success/prelude/Bool/show/0"+        , shouldNormalize "Bool/show" "./success/prelude/Bool/show/1"+        , shouldNormalize "Double/show" "./success/prelude/Double/show/0"+        , shouldNormalize "Double/show" "./success/prelude/Double/show/1"+        , shouldNormalize "Integer/show" "./success/prelude/Integer/show/0"+        , shouldNormalize "Integer/show" "./success/prelude/Integer/show/1"+        , shouldNormalize "Integer/toDouble" "./success/prelude/Integer/toDouble/0"+        , shouldNormalize "Integer/toDouble" "./success/prelude/Integer/toDouble/1"+        , shouldNormalize "List/all" "./success/prelude/List/all/0"+        , shouldNormalize "List/all" "./success/prelude/List/all/1"+        , shouldNormalize "List/any" "./success/prelude/List/any/0"+        , shouldNormalize "List/any" "./success/prelude/List/any/1"+        , shouldNormalize "List/build" "./success/prelude/List/build/0"+        , shouldNormalize "List/build" "./success/prelude/List/build/1"+        , shouldNormalize "List/concat" "./success/prelude/List/concat/0"+        , shouldNormalize "List/concat" "./success/prelude/List/concat/1"+        , shouldNormalize "List/concatMap" "./success/prelude/List/concatMap/0"+        , shouldNormalize "List/concatMap" "./success/prelude/List/concatMap/1"+        , shouldNormalize "List/filter" "./success/prelude/List/filter/0"+        , shouldNormalize "List/filter" "./success/prelude/List/filter/1"+        , shouldNormalize "List/fold" "./success/prelude/List/fold/0"+        , shouldNormalize "List/fold" "./success/prelude/List/fold/1"+        , shouldNormalize "List/fold" "./success/prelude/List/fold/2"+        , shouldNormalize "List/generate" "./success/prelude/List/generate/0"+        , shouldNormalize "List/generate" "./success/prelude/List/generate/1"+        , shouldNormalize "List/head" "./success/prelude/List/head/0"+        , shouldNormalize "List/head" "./success/prelude/List/head/1"+        , shouldNormalize "List/indexed" "./success/prelude/List/indexed/0"+        , shouldNormalize "List/indexed" "./success/prelude/List/indexed/1"+        , shouldNormalize "List/iterate" "./success/prelude/List/iterate/0"+        , shouldNormalize "List/iterate" "./success/prelude/List/iterate/1"+        , shouldNormalize "List/last" "./success/prelude/List/last/0"+        , shouldNormalize "List/last" "./success/prelude/List/last/1"+        , shouldNormalize "List/length" "./success/prelude/List/length/0"+        , shouldNormalize "List/length" "./success/prelude/List/length/1"+        , shouldNormalize "List/map" "./success/prelude/List/map/0"+        , shouldNormalize "List/map" "./success/prelude/List/map/1"+        , shouldNormalize "List/null" "./success/prelude/List/null/0"+        , shouldNormalize "List/null" "./success/prelude/List/null/1"+        , shouldNormalize "List/replicate" "./success/prelude/List/replicate/0"+        , shouldNormalize "List/replicate" "./success/prelude/List/replicate/1"+        , shouldNormalize "List/reverse" "./success/prelude/List/reverse/0"+        , shouldNormalize "List/reverse" "./success/prelude/List/reverse/1"+        , shouldNormalize "List/shifted" "./success/prelude/List/shifted/0"+        , shouldNormalize "List/shifted" "./success/prelude/List/shifted/1"+        , shouldNormalize "List/unzip" "./success/prelude/List/unzip/0"+        , shouldNormalize "List/unzip" "./success/prelude/List/unzip/1"+        , shouldNormalize "Natural/build" "./success/prelude/Natural/build/0"+        , shouldNormalize "Natural/build" "./success/prelude/Natural/build/1"+        , shouldNormalize "Natural/enumerate" "./success/prelude/Natural/enumerate/0"+        , shouldNormalize "Natural/enumerate" "./success/prelude/Natural/enumerate/1"+        , shouldNormalize "Natural/even" "./success/prelude/Natural/even/0"+        , shouldNormalize "Natural/even" "./success/prelude/Natural/even/1"+        , shouldNormalize "Natural/fold" "./success/prelude/Natural/fold/0"+        , shouldNormalize "Natural/fold" "./success/prelude/Natural/fold/1"+        , shouldNormalize "Natural/fold" "./success/prelude/Natural/fold/2"+        , shouldNormalize "Natural/isZero" "./success/prelude/Natural/isZero/0"+        , shouldNormalize "Natural/isZero" "./success/prelude/Natural/isZero/1"+        , shouldNormalize "Natural/odd" "./success/prelude/Natural/odd/0"+        , shouldNormalize "Natural/odd" "./success/prelude/Natural/odd/1"+        , shouldNormalize "Natural/product" "./success/prelude/Natural/product/0"+        , shouldNormalize "Natural/product" "./success/prelude/Natural/product/1"+        , shouldNormalize "Natural/show" "./success/prelude/Natural/show/0"+        , shouldNormalize "Natural/show" "./success/prelude/Natural/show/1"+        , shouldNormalize "Natural/sum" "./success/prelude/Natural/sum/0"+        , shouldNormalize "Natural/sum" "./success/prelude/Natural/sum/1"+        , shouldNormalize "Natural/toDouble" "./success/prelude/Natural/toDouble/0"+        , shouldNormalize "Natural/toDouble" "./success/prelude/Natural/toDouble/1"+        , shouldNormalize "Natural/toInteger" "./success/prelude/Natural/toInteger/0"+        , shouldNormalize "Natural/toInteger" "./success/prelude/Natural/toInteger/1"+        , shouldNormalize "Optional/all" "./success/prelude/Optional/all/0"+        , shouldNormalize "Optional/all" "./success/prelude/Optional/all/1"+        , shouldNormalize "Optional/any" "./success/prelude/Optional/any/0"+        , shouldNormalize "Optional/any" "./success/prelude/Optional/any/1"+        , shouldNormalize "Optional/build" "./success/prelude/Optional/build/0"+        , shouldNormalize "Optional/build" "./success/prelude/Optional/build/1"+        , shouldNormalize "Optional/concat" "./success/prelude/Optional/concat/0"+        , shouldNormalize "Optional/concat" "./success/prelude/Optional/concat/1"+        , shouldNormalize "Optional/concat" "./success/prelude/Optional/concat/2"+        , shouldNormalize "Optional/filter" "./success/prelude/Optional/filter/0"+        , shouldNormalize "Optional/filter" "./success/prelude/Optional/filter/1"+        , shouldNormalize "Optional/fold" "./success/prelude/Optional/fold/0"+        , shouldNormalize "Optional/fold" "./success/prelude/Optional/fold/1"+        , shouldNormalize "Optional/head" "./success/prelude/Optional/head/0"+        , shouldNormalize "Optional/head" "./success/prelude/Optional/head/1"+        , shouldNormalize "Optional/head" "./success/prelude/Optional/head/2"+        , shouldNormalize "Optional/last" "./success/prelude/Optional/last/0"+        , shouldNormalize "Optional/last" "./success/prelude/Optional/last/1"+        , shouldNormalize "Optional/last" "./success/prelude/Optional/last/2"+        , shouldNormalize "Optional/length" "./success/prelude/Optional/length/0"+        , shouldNormalize "Optional/length" "./success/prelude/Optional/length/1"+        , shouldNormalize "Optional/map" "./success/prelude/Optional/map/0"+        , shouldNormalize "Optional/map" "./success/prelude/Optional/map/1"+        , shouldNormalize "Optional/null" "./success/prelude/Optional/null/0"+        , shouldNormalize "Optional/null" "./success/prelude/Optional/null/1"+        , shouldNormalize "Optional/toList" "./success/prelude/Optional/toList/0"+        , shouldNormalize "Optional/toList" "./success/prelude/Optional/toList/1"+        , shouldNormalize "Optional/unzip" "./success/prelude/Optional/unzip/0"+        , shouldNormalize "Optional/unzip" "./success/prelude/Optional/unzip/1"+        , shouldNormalize "Text/concat" "./success/prelude/Text/concat/0"+        , shouldNormalize "Text/concat" "./success/prelude/Text/concat/1"+        , shouldNormalize "Text/concatMap" "./success/prelude/Text/concatMap/0"+        , shouldNormalize "Text/concatMap" "./success/prelude/Text/concatMap/1"+        , shouldNormalize "Text/concatMapSep" "./success/prelude/Text/concatMapSep/0"+        , shouldNormalize "Text/concatMapSep" "./success/prelude/Text/concatMapSep/1"+        , shouldNormalize "Text/concatSep" "./success/prelude/Text/concatSep/0"+        , shouldNormalize "Text/concatSep" "./success/prelude/Text/concatSep/1"         ]  simplifications :: TestTree simplifications =     testGroup "Simplifications"-        [ shouldNormalize "if/then/else" "./simplifications/ifThenElse"-        , shouldNormalize "||" "./simplifications/or"-        , shouldNormalize "&&" "./simplifications/and"-        , shouldNormalize "==" "./simplifications/eq"-        , shouldNormalize "!=" "./simplifications/ne"+        [ shouldNormalize "if/then/else" "./success/simplifications/ifThenElse"+        , shouldNormalize "||" "./success/simplifications/or"+        , shouldNormalize "&&" "./success/simplifications/and"+        , shouldNormalize "==" "./success/simplifications/eq"+        , shouldNormalize "!=" "./success/simplifications/ne"         ]  constantFolding :: TestTree constantFolding =     testGroup "folding of constants"-        [ shouldNormalize "Natural/plus"   "naturalPlus"-        , shouldNormalize "Optional/fold"  "optionalFold"-        , shouldNormalize "Optional/build" "optionalBuild"-        , shouldNormalize "Natural/build"  "naturalBuild"+        [ shouldNormalize "Natural/plus"   "success/simple/naturalPlus"+        , shouldNormalize "Optional/fold"  "success/simple/optionalFold"+        , shouldNormalize "Optional/build" "success/simple/optionalBuild"+        , shouldNormalize "Natural/build"  "success/simple/naturalBuild"         ]  conversions :: TestTree conversions =     testGroup "conversions"-        [ shouldNormalize "Natural/show" "naturalShow"-        , shouldNormalize "Integer/show" "integerShow"-        , shouldNormalize "Double/show"  "doubleShow"-        , shouldNormalize "Natural/toInteger" "naturalToInteger"+        [ shouldNormalize "Natural/show" "success/simple/naturalShow"+        , shouldNormalize "Integer/show" "success/simple/integerShow"+        , shouldNormalize "Double/show"  "success/simple/doubleShow"+        , shouldNormalize "Natural/toInteger" "success/simple/naturalToInteger"+        , shouldNormalize "Integer/toDouble" "success/simple/integerToDouble"         ]  customization :: TestTree@@ -212,8 +217,8 @@ simpleCustomization = testCase "simpleCustomization" $ do   let tyCtx  = insert "min" (Pi "_" Natural (Pi "_" Natural Natural)) empty       valCtx e = case e of-                    (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalLit y)) -> Just (NaturalLit (min x y))-                    _ -> Nothing+                    (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalLit y)) -> pure (Just (NaturalLit (min x y)))+                    _ -> pure Nothing   e <- codeWith tyCtx "min (min 11 12) 8 + 1"   assertNormalizesToWith valCtx e "9" @@ -224,12 +229,12 @@   wurbleType     <- insert "wurble"     <$> code "Natural → Integer"   let tyCtx = minType . fiveorlessType . wurbleType $ empty       valCtx e = case e of-                    (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalLit y)) -> Just (NaturalLit (min x y))-                    (App (Var (V "wurble" 0)) (NaturalLit x)) -> Just-                        (App (Var (V "fiveorless" 0)) (NaturalPlus (NaturalLit x) (NaturalLit 2)))-                    (App (Var (V "fiveorless" 0)) (NaturalLit x)) -> Just-                        (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalPlus (NaturalLit 3) (NaturalLit 2)))-                    _ -> Nothing+                    (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalLit y)) -> pure (Just (NaturalLit (min x y)))+                    (App (Var (V "wurble" 0)) (NaturalLit x)) -> pure (Just+                        (App (Var (V "fiveorless" 0)) (NaturalPlus (NaturalLit x) (NaturalLit 2))))+                    (App (Var (V "fiveorless" 0)) (NaturalLit x)) -> pure (Just+                        (App (App (Var (V "min" 0)) (NaturalLit x)) (NaturalPlus (NaturalLit 3) (NaturalLit 2))))+                    _ -> pure Nothing   e <- codeWith tyCtx "wurble 6"   assertNormalizesToWith valCtx e "5"
tests/Parser.hs view
@@ -18,145 +18,151 @@         [ Test.Tasty.testGroup "whitespace"             [ shouldParse                 "prefix/suffix"-                "./tests/parser/whitespace.dhall"+                "./tests/parser/success/whitespace"             , shouldParse                 "block comment"-                "./tests/parser/blockComment.dhall"+                "./tests/parser/success/blockComment"             , shouldParse                 "nested block comment"-                "./tests/parser/nestedBlockComment.dhall"+                "./tests/parser/success/nestedBlockComment"             , shouldParse                 "line comment"-                "./tests/parser/lineComment.dhall"+                "./tests/parser/success/lineComment"             , shouldParse                 "Unicode comment"-                "./tests/parser/unicodeComment.dhall"+                "./tests/parser/success/unicodeComment"             , shouldParse                 "whitespace buffet"-                "./tests/parser/whitespaceBuffet.dhall"+                "./tests/parser/success/whitespaceBuffet"             ]         , shouldParse             "label"-            "./tests/parser/label.dhall"+            "./tests/parser/success/label"         , shouldParse             "quoted label"-            "./tests/parser/quotedLabel.dhall"+            "./tests/parser/success/quotedLabel"         , shouldParse             "double quoted string"-            "./tests/parser/doubleQuotedString.dhall"+            "./tests/parser/success/doubleQuotedString"         , shouldParse             "Unicode double quoted string"-            "./tests/parser/unicodeDoubleQuotedString.dhall"+            "./tests/parser/success/unicodeDoubleQuotedString"         , shouldParse             "escaped double quoted string"-            "./tests/parser/escapedDoubleQuotedString.dhall"+            "./tests/parser/success/escapedDoubleQuotedString"         , shouldParse             "interpolated double quoted string"-            "./tests/parser/interpolatedDoubleQuotedString.dhall"+            "./tests/parser/success/interpolatedDoubleQuotedString"         , shouldParse             "single quoted string"-            "./tests/parser/singleQuotedString.dhall"+            "./tests/parser/success/singleQuotedString"         , shouldParse             "escaped single quoted string"-            "./tests/parser/escapedSingleQuotedString.dhall"+            "./tests/parser/success/escapedSingleQuotedString"         , shouldParse             "interpolated single quoted string"-            "./tests/parser/interpolatedSingleQuotedString.dhall"+            "./tests/parser/success/interpolatedSingleQuotedString"         , shouldParse             "double"-            "./tests/parser/double.dhall"+            "./tests/parser/success/double"         , shouldParse             "natural"-            "./tests/parser/natural.dhall"+            "./tests/parser/success/natural"         , shouldParse             "identifier"-            "./tests/parser/identifier.dhall"+            "./tests/parser/success/identifier"         , shouldParse             "paths"-            "./tests/parser/paths.dhall"+            "./tests/parser/success/paths"         , shouldParse             "path termination"-            "./tests/parser/pathTermination.dhall"+            "./tests/parser/success/pathTermination"         , shouldParse             "urls"-            "./tests/parser/urls.dhall"+            "./tests/parser/success/urls"         , shouldParse             "environmentVariables"-            "./tests/parser/environmentVariables.dhall"+            "./tests/parser/success/environmentVariables"         , shouldParse             "lambda"-            "./tests/parser/lambda.dhall"+            "./tests/parser/success/lambda"         , shouldParse             "if then else"-            "./tests/parser/ifThenElse.dhall"+            "./tests/parser/success/ifThenElse"         , shouldParse             "let"-            "./tests/parser/let.dhall"+            "./tests/parser/success/let"         , shouldParse             "forall"-            "./tests/parser/forall.dhall"+            "./tests/parser/success/forall"         , shouldParse             "function type"-            "./tests/parser/functionType.dhall"+            "./tests/parser/success/functionType"         , shouldParse             "operators"-            "./tests/parser/operators.dhall"+            "./tests/parser/success/operators"         , shouldParse             "annotations"-            "./tests/parser/annotations.dhall"+            "./tests/parser/success/annotations"         , shouldParse             "merge"-            "./tests/parser/merge.dhall"+            "./tests/parser/success/merge"         , shouldParse             "constructors"-            "./tests/parser/constructors.dhall"+            "./tests/parser/success/constructors"         , shouldParse             "fields"-            "./tests/parser/fields.dhall"+            "./tests/parser/success/fields"         , shouldParse             "record"-            "./tests/parser/record.dhall"+            "./tests/parser/success/record"         , shouldParse             "union"-            "./tests/parser/union.dhall"+            "./tests/parser/success/union"         , shouldParse             "list"-            "./tests/parser/list.dhall"+            "./tests/parser/success/list"         , shouldParse             "builtins"-            "./tests/parser/builtins.dhall"+            "./tests/parser/success/builtins"         , shouldParse             "import alternatives"-            "./tests/parser/importAlt.dhall"+            "./tests/parser/success/importAlt"         , shouldParse             "large expression"-            "./tests/parser/largeExpression.dhall"+            "./tests/parser/success/largeExpression"         , shouldParse             "names that begin with reserved identifiers"-            "./tests/parser/reservedPrefix.dhall"+            "./tests/parser/success/reservedPrefix"         , shouldParse             "interpolated expressions with leading whitespace"-            "./tests/parser/template.dhall"-        , shouldNotParse-            "records with duplicate fields"-            "./tests/parser/failure/duplicateFields.dhall"+            "./tests/parser/success/template"         , shouldParse             "collections with type annotations containing imports"-            "./tests/parser/collectionImportType.dhall"+            "./tests/parser/success/collectionImportType"         , shouldParse             "a parenthesized custom header import"-            "./tests/parser/parenthesizeUsing.dhall"+            "./tests/parser/success/parenthesizeUsing"         , shouldNotParse             "accessing a field of an import without parentheses"             "./tests/parser/failure/importAccess.dhall"         , shouldParse             "Sort"-            "./tests/parser/sort.dhall"+            "./tests/parser/success/sort"+        , shouldParse+            "quoted path components"+            "./tests/parser/success/quotedPaths"+        , shouldNotParse+            "positive double out of bounds"+            "./tests/parser/failure/doubleBoundsPos.dhall"+        , shouldNotParse+            "negative double out of bounds"+            "./tests/parser/failure/doubleBoundsNeg.dhall"         ]  shouldParse :: Text -> FilePath -> TestTree shouldParse name path = Test.Tasty.HUnit.testCase (Data.Text.unpack name) (do-    text <- Data.Text.IO.readFile path+    text <- Data.Text.IO.readFile (path <> "A.dhall")     case Dhall.Parser.exprFromText mempty text of         Left err -> Control.Exception.throwIO err         Right _  -> return () )
tests/QuickCheck.hs view
@@ -8,9 +8,11 @@  import Codec.Serialise (DeserialiseFailure(..)) import Control.Monad (guard)+import Data.List.NonEmpty (NonEmpty(..)) import Dhall.Map (Map) import Dhall.Core-    ( Chunks(..)+    ( Binding(..)+    , Chunks(..)     , Const(..)     , Directory(..)     , Expr(..)@@ -24,6 +26,7 @@     , URL(..)     , Var(..)     )+import Dhall.Set (Set) import Numeric.Natural (Natural) import Test.QuickCheck     (Arbitrary(..), Gen, Property, genericShrink, (===))@@ -36,6 +39,7 @@ import qualified Data.Sequence import qualified Dhall.Binary import qualified Dhall.Core+import qualified Dhall.Set import qualified Test.QuickCheck import qualified Test.Tasty.QuickCheck @@ -46,6 +50,9 @@     D (DeserialiseFailure aL bL) == D (DeserialiseFailure aR bR) =         aL == aR && bL == bR +instance (Arbitrary a, Ord a) => Arbitrary (Set a) where+  arbitrary = Dhall.Set.fromList <$> arbitrary+ lift0 :: a -> Gen a lift0 = pure @@ -121,6 +128,11 @@         .   shrink         .   Dhall.Map.toList +instance (Arbitrary s, Arbitrary a) => Arbitrary (Binding s a) where+    arbitrary = lift3 Binding++    shrink = genericShrink+ instance (Arbitrary s, Arbitrary a) => Arbitrary (Chunks s a) where     arbitrary = do         n <- Test.QuickCheck.choose (0, 2)@@ -159,7 +171,13 @@                 , ( 1, Test.QuickCheck.oneof [ lift2 (Lam "_"), lift3 Lam ])                 , ( 1, Test.QuickCheck.oneof [ lift2 (Pi "_"), lift3 Pi ])                 , ( 1, lift2 App)-                , ( 1, Test.QuickCheck.oneof [ lift3 (Let "_"), lift4 Let ])+                , let letExpression = do+                          n        <- Test.QuickCheck.choose (0, 2)+                          binding  <- arbitrary+                          bindings <- Test.QuickCheck.vectorOf n arbitrary+                          body     <- arbitrary+                          return (Let (binding :| bindings) body)+                  in  ( 1, Test.QuickCheck.oneof [ letExpression ])                 , ( 1, lift2 Annot)                 , ( 7, lift0 Bool)                 , ( 7, lift1 BoolLit)
tests/TypeCheck.hs view
@@ -21,40 +21,70 @@ typecheckTests :: TestTree typecheckTests =     Test.Tasty.testGroup "typecheck tests"-        [ Test.Tasty.testGroup "Prelude examples"-            [ should "Monoid" "./examples/Monoid/00"-            , should "Monoid" "./examples/Monoid/01"-            , should "Monoid" "./examples/Monoid/02"-            , should "Monoid" "./examples/Monoid/03"-            , should "Monoid" "./examples/Monoid/04"-            , should "Monoid" "./examples/Monoid/05"-            , should "Monoid" "./examples/Monoid/06"-            , should "Monoid" "./examples/Monoid/07"-            , should "Monoid" "./examples/Monoid/08"-            , should "Monoid" "./examples/Monoid/09"-            , should "Monoid" "./examples/Monoid/10"-            ]+        [ preludeExamples+        , accessTypeChecks         , should             "allow type-valued fields in a record"-            "fieldsAreTypes"+            "success/simple/fieldsAreTypes"         , should             "allow type-valued alternatives in a union"-            "alternativesAreTypes"+            "success/simple/alternativesAreTypes"         , should             "allow anonymous functions in types to be judgmentally equal"-            "anonymousFunctionsInTypes"+            "success/simple/anonymousFunctionsInTypes"         , should             "correctly handle α-equivalent merge alternatives"-            "mergeEquivalence"+            "success/simple/mergeEquivalence"         , should             "allow Kind variables"-            "kindParameter"+            "success/simple/kindParameter"         , shouldNotTypeCheck             "combining records of terms and types"             "failure/combineMixedRecords"         , shouldNotTypeCheck             "preferring a record of types over a record of terms"             "failure/preferMixedRecords"+        , should+            "allow records of types of mixed kinds"+            "success/recordOfTypes"+        , should+            "allow Boehm-Berarducci-encoded records of types of mixed kinds"+            "success/encodedRecordOfTypes"+        , should+            "allow accessing a type from a record"+            "success/accessType"+        , should+            "allow accessing a type from a Boehm-Berarducci-encoded record"+            "success/accessEncodedType"+        , shouldNotTypeCheck+            "Hurkens' paradox"+            "failure/hurkensParadox"+        , should+            "allow accessing a constructor from a type stored inside a record"+            "success/simple/mixedFieldAccess"+        ]++preludeExamples :: TestTree+preludeExamples =+    Test.Tasty.testGroup "Prelude examples"+        [ should "Monoid" "./success/prelude/Monoid/00"+        , should "Monoid" "./success/prelude/Monoid/01"+        , should "Monoid" "./success/prelude/Monoid/02"+        , should "Monoid" "./success/prelude/Monoid/03"+        , should "Monoid" "./success/prelude/Monoid/04"+        , should "Monoid" "./success/prelude/Monoid/05"+        , should "Monoid" "./success/prelude/Monoid/06"+        , should "Monoid" "./success/prelude/Monoid/07"+        , should "Monoid" "./success/prelude/Monoid/08"+        , should "Monoid" "./success/prelude/Monoid/09"+        , should "Monoid" "./success/prelude/Monoid/10"+        ]++accessTypeChecks :: TestTree+accessTypeChecks =+    Test.Tasty.testGroup "typecheck access"+        [ should "record" "./success/simple/access/0"+        , should "record" "./success/simple/access/1"         ]  should :: Text -> Text -> TestTree
+ tests/format/doubleRoundA.dhall view
@@ -0,0 +1,41 @@+[ 1.0000000000000000+, 1.0000000000000001+, 1.0000000000000002+, 1.0000000000000003+, 1.0000000000000004+, 1.0000000000000005+, 1.0000000000000006+, 1.0000000000000007+, 1.0000000000000008+, 1.0000000000000009++, 1.0000000000000000e64+, 1.0000000000000001e64+, 1.0000000000000002e64+, 1.0000000000000003e64+, 1.0000000000000004e64+, 1.0000000000000005e64+, 1.0000000000000006e64+, 1.0000000000000007e64+, 1.0000000000000008e64+, 1.0000000000000009e64++, 1.0000000000000000e100+, 1.0000000000000001e100+, 1.0000000000000002e100+, 1.0000000000000003e100+, 1.0000000000000004e100+, 1.0000000000000005e100+, 1.0000000000000006e100+, 1.0000000000000007e100+, 1.0000000000000008e100+, 1.0000000000000009e100++, 179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791.0+, 179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218945.0+, 179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944.0++, -179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791.0+, -179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218945.0+, -179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944.0+]
+ tests/format/doubleRoundB.dhall view
@@ -0,0 +1,37 @@+[ 1.0+, 1.0+, 1.0000000000000002+, 1.0000000000000002+, 1.0000000000000004+, 1.0000000000000004+, 1.0000000000000007+, 1.0000000000000007+, 1.0000000000000009+, 1.0000000000000009+, 1.0e64+, 1.0000000000000002e64+, 1.0000000000000002e64+, 1.0000000000000003e64+, 1.0000000000000005e64+, 1.0000000000000005e64+, 1.0000000000000006e64+, 1.0000000000000008e64+, 1.0000000000000008e64+, 1.0000000000000009e64+, 1.0e100+, 1.0e100+, 1.0000000000000002e100+, 1.0000000000000002e100+, 1.0000000000000004e100+, 1.0000000000000004e100+, 1.0000000000000006e100+, 1.0000000000000008e100+, 1.0000000000000008e100+, 1.000000000000001e100+, 1.7976931348623157e308+, 1.7976931348623157e308+, 1.7976931348623155e308+, -1.7976931348623157e308+, -1.7976931348623157e308+, -1.7976931348623155e308+]
tests/format/importLinesA.dhall view
@@ -1,7 +1,7 @@ let _ = ./emptyRecordA.dhall-in  let _ = ./emptyRecordA.dhall-in  let _ = ./emptyRecordA.dhall-in  let _ = ./emptyRecordA.dhall-in  let _ = ./emptyRecordA.dhall-in  let _ = ./emptyRecordA.dhall+let _ = ./emptyRecordA.dhall+let _ = ./emptyRecordA.dhall+let _ = ./emptyRecordA.dhall+let _ = ./emptyRecordA.dhall+let _ = ./emptyRecordA.dhall in  123
tests/format/importLinesB.dhall view
@@ -1,13 +1,13 @@-    let _ = ./emptyRecordA.dhall+let _ = ./emptyRecordA.dhall -in  let _ = ./emptyRecordA.dhall+let _ = ./emptyRecordA.dhall -in  let _ = ./emptyRecordA.dhall+let _ = ./emptyRecordA.dhall -in  let _ = ./emptyRecordA.dhall+let _ = ./emptyRecordA.dhall -in  let _ = ./emptyRecordA.dhall+let _ = ./emptyRecordA.dhall -in  let _ = ./emptyRecordA.dhall+let _ = ./emptyRecordA.dhall  in  123
tests/format/largeExponentA.dhall view
@@ -1,1 +1,1 @@-[ 1.0, 1e1000000000, 1e-1000000000 ]+[ 1.0, 1e100, 1e-100 ]
tests/format/largeExponentB.dhall view
@@ -1,1 +1,1 @@-[ 1.0, 1.0e1000000000, 1.0e-1000000000 ]+[ 1.0, 1.0e100, 1.0e-100 ]
+ tests/format/projectionOrderA.dhall view
@@ -0,0 +1,1 @@+e.{ foo, bar, baz }
+ tests/format/projectionOrderB.dhall view
@@ -0,0 +1,1 @@+e.{ foo, bar, baz }
tests/format/sha256PrintingA.dhall view
@@ -1,2 +1,4 @@ let replicate =-    https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate sha256:b0e3ec1797b32c80c0bcb7e8254b08c7e9e35e75e6b410c7ac21477ab90167ad in  replicate 5+      https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate sha256:cc856d59b63f7699881bdb8e4b1036ca4c0013827268040a50c1e1405f646a2c++in  replicate 5
tests/format/sha256PrintingB.dhall view
@@ -1,4 +1,4 @@-    let replicate =-          https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate sha256:b0e3ec1797b32c80c0bcb7e8254b08c7e9e35e75e6b410c7ac21477ab90167ad+let replicate =+      https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate sha256:cc856d59b63f7699881bdb8e4b1036ca4c0013827268040a50c1e1405f646a2c  in  replicate 5
+ tests/format/unicodeA.dhall view
@@ -0,0 +1,16 @@+  λ(isActive : Bool)+→   { barLeftEnd =+        [ "┨" ] : Optional Text+    , barRightEnd =+        [ "┠" ] : Optional Text+    , separator =+        [ "┃" ] : Optional Text+    , alignment =+          < ToTheLeft = {=} | ToTheRight : {} | Centered : {} >+        : ./Alignment.dhall+    , barWidth =+        [] : Optional Natural+    , barSegments =+        [ "index", "command", "path", "title" ]+    }+  : ./Bar.dhall
+ tests/format/unicodeB.dhall view
@@ -0,0 +1,16 @@+  λ(isActive : Bool)+→   { barLeftEnd =+        [ "┨" ] : Optional Text+    , barRightEnd =+        [ "┠" ] : Optional Text+    , separator =+        [ "┃" ] : Optional Text+    , alignment =+          < ToTheLeft = {=} | ToTheRight : {} | Centered : {} >+        : ./Alignment.dhall+    , barWidth =+        [] : Optional Natural+    , barSegments =+        [ "index", "command", "path", "title" ]+    }+  : ./Bar.dhall
− tests/import/alternativeEnv.dhall 
@@ -1,1 +0,0 @@-env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3
− tests/import/alternativeEnvMissing.dhall 
@@ -1,1 +0,0 @@-env:UNSET ? missing
− tests/import/alternativeEnvNatural.dhall 
@@ -1,1 +0,0 @@-env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2
− tests/import/alternativeEnvSimple.dhall 
@@ -1,1 +0,0 @@-env:UNSET ? 3
− tests/import/alternativeNatural.dhall 
@@ -1,1 +0,0 @@-4 ? missing
+ tests/import/data/fieldOrder/1.dhall view
@@ -0,0 +1,1 @@+{ foo = 1, bar = True }
+ tests/import/data/fieldOrder/2.dhall view
@@ -0,0 +1,1 @@+{ bar = True, foo = 1 }
+ tests/import/failure/alternativeEnv.dhall view
@@ -0,0 +1,1 @@+env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3
+ tests/import/failure/alternativeEnvMissing.dhall view
@@ -0,0 +1,1 @@+env:UNSET ? missing
+ tests/import/failure/missing.dhall view
@@ -0,0 +1,1 @@+missing
− tests/import/fieldOrderA.dhall 
@@ -1,1 +0,0 @@-{ foo = 1, bar = True }
− tests/import/fieldOrderB.dhall 
@@ -1,1 +0,0 @@-{ bar = True, foo = 1 }
− tests/import/fieldOrderC.dhall 
@@ -1,5 +0,0 @@-{ example0 =-    ./fieldOrderA.dhall sha256:72791c3846cef2ec49baabe6a5d38ca25301ed30b45754dfa1c6b06bab8faaf6-, example1 =-    ./fieldOrderB.dhall sha256:72791c3846cef2ec49baabe6a5d38ca25301ed30b45754dfa1c6b06bab8faaf6-}
− tests/import/issue553A.dhall 
@@ -1,5 +0,0 @@-    let T = < A : {} | B : {} >--in  let t = constructors T--in  t
− tests/import/issue553B.dhall 
@@ -1,1 +0,0 @@-./issue553A.dhall sha256:ef4cce5b6c440b2409f9ba86e48fb788b7ccb757569a713492654f23209cb19b
− tests/import/missing.dhall 
@@ -1,1 +0,0 @@-missing
− tests/import/relative.dhall 
@@ -1,2 +0,0 @@--- This file assumes its base directory is actually ./data/foo/bar/-./a.dhall : Natural
+ tests/import/success/alternativeEnvNaturalA.dhall view
@@ -0,0 +1,1 @@+env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2
+ tests/import/success/alternativeEnvNaturalB.dhall view
@@ -0,0 +1,1 @@+2
+ tests/import/success/alternativeEnvSimpleA.dhall view
@@ -0,0 +1,1 @@+env:UNSET ? 3
+ tests/import/success/alternativeEnvSimpleB.dhall view
@@ -0,0 +1,1 @@+3
+ tests/import/success/alternativeNaturalA.dhall view
@@ -0,0 +1,1 @@+4 ? missing
+ tests/import/success/alternativeNaturalB.dhall view
@@ -0,0 +1,1 @@+4
+ tests/import/success/fieldOrderA.dhall view
@@ -0,0 +1,5 @@+{ example0 =+    ./../data/fieldOrder/1.dhall sha256:4a7866b88389e18cf481b525544fd7903325252faf3a86c8fdc981298c788a9b+, example1 =+    ./../data/fieldOrder/2.dhall sha256:4a7866b88389e18cf481b525544fd7903325252faf3a86c8fdc981298c788a9b+}
+ tests/import/success/fieldOrderB.dhall view
@@ -0,0 +1,1 @@+{ example0 = { bar = True, foo = 1 }, example1 = { bar = True, foo = 1 } }
+ tests/import/success/issue553A.dhall view
@@ -0,0 +1,5 @@+    let T = < A : {} | B : {} >++in  let t = constructors T++in  t
+ tests/import/success/issue553B.dhall view
@@ -0,0 +1,1 @@+./issue553A.dhall sha256:6fb582c043889dd5a4c97176f8a58d2633252b5374cb71e288b93bc3757f9643
+ tests/import/success/relative.dhall view
@@ -0,0 +1,2 @@+-- This file assumes its base directory is actually ./data/foo/bar/+./a.dhall : Natural
− tests/normalization/doubleShowA.dhall 
@@ -1,1 +0,0 @@-{ example0 = Double/show -0.42, example1 = Double/show 13.37 }
− tests/normalization/doubleShowB.dhall 
@@ -1,1 +0,0 @@-{ example0 = "-0.42", example1 = "13.37" }
− tests/normalization/examples/Bool/and/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.and [ True, False, True ]
− tests/normalization/examples/Bool/and/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Bool/and/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.and ([] : List Bool)
− tests/normalization/examples/Bool/and/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Bool/build/0A.dhall 
@@ -1,2 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.build -(λ(bool : Type) → λ(true : bool) → λ(false : bool) → true)
− tests/normalization/examples/Bool/build/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Bool/build/1A.dhall 
@@ -1,2 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.build -(λ(bool : Type) → λ(true : bool) → λ(false : bool) → false)
− tests/normalization/examples/Bool/build/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Bool/even/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.even [ False, True, False ]
− tests/normalization/examples/Bool/even/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Bool/even/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.even [ False, True ]
− tests/normalization/examples/Bool/even/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Bool/even/2A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.even [ False ]
− tests/normalization/examples/Bool/even/2B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Bool/even/3A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.even ([] : List Bool)
− tests/normalization/examples/Bool/even/3B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Bool/fold/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.fold True Natural 0 1
− tests/normalization/examples/Bool/fold/0B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/examples/Bool/fold/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.fold False Natural 0 1
− tests/normalization/examples/Bool/fold/1B.dhall 
@@ -1,1 +0,0 @@-1
− tests/normalization/examples/Bool/not/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.not True
− tests/normalization/examples/Bool/not/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Bool/not/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.not False
− tests/normalization/examples/Bool/not/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Bool/odd/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.odd [ True, False, True ]
− tests/normalization/examples/Bool/odd/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Bool/odd/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.odd [ True, False ]
− tests/normalization/examples/Bool/odd/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Bool/odd/2A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.odd [ True ]
− tests/normalization/examples/Bool/odd/2B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Bool/odd/3A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.odd ([] : List Bool)
− tests/normalization/examples/Bool/odd/3B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Bool/or/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.or [ True, False, True ]
− tests/normalization/examples/Bool/or/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Bool/or/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.or ([] : List Bool)
− tests/normalization/examples/Bool/or/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Bool/show/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.show True
− tests/normalization/examples/Bool/show/0B.dhall 
@@ -1,1 +0,0 @@-"True"
− tests/normalization/examples/Bool/show/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.show False
− tests/normalization/examples/Bool/show/1B.dhall 
@@ -1,1 +0,0 @@-"False"
− tests/normalization/examples/Double/show/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Double`.show -3.1
− tests/normalization/examples/Double/show/0B.dhall 
@@ -1,1 +0,0 @@-"-3.1"
− tests/normalization/examples/Double/show/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Double`.show 0.4
− tests/normalization/examples/Double/show/1B.dhall 
@@ -1,1 +0,0 @@-"0.4"
− tests/normalization/examples/Integer/show/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Integer`.show -3
− tests/normalization/examples/Integer/show/0B.dhall 
@@ -1,1 +0,0 @@-"-3"
− tests/normalization/examples/Integer/show/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Integer`.show +0
− tests/normalization/examples/Integer/show/1B.dhall 
@@ -1,1 +0,0 @@-"+0"
− tests/normalization/examples/Integer/toDouble/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Integer`.toDouble -3
− tests/normalization/examples/Integer/toDouble/0B.dhall 
@@ -1,1 +0,0 @@--3.0
− tests/normalization/examples/Integer/toDouble/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Integer`.toDouble +2
− tests/normalization/examples/Integer/toDouble/1B.dhall 
@@ -1,1 +0,0 @@-2.0
− tests/normalization/examples/List/all/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.all Natural Natural/even [ 2, 3, 5 ]
− tests/normalization/examples/List/all/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/List/all/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.all Natural Natural/even ([] : List Natural)
− tests/normalization/examples/List/all/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/List/any/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.any Natural Natural/even [ 2, 3, 5 ]
− tests/normalization/examples/List/any/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/List/any/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.any Natural Natural/even ([] : List Natural)
− tests/normalization/examples/List/any/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/List/build/0A.dhall 
@@ -1,7 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.build-Text-( λ(list : Type)-→ λ(cons : Text → list → list)-→ λ(nil : list)-→ cons "ABC" (cons "DEF" nil)-)
− tests/normalization/examples/List/build/0B.dhall 
@@ -1,1 +0,0 @@-[ "ABC", "DEF" ]
− tests/normalization/examples/List/build/1A.dhall 
@@ -1,7 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.build-Text-( λ(list : Type)-→ λ(cons : Text → list → list)-→ λ(nil : list)-→ nil-)
− tests/normalization/examples/List/build/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Text
− tests/normalization/examples/List/concat/0A.dhall 
@@ -1,5 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.concat Natural-[ [ 0, 1, 2 ]-, [ 3, 4 ]-, [ 5, 6, 7, 8 ]-]
− tests/normalization/examples/List/concat/0B.dhall 
@@ -1,1 +0,0 @@-[ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]
− tests/normalization/examples/List/concat/1A.dhall 
@@ -1,5 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.concat Natural-[ [] : List Natural-, [] : List Natural-, [] : List Natural-]
− tests/normalization/examples/List/concat/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/examples/List/concatMap/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.concatMap Natural Natural (λ(n : Natural) → [ n, n ]) [ 2, 3, 5 ]
− tests/normalization/examples/List/concatMap/0B.dhall 
@@ -1,1 +0,0 @@-[ 2, 2, 3, 3, 5, 5 ]
− tests/normalization/examples/List/concatMap/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.concatMap Natural Natural (λ(n : Natural) → [ n, n ]) ([] : List Natural)
− tests/normalization/examples/List/concatMap/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/examples/List/filter/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.filter Natural Natural/even [ 2, 3, 5 ]
− tests/normalization/examples/List/filter/0B.dhall 
@@ -1,1 +0,0 @@-[ 2 ]
− tests/normalization/examples/List/filter/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.filter Natural Natural/odd [ 2, 3, 5 ]
− tests/normalization/examples/List/filter/1B.dhall 
@@ -1,1 +0,0 @@-[ 3, 5 ]
− tests/normalization/examples/List/fold/0A.dhall 
@@ -1,6 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.fold-Natural-[ 2, 3, 5 ]-Natural-(λ(x : Natural) → λ(y : Natural) → x + y)-0
− tests/normalization/examples/List/fold/0B.dhall 
@@ -1,1 +0,0 @@-10
− tests/normalization/examples/List/fold/1A.dhall 
@@ -1,7 +0,0 @@-  λ(nil : Natural)-→ (../../../../../Prelude/package.dhall).`List`.fold-  Natural-  [ 2, 3, 5 ]-  Natural-  (λ(x : Natural) → λ(y : Natural) → x + y)-  nil
− tests/normalization/examples/List/fold/1B.dhall 
@@ -1,1 +0,0 @@-λ(nil : Natural) → 2 + (3 + (5 + nil))
− tests/normalization/examples/List/fold/2A.dhall 
@@ -1,4 +0,0 @@-  λ(list : Type)-→ λ(cons : Natural → list → list)-→ λ(nil : list)-→ (../../../../../Prelude/package.dhall).`List`.fold Natural [ 2, 3, 5 ] list cons nil
− tests/normalization/examples/List/fold/2B.dhall 
@@ -1,4 +0,0 @@-  λ(list : Type)-→ λ(cons : Natural → list → list)-→ λ(nil : list)-→ cons 2 (cons 3 (cons 5 nil))
− tests/normalization/examples/List/generate/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.generate 5 Bool Natural/even
− tests/normalization/examples/List/generate/0B.dhall 
@@ -1,1 +0,0 @@-[ True, False, True, False, True ]
− tests/normalization/examples/List/generate/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.generate 0 Bool Natural/even
− tests/normalization/examples/List/generate/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Bool
− tests/normalization/examples/List/head/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.head Natural [ 0, 1, 2 ]
− tests/normalization/examples/List/head/0B.dhall 
@@ -1,1 +0,0 @@-Some 0
− tests/normalization/examples/List/head/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.head Natural ([] : List Natural)
− tests/normalization/examples/List/head/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/examples/List/indexed/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.indexed Bool [ True, False, True ]
− tests/normalization/examples/List/indexed/0B.dhall 
@@ -1,4 +0,0 @@-[ { index = 0, value = True }-, { index = 1, value = False }-, { index = 2, value = True }-]
− tests/normalization/examples/List/indexed/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.indexed Bool ([] : List Bool)
− tests/normalization/examples/List/indexed/1B.dhall 
@@ -1,1 +0,0 @@-[] : List { index : Natural, value : Bool }
− tests/normalization/examples/List/iterate/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.iterate 10 Natural (λ(x : Natural) → x * 2) 1
− tests/normalization/examples/List/iterate/0B.dhall 
@@ -1,1 +0,0 @@-[ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 ]
− tests/normalization/examples/List/iterate/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.iterate 0 Natural (λ(x : Natural) → x * 2) 1
− tests/normalization/examples/List/iterate/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/examples/List/last/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.last Natural [ 0, 1, 2 ]
− tests/normalization/examples/List/last/0B.dhall 
@@ -1,1 +0,0 @@-Some 2
− tests/normalization/examples/List/last/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.last Natural ([] : List Natural)
− tests/normalization/examples/List/last/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/examples/List/length/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.length Natural [ 0, 1, 2 ]
− tests/normalization/examples/List/length/0B.dhall 
@@ -1,1 +0,0 @@-3
− tests/normalization/examples/List/length/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.length Natural ([] : List Natural)
− tests/normalization/examples/List/length/1B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/examples/List/map/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.map Natural Bool Natural/even [ 2, 3, 5 ]
− tests/normalization/examples/List/map/0B.dhall 
@@ -1,1 +0,0 @@-[ True, False, False ]
− tests/normalization/examples/List/map/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.map Natural Bool Natural/even ([] : List Natural)
− tests/normalization/examples/List/map/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Bool
− tests/normalization/examples/List/null/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.null Natural [ 0, 1, 2 ]
− tests/normalization/examples/List/null/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/List/null/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.null Natural ([] : List Natural)
− tests/normalization/examples/List/null/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/List/replicate/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.replicate 9 Natural 1
− tests/normalization/examples/List/replicate/0B.dhall 
@@ -1,1 +0,0 @@-[ 1, 1, 1, 1, 1, 1, 1, 1, 1 ]
− tests/normalization/examples/List/replicate/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.replicate 0 Natural 1
− tests/normalization/examples/List/replicate/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/examples/List/reverse/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.reverse Natural [ 0, 1, 2 ]
− tests/normalization/examples/List/reverse/0B.dhall 
@@ -1,1 +0,0 @@-[ 2, 1, 0 ]
− tests/normalization/examples/List/reverse/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.reverse Natural ([] : List Natural)
− tests/normalization/examples/List/reverse/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/examples/List/shifted/0A.dhall 
@@ -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 }-  ]-]
− tests/normalization/examples/List/shifted/0B.dhall 
@@ -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 }-]
− tests/normalization/examples/List/shifted/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.shifted Bool ([] : List (List { index : Natural, value : Bool }))
− tests/normalization/examples/List/shifted/1B.dhall 
@@ -1,1 +0,0 @@-[] : List { index : Natural, value : Bool }
− tests/normalization/examples/List/unzip/0A.dhall 
@@ -1,7 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.unzip-Text-Bool-[ { _1 = "ABC", _2 = True }-, { _1 = "DEF", _2 = False }-, { _1 = "GHI", _2 = True }-]
− tests/normalization/examples/List/unzip/0B.dhall 
@@ -1,1 +0,0 @@-{ _1 = [ "ABC", "DEF", "GHI" ], _2 = [ True, False, True ] }
− tests/normalization/examples/List/unzip/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.unzip Text Bool ([] : List { _1 : Text, _2 : Bool })
− tests/normalization/examples/List/unzip/1B.dhall 
@@ -1,1 +0,0 @@-{ _1 = [] : List Text, _2 = [] : List Bool }
− tests/normalization/examples/Natural/build/0A.dhall 
@@ -1,6 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.build-( λ(natural : Type)-→ λ(succ : natural → natural)-→ λ(zero : natural)-→ succ (succ (succ zero))-)
− tests/normalization/examples/Natural/build/0B.dhall 
@@ -1,1 +0,0 @@-3
− tests/normalization/examples/Natural/build/1A.dhall 
@@ -1,6 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.build-( λ(natural : Type)-→ λ(succ : natural → natural)-→ λ(zero : natural)-→ zero-)
− tests/normalization/examples/Natural/build/1B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/examples/Natural/enumerate/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.enumerate 10
− tests/normalization/examples/Natural/enumerate/0B.dhall 
@@ -1,1 +0,0 @@-[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
− tests/normalization/examples/Natural/enumerate/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.enumerate 0
− tests/normalization/examples/Natural/enumerate/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/examples/Natural/even/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.even 3
− tests/normalization/examples/Natural/even/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Natural/even/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.even 0
− tests/normalization/examples/Natural/even/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Natural/fold/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.fold 3 Natural (λ(x : Natural) → 5 * x) 1
− tests/normalization/examples/Natural/fold/0B.dhall 
@@ -1,1 +0,0 @@-125
− tests/normalization/examples/Natural/fold/1A.dhall 
@@ -1,1 +0,0 @@-λ(zero : Natural) → (../../../../../Prelude/package.dhall).`Natural`.fold 3 Natural (λ(x : Natural) → 5 * x) zero
− tests/normalization/examples/Natural/fold/1B.dhall 
@@ -1,1 +0,0 @@-λ(zero : Natural) → 5 * (5 * (5 * zero))
− tests/normalization/examples/Natural/fold/2A.dhall 
@@ -1,4 +0,0 @@-  λ(natural : Type)-→ λ(succ : natural → natural)-→ λ(zero : natural)-→ (../../../../../Prelude/package.dhall).`Natural`.fold 3 natural succ zero
− tests/normalization/examples/Natural/fold/2B.dhall 
@@ -1,1 +0,0 @@-λ(natural : Type) → λ(succ : natural → natural) → λ(zero : natural) → succ (succ (succ zero))
− tests/normalization/examples/Natural/isZero/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.isZero 2
− tests/normalization/examples/Natural/isZero/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Natural/isZero/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.isZero 0
− tests/normalization/examples/Natural/isZero/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Natural/odd/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.odd 3
− tests/normalization/examples/Natural/odd/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Natural/odd/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.odd 0
− tests/normalization/examples/Natural/odd/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Natural/product/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.product [ 2, 3, 5 ]
− tests/normalization/examples/Natural/product/0B.dhall 
@@ -1,1 +0,0 @@-30
− tests/normalization/examples/Natural/product/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.product ([] : List Natural)
− tests/normalization/examples/Natural/product/1B.dhall 
@@ -1,1 +0,0 @@-1
− tests/normalization/examples/Natural/show/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.show 3
− tests/normalization/examples/Natural/show/0B.dhall 
@@ -1,1 +0,0 @@-"3"
− tests/normalization/examples/Natural/show/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.show 0
− tests/normalization/examples/Natural/show/1B.dhall 
@@ -1,1 +0,0 @@-"0"
− tests/normalization/examples/Natural/sum/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.sum [ 2, 3, 5 ]
− tests/normalization/examples/Natural/sum/0B.dhall 
@@ -1,1 +0,0 @@-10
− tests/normalization/examples/Natural/sum/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.sum ([] : List Natural)
− tests/normalization/examples/Natural/sum/1B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/examples/Natural/toDouble/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.toDouble 3
− tests/normalization/examples/Natural/toDouble/0B.dhall 
@@ -1,1 +0,0 @@-3.0
− tests/normalization/examples/Natural/toDouble/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.toDouble 0
− tests/normalization/examples/Natural/toDouble/1B.dhall 
@@ -1,1 +0,0 @@-0.0
− tests/normalization/examples/Natural/toInteger/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.toInteger 3
− tests/normalization/examples/Natural/toInteger/0B.dhall 
@@ -1,1 +0,0 @@-+3
− tests/normalization/examples/Natural/toInteger/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.toInteger 0
− tests/normalization/examples/Natural/toInteger/1B.dhall 
@@ -1,1 +0,0 @@-+0
− tests/normalization/examples/Optional/all/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (Some 3)
− tests/normalization/examples/Optional/all/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Optional/all/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (None Natural)
− tests/normalization/examples/Optional/all/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Optional/any/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (Some 2)
− tests/normalization/examples/Optional/any/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Optional/any/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (None Natural)
− tests/normalization/examples/Optional/any/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Optional/build/0A.dhall 
@@ -1,7 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.build-Natural-( λ(optional : Type)-→ λ(some : Natural → optional)-→ λ(none : optional)-→ some 1-)
− tests/normalization/examples/Optional/build/0B.dhall 
@@ -1,1 +0,0 @@-Some 1
− tests/normalization/examples/Optional/build/1A.dhall 
@@ -1,7 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.build-Natural-( λ(optional : Type)-→ λ(some : Natural → optional)-→ λ(none : optional)-→ none-)
− tests/normalization/examples/Optional/build/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/examples/Optional/concat/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (Some 1))
− tests/normalization/examples/Optional/concat/0B.dhall 
@@ -1,1 +0,0 @@-Some 1
− tests/normalization/examples/Optional/concat/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (None Natural))
− tests/normalization/examples/Optional/concat/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/examples/Optional/concat/2A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.concat Natural (None (Optional Natural))
− tests/normalization/examples/Optional/concat/2B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/examples/Optional/filter/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/even (Some 2)
− tests/normalization/examples/Optional/filter/0B.dhall 
@@ -1,1 +0,0 @@-Some 2
− tests/normalization/examples/Optional/filter/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/odd (Some 2)
− tests/normalization/examples/Optional/filter/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/examples/Optional/fold/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.fold Natural (Some 2) Natural (λ(x : Natural) → x) 0
− tests/normalization/examples/Optional/fold/0B.dhall 
@@ -1,1 +0,0 @@-2
− tests/normalization/examples/Optional/fold/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.fold Natural (None Natural) Natural (λ(x : Natural) → x) 0
− tests/normalization/examples/Optional/fold/1B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/examples/Optional/head/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.head Natural [ None Natural, Some 1, Some 2 ]
− tests/normalization/examples/Optional/head/0B.dhall 
@@ -1,1 +0,0 @@-Some 1
− tests/normalization/examples/Optional/head/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.head Natural [ None Natural, None Natural ]
− tests/normalization/examples/Optional/head/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/examples/Optional/head/2A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.head Natural ([] : List (Optional Natural))
− tests/normalization/examples/Optional/head/2B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/examples/Optional/last/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.last Natural [ None Natural, Some 1, Some 2 ]
− tests/normalization/examples/Optional/last/0B.dhall 
@@ -1,1 +0,0 @@-Some 2
− tests/normalization/examples/Optional/last/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.last Natural [ None Natural, None Natural ]
− tests/normalization/examples/Optional/last/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/examples/Optional/last/2A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.last Natural ([] : List (Optional Natural))
− tests/normalization/examples/Optional/last/2B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/examples/Optional/length/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.length Natural (Some 2)
− tests/normalization/examples/Optional/length/0B.dhall 
@@ -1,1 +0,0 @@-1
− tests/normalization/examples/Optional/length/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.length Natural (None Natural)
− tests/normalization/examples/Optional/length/1B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/examples/Optional/map/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (Some 3)
− tests/normalization/examples/Optional/map/0B.dhall 
@@ -1,1 +0,0 @@-Some False
− tests/normalization/examples/Optional/map/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (None Natural)
− tests/normalization/examples/Optional/map/1B.dhall 
@@ -1,1 +0,0 @@-None Bool
− tests/normalization/examples/Optional/null/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.null Natural (Some 2)
− tests/normalization/examples/Optional/null/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/examples/Optional/null/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.null Natural (None Natural)
− tests/normalization/examples/Optional/null/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/examples/Optional/toList/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.toList Natural (Some 1)
− tests/normalization/examples/Optional/toList/0B.dhall 
@@ -1,1 +0,0 @@-[ 1 ] : List Natural
− tests/normalization/examples/Optional/toList/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.toList Natural (None Natural)
− tests/normalization/examples/Optional/toList/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/examples/Optional/unzip/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.unzip Text Bool (Some { _1 = "ABC", _2 = True })
− tests/normalization/examples/Optional/unzip/0B.dhall 
@@ -1,1 +0,0 @@-{ _1 = Some "ABC", _2 = Some True }
− tests/normalization/examples/Optional/unzip/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.unzip Text Bool (None { _1 : Text, _2 : Bool })
− tests/normalization/examples/Optional/unzip/1B.dhall 
@@ -1,1 +0,0 @@-{ _1 = None Text, _2 = None Bool }
− tests/normalization/examples/Text/concat/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Text`.concat [ "ABC", "DEF", "GHI" ]
− tests/normalization/examples/Text/concat/0B.dhall 
@@ -1,1 +0,0 @@-"ABCDEFGHI"
− tests/normalization/examples/Text/concat/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Text`.concat ([] : List Text)
− tests/normalization/examples/Text/concat/1B.dhall 
@@ -1,1 +0,0 @@-""
− tests/normalization/examples/Text/concatMap/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Text`.concatMap Natural (λ(n : Natural) → "${Natural/show n} ") [ 0, 1, 2 ]
− tests/normalization/examples/Text/concatMap/0B.dhall 
@@ -1,1 +0,0 @@-"0 1 2 "
− tests/normalization/examples/Text/concatMap/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Text`.concatMap Natural (λ(n : Natural) → "${Natural/show n} ") ([] : List Natural)
− tests/normalization/examples/Text/concatMap/1B.dhall 
@@ -1,1 +0,0 @@-""
− tests/normalization/examples/Text/concatMapSep/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show [ 0, 1, 2 ]
− tests/normalization/examples/Text/concatMapSep/0B.dhall 
@@ -1,1 +0,0 @@-"0, 1, 2"
− tests/normalization/examples/Text/concatMapSep/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show ([] : List Natural)
− tests/normalization/examples/Text/concatMapSep/1B.dhall 
@@ -1,1 +0,0 @@-""
− tests/normalization/examples/Text/concatSep/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Text`.concatSep ", " [ "ABC", "DEF", "GHI" ]
− tests/normalization/examples/Text/concatSep/0B.dhall 
@@ -1,1 +0,0 @@-"ABC, DEF, GHI"
− tests/normalization/examples/Text/concatSep/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Text`.concatSep ", " ([] : List Text)
− tests/normalization/examples/Text/concatSep/1B.dhall 
@@ -1,1 +0,0 @@-""
− tests/normalization/integerShowA.dhall 
@@ -1,4 +0,0 @@-{ example0 = Integer/show +1337-, example1 = Integer/show -42-, example2 = Integer/show +0-}
− tests/normalization/integerShowB.dhall 
@@ -1,1 +0,0 @@-{ example0 = "+1337", example1 = "-42", example2 = "+0" }
− tests/normalization/listBuildA.dhall 
@@ -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))-      )-}
− tests/normalization/listBuildB.dhall 
@@ -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 ]-}
− tests/normalization/multiLineA.dhall 
@@ -1,4 +0,0 @@-''- foo-bar-''
− tests/normalization/multiLineB.dhall 
@@ -1,4 +0,0 @@-''- foo-bar-''
− tests/normalization/naturalBuildA.dhall 
@@ -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)-      )-}
− tests/normalization/naturalBuildB.dhall 
@@ -1,7 +0,0 @@-{ example0 =-    1-, example1 =-    1-, example2 =-    λ(id : ∀(a : Type) → a → a) → id Natural 1-}
− tests/normalization/naturalPlusA.dhall 
@@ -1,1 +0,0 @@-1 + 2
− tests/normalization/naturalPlusB.dhall 
@@ -1,1 +0,0 @@-3
− tests/normalization/naturalShowA.dhall 
@@ -1,1 +0,0 @@-Natural/show 42
− tests/normalization/naturalShowB.dhall 
@@ -1,1 +0,0 @@-"42"
− tests/normalization/naturalToIntegerA.dhall 
@@ -1,1 +0,0 @@-Natural/toInteger 1
− tests/normalization/naturalToIntegerB.dhall 
@@ -1,1 +0,0 @@-+1
− tests/normalization/optionalBuildA.dhall 
@@ -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-      )-}
− tests/normalization/optionalBuildB.dhall 
@@ -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-}
− tests/normalization/optionalBuildFoldA.dhall 
@@ -1,1 +0,0 @@-Optional/build Text (Optional/fold Text ([ "foo" ] : Optional Text))
− tests/normalization/optionalBuildFoldB.dhall 
@@ -1,1 +0,0 @@-[ "foo" ] : Optional Text
− tests/normalization/optionalFoldA.dhall 
@@ -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)-    }
− tests/normalization/optionalFoldB.dhall 
@@ -1,1 +0,0 @@-{ example0 = 1, example1 = 2 }
− tests/normalization/remoteSystemsA.dhall 
@@ -1,55 +0,0 @@-    let Text/concatMap =-(          ../../Prelude/package.dhall).`Text`.concatMap --in  let Text/concatSep =-(          ../../Prelude/package.dhall).`Text`.concatSep --in  let Row =-          { cores :-              Natural-          , host :-              Text-          , key :-              Text-          , mandatoryFeatures :-              List Text-          , platforms :-              List Text-          , speedFactor :-              Natural-          , supportedFeatures :-              List Text-          , user :-              Optional Text-          }--in  let renderRow =-            λ ( row-              : Row-              )-          →     let host =-                      Optional/fold-                      Text-                      row.user-                      Text-                      (λ(user : Text) → "${user}@${row.host}")-                      row.host-            -            in  let platforms = Text/concatSep "," row.platforms-            -            in  let key = row.key-            -            in  let cores = Integer/show (Natural/toInteger row.cores)-            -            in  let speedFactor =-                      Integer/show (Natural/toInteger row.speedFactor)-            -            in  let supportedFeatures = Text/concatSep "," row.supportedFeatures-            -            in  let mandatoryFeatures = Text/concatSep "," row.mandatoryFeatures-            -            in  ''-                ${host} ${platforms} ${key} ${cores} ${speedFactor} ${supportedFeatures} ${mandatoryFeatures}-                ''--in  Text/concatMap Row renderRow
− tests/normalization/remoteSystemsB.dhall 
@@ -1,1 +0,0 @@-λ(xs : List { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text }) → List/fold { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text } xs Text (λ(x : { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text }) → λ(y : Text) → "${Optional/fold Text x.user Text (λ(user : Text) → "${user}@${x.host}") x.host} ${merge { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } (List/fold Text x.platforms < Empty : {} | NonEmpty : Text > (λ(element : Text) → λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → < NonEmpty = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : Text} ${x.key} ${Integer/show (Natural/toInteger x.cores)} ${Integer/show (Natural/toInteger x.speedFactor)} ${merge { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } (List/fold Text x.supportedFeatures < Empty : {} | NonEmpty : Text > (λ(element : Text) → λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → < NonEmpty = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : Text} ${merge { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } (List/fold Text x.mandatoryFeatures < Empty : {} | NonEmpty : Text > (λ(element : Text) → λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → < NonEmpty = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : Text}\n" ++ y) ""
− tests/normalization/simplifications/andA.dhall 
@@ -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-}
− tests/normalization/simplifications/andB.dhall 
@@ -1,6 +0,0 @@-{ example0 = λ(x : Bool) → x-, example1 = λ(x : Bool) → x-, example2 = λ(x : Bool) → False-, example3 = λ(x : Bool) → False-, example4 = λ(x : Bool) → x-}
− tests/normalization/simplifications/eqA.dhall 
@@ -1,4 +0,0 @@-{ example0 = λ(x : Bool) → x == True-, example1 = λ(x : Bool) → True == x-, example2 = λ(x : Bool) → x == x-}
− tests/normalization/simplifications/eqB.dhall 
@@ -1,4 +0,0 @@-{ example0 = λ(x : Bool) → x-, example1 = λ(x : Bool) → x-, example2 = λ(x : Bool) → True-}
− tests/normalization/simplifications/ifThenElseA.dhall 
@@ -1,3 +0,0 @@-{ example0 = λ(x : Bool) → if x then True else False-, example1 = λ(x : Bool) → λ(y : Text) → if x then y else y-}
− tests/normalization/simplifications/ifThenElseB.dhall 
@@ -1,3 +0,0 @@-{ example0 = λ(x : Bool) → x-, example1 = λ(x : Bool) → λ(y : Text) → y-}
− tests/normalization/simplifications/neA.dhall 
@@ -1,4 +0,0 @@-{ example0 = λ(x : Bool) → x != False-, example1 = λ(x : Bool) → False != x-, example2 = λ(x : Bool) → x != x-}
− tests/normalization/simplifications/neB.dhall 
@@ -1,4 +0,0 @@-{ example0 = λ(x : Bool) → x-, example1 = λ(x : Bool) → x-, example2 = λ(x : Bool) → False-}
− tests/normalization/simplifications/orA.dhall 
@@ -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-}
− tests/normalization/simplifications/orB.dhall 
@@ -1,6 +0,0 @@-{ example0 = λ(x : Bool) → True-, example1 = λ(x : Bool) → True-, example2 = λ(x : Bool) → x-, example3 = λ(x : Bool) → x-, example4 = λ(x : Bool) → x-}
− tests/normalization/sortOperatorA.dhall 
@@ -1,1 +0,0 @@-{ b = 2 } // { a = 1 }
− tests/normalization/sortOperatorB.dhall 
@@ -1,1 +0,0 @@-{ a = 1, b = 2 }
+ tests/normalization/success/haskell-tutorial/access/0A.dhall view
@@ -0,0 +1,1 @@+{ x = "foo" }.x
+ tests/normalization/success/haskell-tutorial/access/0B.dhall view
@@ -0,0 +1,1 @@+"foo"
+ tests/normalization/success/haskell-tutorial/access/1A.dhall view
@@ -0,0 +1,1 @@+< Foo : Text | Bar : Natural >.Foo
+ tests/normalization/success/haskell-tutorial/access/1B.dhall view
@@ -0,0 +1,1 @@+λ(Foo : Text) → < Foo = Foo | Bar : Natural >
+ tests/normalization/success/haskell-tutorial/combineTypes/0A.dhall view
@@ -0,0 +1,1 @@+{ foo : { bar : Text } } ⩓ { foo : { baz : Bool }, qux : Integer }
+ tests/normalization/success/haskell-tutorial/combineTypes/0B.dhall view
@@ -0,0 +1,1 @@+{ foo : { bar : Text, baz : Bool }, qux : Integer }
+ tests/normalization/success/haskell-tutorial/combineTypes/1A.dhall view
@@ -0,0 +1,1 @@+{ foo : { bar : Text } } //\\ { foo : { baz : Bool }, qux : Integer }
+ tests/normalization/success/haskell-tutorial/combineTypes/1B.dhall view
@@ -0,0 +1,1 @@+{ foo : { bar : Text, baz : Bool }, qux : Integer }
+ tests/normalization/success/haskell-tutorial/prefer/0A.dhall view
@@ -0,0 +1,1 @@+{ foo = 1, bar = "ABC" } // { baz = True }
+ tests/normalization/success/haskell-tutorial/prefer/0B.dhall view
@@ -0,0 +1,1 @@+{ bar = "ABC", baz = True, foo = 1 }
+ tests/normalization/success/haskell-tutorial/projection/0A.dhall view
@@ -0,0 +1,1 @@+{ x = 1, y = True, z = "ABC" }.{ x, y }
+ tests/normalization/success/haskell-tutorial/projection/0B.dhall view
@@ -0,0 +1,1 @@+{ x = 1, y = True }
+ tests/normalization/success/prelude/Bool/and/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.and [ True, False, True ]
+ tests/normalization/success/prelude/Bool/and/0B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Bool/and/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.and ([] : List Bool)
+ tests/normalization/success/prelude/Bool/and/1B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Bool/build/0A.dhall view
@@ -0,0 +1,2 @@+(../../../../../../Prelude/package.dhall).`Bool`.build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → true)
+ tests/normalization/success/prelude/Bool/build/0B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Bool/build/1A.dhall view
@@ -0,0 +1,2 @@+(../../../../../../Prelude/package.dhall).`Bool`.build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → false)
+ tests/normalization/success/prelude/Bool/build/1B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Bool/even/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.even [ False, True, False ]
+ tests/normalization/success/prelude/Bool/even/0B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Bool/even/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.even [ False, True ]
+ tests/normalization/success/prelude/Bool/even/1B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Bool/even/2A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.even [ False ]
+ tests/normalization/success/prelude/Bool/even/2B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Bool/even/3A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.even ([] : List Bool)
+ tests/normalization/success/prelude/Bool/even/3B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Bool/fold/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.fold True Natural 0 1
+ tests/normalization/success/prelude/Bool/fold/0B.dhall view
@@ -0,0 +1,1 @@+0
+ tests/normalization/success/prelude/Bool/fold/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.fold False Natural 0 1
+ tests/normalization/success/prelude/Bool/fold/1B.dhall view
@@ -0,0 +1,1 @@+1
+ tests/normalization/success/prelude/Bool/not/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.not True
+ tests/normalization/success/prelude/Bool/not/0B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Bool/not/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.not False
+ tests/normalization/success/prelude/Bool/not/1B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Bool/odd/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.odd [ True, False, True ]
+ tests/normalization/success/prelude/Bool/odd/0B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Bool/odd/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.odd [ True, False ]
+ tests/normalization/success/prelude/Bool/odd/1B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Bool/odd/2A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.odd [ True ]
+ tests/normalization/success/prelude/Bool/odd/2B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Bool/odd/3A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.odd ([] : List Bool)
+ tests/normalization/success/prelude/Bool/odd/3B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Bool/or/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.or [ True, False, True ]
+ tests/normalization/success/prelude/Bool/or/0B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Bool/or/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.or ([] : List Bool)
+ tests/normalization/success/prelude/Bool/or/1B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Bool/show/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.show True
+ tests/normalization/success/prelude/Bool/show/0B.dhall view
@@ -0,0 +1,1 @@+"True"
+ tests/normalization/success/prelude/Bool/show/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.show False
+ tests/normalization/success/prelude/Bool/show/1B.dhall view
@@ -0,0 +1,1 @@+"False"
+ tests/normalization/success/prelude/Double/show/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Double`.show -3.1
+ tests/normalization/success/prelude/Double/show/0B.dhall view
@@ -0,0 +1,1 @@+"-3.1"
+ tests/normalization/success/prelude/Double/show/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Double`.show 0.4
+ tests/normalization/success/prelude/Double/show/1B.dhall view
@@ -0,0 +1,1 @@+"0.4"
+ tests/normalization/success/prelude/Integer/show/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Integer`.show -3
+ tests/normalization/success/prelude/Integer/show/0B.dhall view
@@ -0,0 +1,1 @@+"-3"
+ tests/normalization/success/prelude/Integer/show/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Integer`.show +0
+ tests/normalization/success/prelude/Integer/show/1B.dhall view
@@ -0,0 +1,1 @@+"+0"
+ tests/normalization/success/prelude/Integer/toDouble/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Integer`.toDouble -3
+ tests/normalization/success/prelude/Integer/toDouble/0B.dhall view
@@ -0,0 +1,1 @@+-3.0
+ tests/normalization/success/prelude/Integer/toDouble/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Integer`.toDouble +2
+ tests/normalization/success/prelude/Integer/toDouble/1B.dhall view
@@ -0,0 +1,1 @@+2.0
+ tests/normalization/success/prelude/List/all/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.all Natural Natural/even [ 2, 3, 5 ]
+ tests/normalization/success/prelude/List/all/0B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/List/all/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.all Natural Natural/even ([] : List Natural)
+ tests/normalization/success/prelude/List/all/1B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/List/any/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.any Natural Natural/even [ 2, 3, 5 ]
+ tests/normalization/success/prelude/List/any/0B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/List/any/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.any Natural Natural/even ([] : List Natural)
+ tests/normalization/success/prelude/List/any/1B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/List/build/0A.dhall view
@@ -0,0 +1,7 @@+(../../../../../../Prelude/package.dhall).`List`.build+Text+( λ(list : Type)+→ λ(cons : Text → list → list)+→ λ(nil : list)+→ cons "ABC" (cons "DEF" nil)+)
+ tests/normalization/success/prelude/List/build/0B.dhall view
@@ -0,0 +1,1 @@+[ "ABC", "DEF" ]
+ tests/normalization/success/prelude/List/build/1A.dhall view
@@ -0,0 +1,7 @@+(../../../../../../Prelude/package.dhall).`List`.build+Text+( λ(list : Type)+→ λ(cons : Text → list → list)+→ λ(nil : list)+→ nil+)
+ tests/normalization/success/prelude/List/build/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Text
+ tests/normalization/success/prelude/List/concat/0A.dhall view
@@ -0,0 +1,5 @@+(../../../../../../Prelude/package.dhall).`List`.concat Natural+[ [ 0, 1, 2 ]+, [ 3, 4 ]+, [ 5, 6, 7, 8 ]+]
+ tests/normalization/success/prelude/List/concat/0B.dhall view
@@ -0,0 +1,1 @@+[ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]
+ tests/normalization/success/prelude/List/concat/1A.dhall view
@@ -0,0 +1,5 @@+(../../../../../../Prelude/package.dhall).`List`.concat Natural+[ [] : List Natural+, [] : List Natural+, [] : List Natural+]
+ tests/normalization/success/prelude/List/concat/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ tests/normalization/success/prelude/List/concatMap/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.concatMap Natural Natural (λ(n : Natural) → [ n, n ]) [ 2, 3, 5 ]
+ tests/normalization/success/prelude/List/concatMap/0B.dhall view
@@ -0,0 +1,1 @@+[ 2, 2, 3, 3, 5, 5 ]
+ tests/normalization/success/prelude/List/concatMap/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.concatMap Natural Natural (λ(n : Natural) → [ n, n ]) ([] : List Natural)
+ tests/normalization/success/prelude/List/concatMap/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ tests/normalization/success/prelude/List/filter/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.filter Natural Natural/even [ 2, 3, 5 ]
+ tests/normalization/success/prelude/List/filter/0B.dhall view
@@ -0,0 +1,1 @@+[ 2 ]
+ tests/normalization/success/prelude/List/filter/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.filter Natural Natural/odd [ 2, 3, 5 ]
+ tests/normalization/success/prelude/List/filter/1B.dhall view
@@ -0,0 +1,1 @@+[ 3, 5 ]
+ tests/normalization/success/prelude/List/fold/0A.dhall view
@@ -0,0 +1,6 @@+(../../../../../../Prelude/package.dhall).`List`.fold+Natural+[ 2, 3, 5 ]+Natural+(λ(x : Natural) → λ(y : Natural) → x + y)+0
+ tests/normalization/success/prelude/List/fold/0B.dhall view
@@ -0,0 +1,1 @@+10
+ tests/normalization/success/prelude/List/fold/1A.dhall view
@@ -0,0 +1,7 @@+  λ(nil : Natural)+→ (../../../../../../Prelude/package.dhall).`List`.fold+  Natural+  [ 2, 3, 5 ]+  Natural+  (λ(x : Natural) → λ(y : Natural) → x + y)+  nil
+ tests/normalization/success/prelude/List/fold/1B.dhall view
@@ -0,0 +1,1 @@+λ(nil : Natural) → 2 + (3 + (5 + nil))
+ tests/normalization/success/prelude/List/fold/2A.dhall view
@@ -0,0 +1,4 @@+  λ(list : Type)+→ λ(cons : Natural → list → list)+→ λ(nil : list)+→ (../../../../../../Prelude/package.dhall).`List`.fold Natural [ 2, 3, 5 ] list cons nil
+ tests/normalization/success/prelude/List/fold/2B.dhall view
@@ -0,0 +1,4 @@+  λ(list : Type)+→ λ(cons : Natural → list → list)+→ λ(nil : list)+→ cons 2 (cons 3 (cons 5 nil))
+ tests/normalization/success/prelude/List/generate/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.generate 5 Bool Natural/even
+ tests/normalization/success/prelude/List/generate/0B.dhall view
@@ -0,0 +1,1 @@+[ True, False, True, False, True ]
+ tests/normalization/success/prelude/List/generate/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.generate 0 Bool Natural/even
+ tests/normalization/success/prelude/List/generate/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Bool
+ tests/normalization/success/prelude/List/head/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.head Natural [ 0, 1, 2 ]
+ tests/normalization/success/prelude/List/head/0B.dhall view
@@ -0,0 +1,1 @@+Some 0
+ tests/normalization/success/prelude/List/head/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.head Natural ([] : List Natural)
+ tests/normalization/success/prelude/List/head/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ tests/normalization/success/prelude/List/indexed/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.indexed Bool [ True, False, True ]
+ tests/normalization/success/prelude/List/indexed/0B.dhall view
@@ -0,0 +1,4 @@+[ { index = 0, value = True }+, { index = 1, value = False }+, { index = 2, value = True }+]
+ tests/normalization/success/prelude/List/indexed/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.indexed Bool ([] : List Bool)
+ tests/normalization/success/prelude/List/indexed/1B.dhall view
@@ -0,0 +1,1 @@+[] : List { index : Natural, value : Bool }
+ tests/normalization/success/prelude/List/iterate/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.iterate 10 Natural (λ(x : Natural) → x * 2) 1
+ tests/normalization/success/prelude/List/iterate/0B.dhall view
@@ -0,0 +1,1 @@+[ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 ]
+ tests/normalization/success/prelude/List/iterate/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.iterate 0 Natural (λ(x : Natural) → x * 2) 1
+ tests/normalization/success/prelude/List/iterate/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ tests/normalization/success/prelude/List/last/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.last Natural [ 0, 1, 2 ]
+ tests/normalization/success/prelude/List/last/0B.dhall view
@@ -0,0 +1,1 @@+Some 2
+ tests/normalization/success/prelude/List/last/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.last Natural ([] : List Natural)
+ tests/normalization/success/prelude/List/last/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ tests/normalization/success/prelude/List/length/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.length Natural [ 0, 1, 2 ]
+ tests/normalization/success/prelude/List/length/0B.dhall view
@@ -0,0 +1,1 @@+3
+ tests/normalization/success/prelude/List/length/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.length Natural ([] : List Natural)
+ tests/normalization/success/prelude/List/length/1B.dhall view
@@ -0,0 +1,1 @@+0
+ tests/normalization/success/prelude/List/map/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.map Natural Bool Natural/even [ 2, 3, 5 ]
+ tests/normalization/success/prelude/List/map/0B.dhall view
@@ -0,0 +1,1 @@+[ True, False, False ]
+ tests/normalization/success/prelude/List/map/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.map Natural Bool Natural/even ([] : List Natural)
+ tests/normalization/success/prelude/List/map/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Bool
+ tests/normalization/success/prelude/List/null/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.null Natural [ 0, 1, 2 ]
+ tests/normalization/success/prelude/List/null/0B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/List/null/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.null Natural ([] : List Natural)
+ tests/normalization/success/prelude/List/null/1B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/List/replicate/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.replicate 9 Natural 1
+ tests/normalization/success/prelude/List/replicate/0B.dhall view
@@ -0,0 +1,1 @@+[ 1, 1, 1, 1, 1, 1, 1, 1, 1 ]
+ tests/normalization/success/prelude/List/replicate/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.replicate 0 Natural 1
+ tests/normalization/success/prelude/List/replicate/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ tests/normalization/success/prelude/List/reverse/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.reverse Natural [ 0, 1, 2 ]
+ tests/normalization/success/prelude/List/reverse/0B.dhall view
@@ -0,0 +1,1 @@+[ 2, 1, 0 ]
+ tests/normalization/success/prelude/List/reverse/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.reverse Natural ([] : List Natural)
+ tests/normalization/success/prelude/List/reverse/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ tests/normalization/success/prelude/List/shifted/0A.dhall view
@@ -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 }+  ]+]
+ tests/normalization/success/prelude/List/shifted/0B.dhall view
@@ -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 }+]
+ tests/normalization/success/prelude/List/shifted/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.shifted Bool ([] : List (List { index : Natural, value : Bool }))
+ tests/normalization/success/prelude/List/shifted/1B.dhall view
@@ -0,0 +1,1 @@+[] : List { index : Natural, value : Bool }
+ tests/normalization/success/prelude/List/unzip/0A.dhall view
@@ -0,0 +1,7 @@+(../../../../../../Prelude/package.dhall).`List`.unzip+Text+Bool+[ { _1 = "ABC", _2 = True }+, { _1 = "DEF", _2 = False }+, { _1 = "GHI", _2 = True }+]
+ tests/normalization/success/prelude/List/unzip/0B.dhall view
@@ -0,0 +1,1 @@+{ _1 = [ "ABC", "DEF", "GHI" ], _2 = [ True, False, True ] }
+ tests/normalization/success/prelude/List/unzip/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.unzip Text Bool ([] : List { _1 : Text, _2 : Bool })
+ tests/normalization/success/prelude/List/unzip/1B.dhall view
@@ -0,0 +1,1 @@+{ _1 = [] : List Text, _2 = [] : List Bool }
+ tests/normalization/success/prelude/Natural/build/0A.dhall view
@@ -0,0 +1,6 @@+(../../../../../../Prelude/package.dhall).`Natural`.build+( λ(natural : Type)+→ λ(succ : natural → natural)+→ λ(zero : natural)+→ succ (succ (succ zero))+)
+ tests/normalization/success/prelude/Natural/build/0B.dhall view
@@ -0,0 +1,1 @@+3
+ tests/normalization/success/prelude/Natural/build/1A.dhall view
@@ -0,0 +1,6 @@+(../../../../../../Prelude/package.dhall).`Natural`.build+( λ(natural : Type)+→ λ(succ : natural → natural)+→ λ(zero : natural)+→ zero+)
+ tests/normalization/success/prelude/Natural/build/1B.dhall view
@@ -0,0 +1,1 @@+0
+ tests/normalization/success/prelude/Natural/enumerate/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.enumerate 10
+ tests/normalization/success/prelude/Natural/enumerate/0B.dhall view
@@ -0,0 +1,1 @@+[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
+ tests/normalization/success/prelude/Natural/enumerate/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.enumerate 0
+ tests/normalization/success/prelude/Natural/enumerate/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ tests/normalization/success/prelude/Natural/even/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.even 3
+ tests/normalization/success/prelude/Natural/even/0B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Natural/even/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.even 0
+ tests/normalization/success/prelude/Natural/even/1B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Natural/fold/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.fold 3 Natural (λ(x : Natural) → 5 * x) 1
+ tests/normalization/success/prelude/Natural/fold/0B.dhall view
@@ -0,0 +1,1 @@+125
+ tests/normalization/success/prelude/Natural/fold/1A.dhall view
@@ -0,0 +1,1 @@+λ(zero : Natural) → (../../../../../../Prelude/package.dhall).`Natural`.fold 3 Natural (λ(x : Natural) → 5 * x) zero
+ tests/normalization/success/prelude/Natural/fold/1B.dhall view
@@ -0,0 +1,1 @@+λ(zero : Natural) → 5 * (5 * (5 * zero))
+ tests/normalization/success/prelude/Natural/fold/2A.dhall view
@@ -0,0 +1,4 @@+  λ(natural : Type)+→ λ(succ : natural → natural)+→ λ(zero : natural)+→ (../../../../../../Prelude/package.dhall).`Natural`.fold 3 natural succ zero
+ tests/normalization/success/prelude/Natural/fold/2B.dhall view
@@ -0,0 +1,1 @@+λ(natural : Type) → λ(succ : natural → natural) → λ(zero : natural) → succ (succ (succ zero))
+ tests/normalization/success/prelude/Natural/isZero/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.isZero 2
+ tests/normalization/success/prelude/Natural/isZero/0B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Natural/isZero/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.isZero 0
+ tests/normalization/success/prelude/Natural/isZero/1B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Natural/odd/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.odd 3
+ tests/normalization/success/prelude/Natural/odd/0B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Natural/odd/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.odd 0
+ tests/normalization/success/prelude/Natural/odd/1B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Natural/product/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.product [ 2, 3, 5 ]
+ tests/normalization/success/prelude/Natural/product/0B.dhall view
@@ -0,0 +1,1 @@+30
+ tests/normalization/success/prelude/Natural/product/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.product ([] : List Natural)
+ tests/normalization/success/prelude/Natural/product/1B.dhall view
@@ -0,0 +1,1 @@+1
+ tests/normalization/success/prelude/Natural/show/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.show 3
+ tests/normalization/success/prelude/Natural/show/0B.dhall view
@@ -0,0 +1,1 @@+"3"
+ tests/normalization/success/prelude/Natural/show/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.show 0
+ tests/normalization/success/prelude/Natural/show/1B.dhall view
@@ -0,0 +1,1 @@+"0"
+ tests/normalization/success/prelude/Natural/sum/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.sum [ 2, 3, 5 ]
+ tests/normalization/success/prelude/Natural/sum/0B.dhall view
@@ -0,0 +1,1 @@+10
+ tests/normalization/success/prelude/Natural/sum/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.sum ([] : List Natural)
+ tests/normalization/success/prelude/Natural/sum/1B.dhall view
@@ -0,0 +1,1 @@+0
+ tests/normalization/success/prelude/Natural/toDouble/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.toDouble 3
+ tests/normalization/success/prelude/Natural/toDouble/0B.dhall view
@@ -0,0 +1,1 @@+3.0
+ tests/normalization/success/prelude/Natural/toDouble/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.toDouble 0
+ tests/normalization/success/prelude/Natural/toDouble/1B.dhall view
@@ -0,0 +1,1 @@+0.0
+ tests/normalization/success/prelude/Natural/toInteger/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.toInteger 3
+ tests/normalization/success/prelude/Natural/toInteger/0B.dhall view
@@ -0,0 +1,1 @@++3
+ tests/normalization/success/prelude/Natural/toInteger/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.toInteger 0
+ tests/normalization/success/prelude/Natural/toInteger/1B.dhall view
@@ -0,0 +1,1 @@++0
+ tests/normalization/success/prelude/Optional/all/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (Some 3)
+ tests/normalization/success/prelude/Optional/all/0B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Optional/all/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (None Natural)
+ tests/normalization/success/prelude/Optional/all/1B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Optional/any/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (Some 2)
+ tests/normalization/success/prelude/Optional/any/0B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Optional/any/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (None Natural)
+ tests/normalization/success/prelude/Optional/any/1B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Optional/build/0A.dhall view
@@ -0,0 +1,7 @@+(../../../../../../Prelude/package.dhall).`Optional`.build+Natural+( λ(optional : Type)+→ λ(some : Natural → optional)+→ λ(none : optional)+→ some 1+)
+ tests/normalization/success/prelude/Optional/build/0B.dhall view
@@ -0,0 +1,1 @@+Some 1
+ tests/normalization/success/prelude/Optional/build/1A.dhall view
@@ -0,0 +1,7 @@+(../../../../../../Prelude/package.dhall).`Optional`.build+Natural+( λ(optional : Type)+→ λ(some : Natural → optional)+→ λ(none : optional)+→ none+)
+ tests/normalization/success/prelude/Optional/build/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ tests/normalization/success/prelude/Optional/concat/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (Some 1))
+ tests/normalization/success/prelude/Optional/concat/0B.dhall view
@@ -0,0 +1,1 @@+Some 1
+ tests/normalization/success/prelude/Optional/concat/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (None Natural))
+ tests/normalization/success/prelude/Optional/concat/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ tests/normalization/success/prelude/Optional/concat/2A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (None (Optional Natural))
+ tests/normalization/success/prelude/Optional/concat/2B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ tests/normalization/success/prelude/Optional/filter/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/even (Some 2)
+ tests/normalization/success/prelude/Optional/filter/0B.dhall view
@@ -0,0 +1,1 @@+Some 2
+ tests/normalization/success/prelude/Optional/filter/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/odd (Some 2)
+ tests/normalization/success/prelude/Optional/filter/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ tests/normalization/success/prelude/Optional/fold/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.fold Natural (Some 2) Natural (λ(x : Natural) → x) 0
+ tests/normalization/success/prelude/Optional/fold/0B.dhall view
@@ -0,0 +1,1 @@+2
+ tests/normalization/success/prelude/Optional/fold/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.fold Natural (None Natural) Natural (λ(x : Natural) → x) 0
+ tests/normalization/success/prelude/Optional/fold/1B.dhall view
@@ -0,0 +1,1 @@+0
+ tests/normalization/success/prelude/Optional/head/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.head Natural [ None Natural, Some 1, Some 2 ]
+ tests/normalization/success/prelude/Optional/head/0B.dhall view
@@ -0,0 +1,1 @@+Some 1
+ tests/normalization/success/prelude/Optional/head/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.head Natural [ None Natural, None Natural ]
+ tests/normalization/success/prelude/Optional/head/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ tests/normalization/success/prelude/Optional/head/2A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.head Natural ([] : List (Optional Natural))
+ tests/normalization/success/prelude/Optional/head/2B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ tests/normalization/success/prelude/Optional/last/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.last Natural [ None Natural, Some 1, Some 2 ]
+ tests/normalization/success/prelude/Optional/last/0B.dhall view
@@ -0,0 +1,1 @@+Some 2
+ tests/normalization/success/prelude/Optional/last/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.last Natural [ None Natural, None Natural ]
+ tests/normalization/success/prelude/Optional/last/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ tests/normalization/success/prelude/Optional/last/2A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.last Natural ([] : List (Optional Natural))
+ tests/normalization/success/prelude/Optional/last/2B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ tests/normalization/success/prelude/Optional/length/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.length Natural (Some 2)
+ tests/normalization/success/prelude/Optional/length/0B.dhall view
@@ -0,0 +1,1 @@+1
+ tests/normalization/success/prelude/Optional/length/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.length Natural (None Natural)
+ tests/normalization/success/prelude/Optional/length/1B.dhall view
@@ -0,0 +1,1 @@+0
+ tests/normalization/success/prelude/Optional/map/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (Some 3)
+ tests/normalization/success/prelude/Optional/map/0B.dhall view
@@ -0,0 +1,1 @@+Some False
+ tests/normalization/success/prelude/Optional/map/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (None Natural)
+ tests/normalization/success/prelude/Optional/map/1B.dhall view
@@ -0,0 +1,1 @@+None Bool
+ tests/normalization/success/prelude/Optional/null/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.null Natural (Some 2)
+ tests/normalization/success/prelude/Optional/null/0B.dhall view
@@ -0,0 +1,1 @@+False
+ tests/normalization/success/prelude/Optional/null/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.null Natural (None Natural)
+ tests/normalization/success/prelude/Optional/null/1B.dhall view
@@ -0,0 +1,1 @@+True
+ tests/normalization/success/prelude/Optional/toList/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.toList Natural (Some 1)
+ tests/normalization/success/prelude/Optional/toList/0B.dhall view
@@ -0,0 +1,1 @@+[ 1 ] : List Natural
+ tests/normalization/success/prelude/Optional/toList/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.toList Natural (None Natural)
+ tests/normalization/success/prelude/Optional/toList/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ tests/normalization/success/prelude/Optional/unzip/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.unzip Text Bool (Some { _1 = "ABC", _2 = True })
+ tests/normalization/success/prelude/Optional/unzip/0B.dhall view
@@ -0,0 +1,1 @@+{ _1 = Some "ABC", _2 = Some True }
+ tests/normalization/success/prelude/Optional/unzip/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.unzip Text Bool (None { _1 : Text, _2 : Bool })
+ tests/normalization/success/prelude/Optional/unzip/1B.dhall view
@@ -0,0 +1,1 @@+{ _1 = None Text, _2 = None Bool }
+ tests/normalization/success/prelude/Text/concat/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concat [ "ABC", "DEF", "GHI" ]
+ tests/normalization/success/prelude/Text/concat/0B.dhall view
@@ -0,0 +1,1 @@+"ABCDEFGHI"
+ tests/normalization/success/prelude/Text/concat/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concat ([] : List Text)
+ tests/normalization/success/prelude/Text/concat/1B.dhall view
@@ -0,0 +1,1 @@+""
+ tests/normalization/success/prelude/Text/concatMap/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concatMap Natural (λ(n : Natural) → "${Natural/show n} ") [ 0, 1, 2 ]
+ tests/normalization/success/prelude/Text/concatMap/0B.dhall view
@@ -0,0 +1,1 @@+"0 1 2 "
+ tests/normalization/success/prelude/Text/concatMap/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concatMap Natural (λ(n : Natural) → "${Natural/show n} ") ([] : List Natural)
+ tests/normalization/success/prelude/Text/concatMap/1B.dhall view
@@ -0,0 +1,1 @@+""
+ tests/normalization/success/prelude/Text/concatMapSep/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show [ 0, 1, 2 ]
+ tests/normalization/success/prelude/Text/concatMapSep/0B.dhall view
@@ -0,0 +1,1 @@+"0, 1, 2"
+ tests/normalization/success/prelude/Text/concatMapSep/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show ([] : List Natural)
+ tests/normalization/success/prelude/Text/concatMapSep/1B.dhall view
@@ -0,0 +1,1 @@+""
+ tests/normalization/success/prelude/Text/concatSep/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concatSep ", " [ "ABC", "DEF", "GHI" ]
+ tests/normalization/success/prelude/Text/concatSep/0B.dhall view
@@ -0,0 +1,1 @@+"ABC, DEF, GHI"
+ tests/normalization/success/prelude/Text/concatSep/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concatSep ", " ([] : List Text)
+ tests/normalization/success/prelude/Text/concatSep/1B.dhall view
@@ -0,0 +1,1 @@+""
+ tests/normalization/success/remoteSystemsA.dhall view
@@ -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
+ tests/normalization/success/remoteSystemsB.dhall view
@@ -0,0 +1,1 @@+λ(xs : List { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text }) → List/fold { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text } xs Text (λ(x : { cores : Natural, host : Text, key : Text, mandatoryFeatures : List Text, platforms : List Text, speedFactor : Natural, supportedFeatures : List Text, user : Optional Text }) → λ(y : Text) → "${Optional/fold Text x.user Text (λ(user : Text) → "${user}@${x.host}") x.host} ${merge { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } (List/fold Text x.platforms < Empty : {} | NonEmpty : Text > (λ(element : Text) → λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → < NonEmpty = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : Text} ${x.key} ${Integer/show (Natural/toInteger x.cores)} ${Integer/show (Natural/toInteger x.speedFactor)} ${merge { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } (List/fold Text x.supportedFeatures < Empty : {} | NonEmpty : Text > (λ(element : Text) → λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → < NonEmpty = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : Text} ${merge { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result } (List/fold Text x.mandatoryFeatures < Empty : {} | NonEmpty : Text > (λ(element : Text) → λ(status : < Empty : {} | NonEmpty : Text >) → merge { Empty = λ(_ : {}) → < NonEmpty = element | Empty : {} >, NonEmpty = λ(result : Text) → < NonEmpty = element ++ "," ++ result | Empty : {} > } status : < Empty : {} | NonEmpty : Text >) < Empty = {=} | NonEmpty : Text >) : Text}\n" ++ y) ""
+ tests/normalization/success/simple/doubleShowA.dhall view
@@ -0,0 +1,1 @@+{ example0 = Double/show -0.42, example1 = Double/show 13.37 }
+ tests/normalization/success/simple/doubleShowB.dhall view
@@ -0,0 +1,1 @@+{ example0 = "-0.42", example1 = "13.37" }
+ tests/normalization/success/simple/integerShowA.dhall view
@@ -0,0 +1,4 @@+{ example0 = Integer/show +1337+, example1 = Integer/show -42+, example2 = Integer/show +0+}
+ tests/normalization/success/simple/integerShowB.dhall view
@@ -0,0 +1,1 @@+{ example0 = "+1337", example1 = "-42", example2 = "+0" }
+ tests/normalization/success/simple/integerToDoubleA.dhall view
@@ -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+]
+ tests/normalization/success/simple/integerToDoubleB.dhall view
@@ -0,0 +1,9 @@+[ Infinity+, 1.7976931348623157e308+, 1.7976931348623157e308+, 1.7976931348623155e308+, -Infinity+, -1.7976931348623157e308+, -1.7976931348623157e308+, -1.7976931348623155e308+]
+ tests/normalization/success/simple/letletA.dhall view
@@ -0,0 +1,3 @@+let l = λ(n : Natural) → λ(m : Natural) → λ(x : Natural) → n + m * x+let f = l 2 3+in  f 445
+ tests/normalization/success/simple/letletB.dhall view
@@ -0,0 +1,1 @@+1337
+ tests/normalization/success/simple/listBuildA.dhall view
@@ -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))+      )+}
+ tests/normalization/success/simple/listBuildB.dhall view
@@ -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 ]+}
+ tests/normalization/success/simple/multiLineA.dhall view
@@ -0,0 +1,4 @@+''+ foo+bar+''
+ tests/normalization/success/simple/multiLineB.dhall view
@@ -0,0 +1,4 @@+''+ foo+bar+''
+ tests/normalization/success/simple/naturalBuildA.dhall view
@@ -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)+      )+}
+ tests/normalization/success/simple/naturalBuildB.dhall view
@@ -0,0 +1,7 @@+{ example0 =+    1+, example1 =+    1+, example2 =+    λ(id : ∀(a : Type) → a → a) → id Natural 1+}
+ tests/normalization/success/simple/naturalPlusA.dhall view
@@ -0,0 +1,1 @@+1 + 2
+ tests/normalization/success/simple/naturalPlusB.dhall view
@@ -0,0 +1,1 @@+3
+ tests/normalization/success/simple/naturalShowA.dhall view
@@ -0,0 +1,1 @@+Natural/show 42
+ tests/normalization/success/simple/naturalShowB.dhall view
@@ -0,0 +1,1 @@+"42"
+ tests/normalization/success/simple/naturalToIntegerA.dhall view
@@ -0,0 +1,1 @@+Natural/toInteger 1
+ tests/normalization/success/simple/naturalToIntegerB.dhall view
@@ -0,0 +1,1 @@++1
+ tests/normalization/success/simple/optionalBuildA.dhall view
@@ -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+      )+}
+ tests/normalization/success/simple/optionalBuildB.dhall view
@@ -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+}
+ tests/normalization/success/simple/optionalBuildFoldA.dhall view
@@ -0,0 +1,1 @@+Optional/build Text (Optional/fold Text ([ "foo" ] : Optional Text))
+ tests/normalization/success/simple/optionalBuildFoldB.dhall view
@@ -0,0 +1,1 @@+[ "foo" ] : Optional Text
+ tests/normalization/success/simple/optionalFoldA.dhall view
@@ -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)+    }
+ tests/normalization/success/simple/optionalFoldB.dhall view
@@ -0,0 +1,1 @@+{ example0 = 1, example1 = 2 }
+ tests/normalization/success/simple/sortOperatorA.dhall view
@@ -0,0 +1,1 @@+{ b = 2 } // { a = 1 }
+ tests/normalization/success/simple/sortOperatorB.dhall view
@@ -0,0 +1,1 @@+{ a = 1, b = 2 }
+ tests/normalization/success/simplifications/andA.dhall view
@@ -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+}
+ tests/normalization/success/simplifications/andB.dhall view
@@ -0,0 +1,6 @@+{ example0 = λ(x : Bool) → x+, example1 = λ(x : Bool) → x+, example2 = λ(x : Bool) → False+, example3 = λ(x : Bool) → False+, example4 = λ(x : Bool) → x+}
+ tests/normalization/success/simplifications/eqA.dhall view
@@ -0,0 +1,4 @@+{ example0 = λ(x : Bool) → x == True+, example1 = λ(x : Bool) → True == x+, example2 = λ(x : Bool) → x == x+}
+ tests/normalization/success/simplifications/eqB.dhall view
@@ -0,0 +1,4 @@+{ example0 = λ(x : Bool) → x+, example1 = λ(x : Bool) → x+, example2 = λ(x : Bool) → True+}
+ tests/normalization/success/simplifications/ifThenElseA.dhall view
@@ -0,0 +1,3 @@+{ example0 = λ(x : Bool) → if x then True else False+, example1 = λ(x : Bool) → λ(y : Text) → if x then y else y+}
+ tests/normalization/success/simplifications/ifThenElseB.dhall view
@@ -0,0 +1,3 @@+{ example0 = λ(x : Bool) → x+, example1 = λ(x : Bool) → λ(y : Text) → y+}
+ tests/normalization/success/simplifications/neA.dhall view
@@ -0,0 +1,4 @@+{ example0 = λ(x : Bool) → x != False+, example1 = λ(x : Bool) → False != x+, example2 = λ(x : Bool) → x != x+}
+ tests/normalization/success/simplifications/neB.dhall view
@@ -0,0 +1,4 @@+{ example0 = λ(x : Bool) → x+, example1 = λ(x : Bool) → x+, example2 = λ(x : Bool) → False+}
+ tests/normalization/success/simplifications/orA.dhall view
@@ -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+}
+ tests/normalization/success/simplifications/orB.dhall view
@@ -0,0 +1,6 @@+{ example0 = λ(x : Bool) → True+, example1 = λ(x : Bool) → True+, example2 = λ(x : Bool) → x+, example3 = λ(x : Bool) → x+, example4 = λ(x : Bool) → x+}
− tests/normalization/tutorial/combineTypes/0A.dhall 
@@ -1,1 +0,0 @@-{ foo : { bar : Text } } ⩓ { foo : { baz : Bool }, qux : Integer }
− tests/normalization/tutorial/combineTypes/0B.dhall 
@@ -1,1 +0,0 @@-{ foo : { bar : Text, baz : Bool }, qux : Integer }
− tests/normalization/tutorial/projection/0A.dhall 
@@ -1,1 +0,0 @@-{ x = 1, y = True, z = "ABC" }.{ x, y }
− tests/normalization/tutorial/projection/0B.dhall 
@@ -1,1 +0,0 @@-{ x = 1, y = True }
− tests/parser/annotations.dhall 
@@ -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 }
− tests/parser/blockComment.dhall 
@@ -1,3 +0,0 @@-{- foo -}--1
− tests/parser/builtins.dhall 
@@ -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-  }
− tests/parser/collectionImportType.dhall 
@@ -1,3 +0,0 @@-{ example0 = [] : Optional ./type.dhall-, example1 = [] : List ./type.dhall-}
− tests/parser/constructors.dhall 
@@ -1,1 +0,0 @@-constructors < Left : Natural | Right : Bool >
− tests/parser/double.dhall 
@@ -1,1 +0,0 @@-[ 1.1, -1.1, 1e1, 1.1e1, -1.1 ]
− tests/parser/doubleQuotedString.dhall 
@@ -1,1 +0,0 @@-"ABC"
− tests/parser/environmentVariables.dhall 
@@ -1,5 +0,0 @@-[ env:FOO--  -- Yes, this is legal-, env:"\"\\\a\b\f\n\r\t\v"-]
− tests/parser/escapedDoubleQuotedString.dhall 
@@ -1,1 +0,0 @@-"\\\"\$\\\/\b\f\n\r\t \u2200(a : Type) \u2192 a"
− tests/parser/escapedSingleQuotedString.dhall 
@@ -1,4 +0,0 @@-''-''${-'''-''
+ tests/parser/failure/doubleBoundsNeg.dhall view
@@ -0,0 +1,1 @@+-179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0
+ tests/parser/failure/doubleBoundsPos.dhall view
@@ -0,0 +1,1 @@+179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0
− tests/parser/failure/duplicateFields.dhall 
@@ -1,1 +0,0 @@-{ a = 1, a = 2 }
− tests/parser/fields.dhall 
@@ -1,1 +0,0 @@-({ foo = { bar = { baz = 1 } } }).foo. bar .baz
− tests/parser/forall.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → forall (b : Type) -> a
− tests/parser/functionType.dhall 
@@ -1,1 +0,0 @@-Bool → Bool -> Bool
− tests/parser/identifier.dhall 
@@ -1,1 +0,0 @@-λ(a : Type) → λ(a : Type) → a@1
− tests/parser/ifThenElse.dhall 
@@ -1,1 +0,0 @@-if True then 1 else 2
− tests/parser/importAlt.dhall 
@@ -1,1 +0,0 @@-env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2
− tests/parser/interpolatedDoubleQuotedString.dhall 
@@ -1,1 +0,0 @@-"ABC${Integer/show 123}"
− tests/parser/interpolatedSingleQuotedString.dhall 
@@ -1,4 +0,0 @@-''-ABC-${Integer/show 123}-''
− tests/parser/label.dhall 
@@ -1,2 +0,0 @@-let _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ = 1-in  _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/
− tests/parser/lambda.dhall 
@@ -1,1 +0,0 @@-λ(a : Type) → \(b : Type) -> a
− tests/parser/largeExpression.dhall 
@@ -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-  )-  ""
− tests/parser/let.dhall 
@@ -1,3 +0,0 @@-    let x = 1-in  let y : Integer = 2-in  x
− tests/parser/lineComment.dhall 
@@ -1,3 +0,0 @@--- foo--1
− tests/parser/list.dhall 
@@ -1,4 +0,0 @@-[ [1, 2, 3]-, [1, 2, 3] : List Integer-, [] : List Integer-]
− tests/parser/merge.dhall 
@@ -1,7 +0,0 @@-  λ(x : <>)-→ { bar = merge {=} x : Integer-  , foo =-      merge-      { Left = λ(b : Bool) → b, Right = Natural/even }-      < Left = True | Right : Natural >-  }
− tests/parser/natural.dhall 
@@ -1,1 +0,0 @@-[ +0, +1, +01, +10 ]
− tests/parser/nestedBlockComment.dhall 
@@ -1,3 +0,0 @@-{- foo {- bar -} baz -}--1
− tests/parser/operators.dhall 
@@ -1,2 +0,0 @@-  { foo = (False && Natural/even (+1 + +2 * +3)) || True == False != True }-∧ { bar = [ "ABC" ++ "DEF" ] # [ "GHI" ] } ⫽ { baz = True }
− tests/parser/parenthesizeUsing.dhall 
@@ -1,1 +0,0 @@-https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate using (./a.dhall sha256:16173e984d35ee3ffd8b6b79167df89480e67d1cd03ea5d0fc93689e4d928e61) sha256:b0e3ec1797b32c80c0bcb7e8254b08c7e9e35e75e6b410c7ac21477ab90167ad
− tests/parser/pathTermination.dhall 
@@ -1,3 +0,0 @@--- Verify that certain punctuation marks terminate paths correctly-  λ(x : ./example)-→ ./example[./example, ./example{bar = ./example<baz = ./example>, qux = ./example}, ./example]
− tests/parser/paths.dhall 
@@ -1,5 +0,0 @@-[ /absolute/path-, ./relative/path-, ~/home/anchored/path-, /ipfs/QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx/Prelude-]
− tests/parser/quotedLabel.dhall 
@@ -1,4 +0,0 @@-{ example1 = let `let` = 1 in `let`-, example2 = let `:.` = 1 in `:.`-, example3 = let `$ref` = 1 in `$ref`-}
− tests/parser/record.dhall 
@@ -1,4 +0,0 @@-{ foo = 1-, bar = +2-, baz = True-} : { foo : Integer, bar : Natural, baz : Bool }
− tests/parser/reservedPrefix.dhall 
@@ -1,1 +0,0 @@-let TypeSynonym = Integer in 1 : TypeSynonym
− tests/parser/singleQuotedString.dhall 
@@ -1,4 +0,0 @@-''-ABC-DEF-''
− tests/parser/sort.dhall 
@@ -1,1 +0,0 @@-Sort
+ tests/parser/success/annotationsA.dhall view
@@ -0,0 +1,4 @@+{ foo = ([] : List Integer) # [1, 2, 3] # ([1, 2, 3] : List Integer)+, bar = [] : Optional Integer+, baz = [1] : Optional Integer+} : { foo : List Integer, bar : Optional Integer, baz : Optional Integer }
+ tests/parser/success/annotationsB.dhall view
@@ -0,0 +1,84 @@+[+  26,+  [+    8,+    {+      "foo": [+        3,+        7,+        [+          3,+          7,+          [+            4,+            "Integer"+          ],+          [+            4,+            null,+            [+              15,+              1+            ],+            [+              15,+              2+            ],+            [+              15,+              3+            ]+          ]+        ],+        [+          4,+          null,+          [+            15,+            1+          ],+          [+            15,+            2+          ],+          [+            15,+            3+          ]+        ]+      ],+      "bar": [+        5,+        "Integer"+      ],+      "baz": [+        5,+        "Integer",+        [+          15,+          1+        ]+      ]+    }+  ],+  [+    7,+    {+      "foo": [+        0,+        "List",+        "Integer"+      ],+      "bar": [+        0,+        "Optional",+        "Integer"+      ],+      "baz": [+        0,+        "Optional",+        "Integer"+      ]+    }+  ]+]
+ tests/parser/success/blockCommentA.dhall view
@@ -0,0 +1,3 @@+{- foo -}++1
+ tests/parser/success/blockCommentB.dhall view
@@ -0,0 +1,4 @@+[+  15,+  1+]
+ tests/parser/success/builtinsA.dhall view
@@ -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+  }
+ tests/parser/success/builtinsB.dhall view
@@ -0,0 +1,57 @@+[+  1,+  "x",+  [+    7,+    {+      "field0": "Bool",+      "field1": [+        0,+        "Optional",+        [+          0,+          "Optional",+          "Bool"+        ]+      ],+      "field2": "Natural",+      "field3": "Integer",+      "field4": "Double",+      "field5": "Text",+      "field6": [+        0,+        "List",+        [+          0,+          "List",+          "Bool"+        ]+      ]+    }+  ],+  [+    8,+    {+      "field00": "Natural/fold",+      "field01": "Natural/build",+      "field02": "Natural/isZero",+      "field03": "Natural/even",+      "field04": "Natural/odd",+      "field05": "Natural/toInteger",+      "field06": "Natural/show",+      "field07": "Integer/show",+      "field08": "Double/show",+      "field09": "List/build",+      "field10": "List/fold",+      "field11": "List/length",+      "field12": "List/head",+      "field13": "List/last",+      "field14": "List/indexed",+      "field15": "List/reverse",+      "field16": "Optional/fold",+      "field17": "Optional/build",+      "field18": true,+      "field19": false+    }+  ]+]
+ tests/parser/success/collectionImportTypeA.dhall view
@@ -0,0 +1,3 @@+{ example0 = [] : Optional ./type.dhall+, example1 = [] : List ./type.dhall+}
+ tests/parser/success/collectionImportTypeB.dhall view
@@ -0,0 +1,21 @@+[+  8,+  {+    "example0": [+      5,+      [+        24,+        3,+        "type.dhall"+      ]+    ],+    "example1": [+      4,+      [+        24,+        3,+        "type.dhall"+      ]+    ]+  }+]
+ tests/parser/success/constructorsA.dhall view
@@ -0,0 +1,1 @@+constructors < Left : Natural | Right : Bool >
+ tests/parser/success/constructorsB.dhall view
@@ -0,0 +1,10 @@+[+  13,+  [+    11,+    {+      "Left": "Natural",+      "Right": "Bool"+    }+  ]+]
+ tests/parser/success/doubleA.dhall view
@@ -0,0 +1,1 @@+[ 1.1, -1.1, 1e1, 1.1e1, -1.1 ]
+ tests/parser/success/doubleB.dhall view
@@ -0,0 +1,24 @@+[+  4,+  null,+  [+    17,+    1.1+  ],+  [+    17,+    -1.1+  ],+  [+    17,+    10.0+  ],+  [+    17,+    11.0+  ],+  [+    17,+    -1.1+  ]+]
+ tests/parser/success/doubleQuotedStringA.dhall view
@@ -0,0 +1,1 @@+"ABC"
+ tests/parser/success/doubleQuotedStringB.dhall view
@@ -0,0 +1,4 @@+[+  18,+  "ABC"+]
+ tests/parser/success/environmentVariablesA.dhall view
@@ -0,0 +1,5 @@+[ env:FOO++  -- Yes, this is legal+, env:"\"\\\a\b\f\n\r\t\v"+]
+ tests/parser/success/environmentVariablesB.dhall view
@@ -0,0 +1,14 @@+[+  4,+  null,+  [+    24,+    6,+    "FOO"+  ],+  [+    24,+    6,+    "\\\"\\\\\\a\\b\\f\\n\\r\\t\\v"+  ]+]
+ tests/parser/success/escapedDoubleQuotedStringA.dhall view
@@ -0,0 +1,1 @@+"\\\"\$\\\/\b\f\n\r\t \u2200(a : Type) \u2192 a"
+ tests/parser/success/escapedDoubleQuotedStringB.dhall view
@@ -0,0 +1,4 @@+[+  18,+  "\\\"$\\/\b\f\n\r\t ∀(a : Type) → a"+]
+ tests/parser/success/escapedSingleQuotedStringA.dhall view
@@ -0,0 +1,4 @@+''+''${+'''+''
+ tests/parser/success/escapedSingleQuotedStringB.dhall view
@@ -0,0 +1,4 @@+[+  18,+  "${\n''\n"+]
+ tests/parser/success/fieldsA.dhall view
@@ -0,0 +1,1 @@+({ foo = { bar = { baz = 1 } } }).foo. bar .baz
+ tests/parser/success/fieldsB.dhall view
@@ -0,0 +1,31 @@+[+  9,+  [+    9,+    [+      9,+      [+        8,+        {+          "foo": [+            8,+            {+              "bar": [+                8,+                {+                  "baz": [+                    15,+                    1+                  ]+                }+              ]+            }+          ]+        }+      ],+      "foo"+    ],+    "bar"+  ],+  "baz"+]
+ tests/parser/success/forallA.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → forall (b : Type) -> a
+ tests/parser/success/forallB.dhall view
@@ -0,0 +1,11 @@+[+  2,+  "a",+  "Type",+  [+    2,+    "b",+    "Type",+    "a"+  ]+]
+ tests/parser/success/functionTypeA.dhall view
@@ -0,0 +1,1 @@+Bool → Bool -> Bool
+ tests/parser/success/functionTypeB.dhall view
@@ -0,0 +1,9 @@+[+  2,+  "Bool",+  [+    2,+    "Bool",+    "Bool"+  ]+]
+ tests/parser/success/identifierA.dhall view
@@ -0,0 +1,1 @@+λ(a : Type) → λ(a : Type) → a@1
+ tests/parser/success/identifierB.dhall view
@@ -0,0 +1,14 @@+[+  1,+  "a",+  "Type",+  [+    1,+    "a",+    "Type",+    [+      "a",+      1+    ]+  ]+]
+ tests/parser/success/ifThenElseA.dhall view
@@ -0,0 +1,1 @@+if True then 1 else 2
+ tests/parser/success/ifThenElseB.dhall view
@@ -0,0 +1,12 @@+[+  14,+  true,+  [+    15,+    1+  ],+  [+    15,+    2+  ]+]
+ tests/parser/success/importAltA.dhall view
@@ -0,0 +1,1 @@+env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2
+ tests/parser/success/importAltB.dhall view
@@ -0,0 +1,39 @@+[+  3,+  11,+  [+    3,+    11,+    [+      3,+      11,+      [+        3,+        11,+        [+          24,+          6,+          "UNSET1"+        ],+        [+          24,+          6,+          "UNSET2"+        ]+      ],+      [+        24,+        7+      ]+    ],+    [+      24,+      6,+      "UNSET3"+    ]+  ],+  [+    15,+    2+  ]+]
+ tests/parser/success/interpolatedDoubleQuotedStringA.dhall view
@@ -0,0 +1,1 @@+"ABC${Integer/show 123}"
+ tests/parser/success/interpolatedDoubleQuotedStringB.dhall view
@@ -0,0 +1,13 @@+[+  18,+  "ABC",+  [+    0,+    "Integer/show",+    [+      15,+      123+    ]+  ],+  ""+]
+ tests/parser/success/interpolatedSingleQuotedStringA.dhall view
@@ -0,0 +1,4 @@+''+ABC+${Integer/show 123}+''
+ tests/parser/success/interpolatedSingleQuotedStringB.dhall view
@@ -0,0 +1,13 @@+[+  18,+  "ABC\n",+  [+    0,+    "Integer/show",+    [+      15,+      123+    ]+  ],+  "\n"+]
+ tests/parser/success/labelA.dhall view
@@ -0,0 +1,2 @@+let _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ = 1+in  _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/
+ tests/parser/success/labelB.dhall view
@@ -0,0 +1,10 @@+[+  25,+  "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/",+  null,+  [+    15,+    1+  ],+  "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/"+]
+ tests/parser/success/lambdaA.dhall view
@@ -0,0 +1,1 @@+λ(a : Type) → \(b : Type) -> a
+ tests/parser/success/lambdaB.dhall view
@@ -0,0 +1,11 @@+[+  1,+  "a",+  "Type",+  [+    1,+    "b",+    "Type",+    "a"+  ]+]
+ tests/parser/success/largeExpressionA.dhall view
@@ -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+  )+  ""
+ tests/parser/success/largeExpressionB.dhall view
@@ -0,0 +1,1303 @@+[+  1,+  "xs",+  [+    0,+    "List",+    [+      7,+      {+        "cores": "Natural",+        "host": "Text",+        "key": "Text",+        "mandatoryFeatures": [+          0,+          "List",+          "Text"+        ],+        "platforms": [+          0,+          "List",+          [+            11,+            {+              "AArch64_Linux": [+                7,+                {}+              ],+              "ARMv5tel_Linux": [+                7,+                {}+              ],+              "ARMv7l_Linux": [+                7,+                {}+              ],+              "I686_Cygwin": [+                7,+                {}+              ],+              "I686_Linux": [+                7,+                {}+              ],+              "MIPS64el_Linux": [+                7,+                {}+              ],+              "PowerPC_Linux": [+                7,+                {}+              ],+              "X86_64_Cygwin": [+                7,+                {}+              ],+              "X86_64_Darwin": [+                7,+                {}+              ],+              "X86_64_FreeBSD": [+                7,+                {}+              ],+              "X86_64_Linux": [+                7,+                {}+              ],+              "X86_64_Solaris": [+                7,+                {}+              ]+            }+          ]+        ],+        "speedFactor": "Natural",+        "supportedFeatures": [+          0,+          "List",+          "Text"+        ],+        "user": [+          0,+          "Optional",+          "Text"+        ]+      }+    ]+  ],+  [+    0,+    [+      0,+      [+        0,+        [+          0,+          [+            0,+            "List/fold",+            [+              7,+              {+                "cores": "Natural",+                "host": "Text",+                "key": "Text",+                "mandatoryFeatures": [+                  0,+                  "List",+                  "Text"+                ],+                "platforms": [+                  0,+                  "List",+                  [+                    11,+                    {+                      "AArch64_Linux": [+                        7,+                        {}+                      ],+                      "ARMv5tel_Linux": [+                        7,+                        {}+                      ],+                      "ARMv7l_Linux": [+                        7,+                        {}+                      ],+                      "I686_Cygwin": [+                        7,+                        {}+                      ],+                      "I686_Linux": [+                        7,+                        {}+                      ],+                      "MIPS64el_Linux": [+                        7,+                        {}+                      ],+                      "PowerPC_Linux": [+                        7,+                        {}+                      ],+                      "X86_64_Cygwin": [+                        7,+                        {}+                      ],+                      "X86_64_Darwin": [+                        7,+                        {}+                      ],+                      "X86_64_FreeBSD": [+                        7,+                        {}+                      ],+                      "X86_64_Linux": [+                        7,+                        {}+                      ],+                      "X86_64_Solaris": [+                        7,+                        {}+                      ]+                    }+                  ]+                ],+                "speedFactor": "Natural",+                "supportedFeatures": [+                  0,+                  "List",+                  "Text"+                ],+                "user": [+                  0,+                  "Optional",+                  "Text"+                ]+              }+            ]+          ],+          "xs"+        ],+        "Text"+      ],+      [+        1,+        "x",+        [+          7,+          {+            "cores": "Natural",+            "host": "Text",+            "key": "Text",+            "mandatoryFeatures": [+              0,+              "List",+              "Text"+            ],+            "platforms": [+              0,+              "List",+              [+                11,+                {+                  "AArch64_Linux": [+                    7,+                    {}+                  ],+                  "ARMv5tel_Linux": [+                    7,+                    {}+                  ],+                  "ARMv7l_Linux": [+                    7,+                    {}+                  ],+                  "I686_Cygwin": [+                    7,+                    {}+                  ],+                  "I686_Linux": [+                    7,+                    {}+                  ],+                  "MIPS64el_Linux": [+                    7,+                    {}+                  ],+                  "PowerPC_Linux": [+                    7,+                    {}+                  ],+                  "X86_64_Cygwin": [+                    7,+                    {}+                  ],+                  "X86_64_Darwin": [+                    7,+                    {}+                  ],+                  "X86_64_FreeBSD": [+                    7,+                    {}+                  ],+                  "X86_64_Linux": [+                    7,+                    {}+                  ],+                  "X86_64_Solaris": [+                    7,+                    {}+                  ]+                }+              ]+            ],+            "speedFactor": "Natural",+            "supportedFeatures": [+              0,+              "List",+              "Text"+            ],+            "user": [+              0,+              "Optional",+              "Text"+            ]+          }+        ],+        [+          1,+          "y",+          "Text",+          [+            3,+            6,+            [+              3,+              6,+              [+                3,+                6,+                [+                  3,+                  6,+                  [+                    3,+                    6,+                    [+                      3,+                      6,+                      [+                        3,+                        6,+                        [+                          3,+                          6,+                          [+                            3,+                            6,+                            [+                              3,+                              6,+                              [+                                3,+                                6,+                                [+                                  3,+                                  6,+                                  [+                                    3,+                                    6,+                                    [+                                      3,+                                      6,+                                      [+                                        0,+                                        [+                                          0,+                                          [+                                            0,+                                            [+                                              0,+                                              [+                                                0,+                                                "Optional/fold",+                                                "Text"+                                              ],+                                              [+                                                9,+                                                "x",+                                                "user"+                                              ]+                                            ],+                                            "Text"+                                          ],+                                          [+                                            1,+                                            "user",+                                            "Text",+                                            [+                                              3,+                                              6,+                                              [+                                                3,+                                                6,+                                                [+                                                  3,+                                                  6,+                                                  "user",+                                                  [+                                                    18,+                                                    "@"+                                                  ]+                                                ],+                                                [+                                                  9,+                                                  "x",+                                                  "host"+                                                ]+                                              ],+                                              [+                                                18,+                                                ""+                                              ]+                                            ]+                                          ]+                                        ],+                                        [+                                          9,+                                          "x",+                                          "host"+                                        ]+                                      ],+                                      [+                                        18,+                                        " "+                                      ]+                                    ],+                                    [+                                      6,+                                      [+                                        8,+                                        {+                                          "Empty": [+                                            1,+                                            [+                                              7,+                                              {}+                                            ],+                                            [+                                              18,+                                              ""+                                            ]+                                          ],+                                          "NonEmpty": [+                                            1,+                                            "result",+                                            "Text",+                                            "result"+                                          ]+                                        }+                                      ],+                                      [+                                        0,+                                        [+                                          0,+                                          [+                                            0,+                                            [+                                              0,+                                              [+                                                0,+                                                "List/fold",+                                                [+                                                  11,+                                                  {+                                                    "AArch64_Linux": [+                                                      7,+                                                      {}+                                                    ],+                                                    "ARMv5tel_Linux": [+                                                      7,+                                                      {}+                                                    ],+                                                    "ARMv7l_Linux": [+                                                      7,+                                                      {}+                                                    ],+                                                    "I686_Cygwin": [+                                                      7,+                                                      {}+                                                    ],+                                                    "I686_Linux": [+                                                      7,+                                                      {}+                                                    ],+                                                    "MIPS64el_Linux": [+                                                      7,+                                                      {}+                                                    ],+                                                    "PowerPC_Linux": [+                                                      7,+                                                      {}+                                                    ],+                                                    "X86_64_Cygwin": [+                                                      7,+                                                      {}+                                                    ],+                                                    "X86_64_Darwin": [+                                                      7,+                                                      {}+                                                    ],+                                                    "X86_64_FreeBSD": [+                                                      7,+                                                      {}+                                                    ],+                                                    "X86_64_Linux": [+                                                      7,+                                                      {}+                                                    ],+                                                    "X86_64_Solaris": [+                                                      7,+                                                      {}+                                                    ]+                                                  }+                                                ]+                                              ],+                                              [+                                                9,+                                                "x",+                                                "platforms"+                                              ]+                                            ],+                                            [+                                              11,+                                              {+                                                "Empty": [+                                                  7,+                                                  {}+                                                ],+                                                "NonEmpty": "Text"+                                              }+                                            ]+                                          ],+                                          [+                                            1,+                                            "element",+                                            [+                                              11,+                                              {+                                                "AArch64_Linux": [+                                                  7,+                                                  {}+                                                ],+                                                "ARMv5tel_Linux": [+                                                  7,+                                                  {}+                                                ],+                                                "ARMv7l_Linux": [+                                                  7,+                                                  {}+                                                ],+                                                "I686_Cygwin": [+                                                  7,+                                                  {}+                                                ],+                                                "I686_Linux": [+                                                  7,+                                                  {}+                                                ],+                                                "MIPS64el_Linux": [+                                                  7,+                                                  {}+                                                ],+                                                "PowerPC_Linux": [+                                                  7,+                                                  {}+                                                ],+                                                "X86_64_Cygwin": [+                                                  7,+                                                  {}+                                                ],+                                                "X86_64_Darwin": [+                                                  7,+                                                  {}+                                                ],+                                                "X86_64_FreeBSD": [+                                                  7,+                                                  {}+                                                ],+                                                "X86_64_Linux": [+                                                  7,+                                                  {}+                                                ],+                                                "X86_64_Solaris": [+                                                  7,+                                                  {}+                                                ]+                                              }+                                            ],+                                            [+                                              1,+                                              "status",+                                              [+                                                11,+                                                {+                                                  "Empty": [+                                                    7,+                                                    {}+                                                  ],+                                                  "NonEmpty": "Text"+                                                }+                                              ],+                                              [+                                                6,+                                                [+                                                  8,+                                                  {+                                                    "Empty": [+                                                      1,+                                                      [+                                                        7,+                                                        {}+                                                      ],+                                                      [+                                                        12,+                                                        "NonEmpty",+                                                        [+                                                          6,+                                                          [+                                                            8,+                                                            {+                                                              "AArch64_Linux": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "aarch64-linux"+                                                                ]+                                                              ],+                                                              "ARMv5tel_Linux": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "armv5tel-linux"+                                                                ]+                                                              ],+                                                              "ARMv7l_Linux": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "armv7l-linux"+                                                                ]+                                                              ],+                                                              "I686_Cygwin": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "i686-cygwin"+                                                                ]+                                                              ],+                                                              "I686_Linux": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "i686-linux"+                                                                ]+                                                              ],+                                                              "MIPS64el_Linux": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "mips64el-linux"+                                                                ]+                                                              ],+                                                              "PowerPC_Linux": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "powerpc-linux"+                                                                ]+                                                              ],+                                                              "X86_64_Cygwin": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "x86_64-cygwin"+                                                                ]+                                                              ],+                                                              "X86_64_Darwin": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "x86_64-darwin"+                                                                ]+                                                              ],+                                                              "X86_64_FreeBSD": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "x86_64-freebsd"+                                                                ]+                                                              ],+                                                              "X86_64_Linux": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "x86_64-linux"+                                                                ]+                                                              ],+                                                              "X86_64_Solaris": [+                                                                1,+                                                                [+                                                                  7,+                                                                  {}+                                                                ],+                                                                [+                                                                  18,+                                                                  "x86_64-solaris"+                                                                ]+                                                              ]+                                                            }+                                                          ],+                                                          "element"+                                                        ],+                                                        {+                                                          "Empty": [+                                                            7,+                                                            {}+                                                          ]+                                                        }+                                                      ]+                                                    ],+                                                    "NonEmpty": [+                                                      1,+                                                      "result",+                                                      "Text",+                                                      [+                                                        12,+                                                        "NonEmpty",+                                                        [+                                                          3,+                                                          6,+                                                          [+                                                            3,+                                                            6,+                                                            [+                                                              6,+                                                              [+                                                                8,+                                                                {+                                                                  "AArch64_Linux": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "aarch64-linux"+                                                                    ]+                                                                  ],+                                                                  "ARMv5tel_Linux": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "armv5tel-linux"+                                                                    ]+                                                                  ],+                                                                  "ARMv7l_Linux": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "armv7l-linux"+                                                                    ]+                                                                  ],+                                                                  "I686_Cygwin": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "i686-cygwin"+                                                                    ]+                                                                  ],+                                                                  "I686_Linux": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "i686-linux"+                                                                    ]+                                                                  ],+                                                                  "MIPS64el_Linux": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "mips64el-linux"+                                                                    ]+                                                                  ],+                                                                  "PowerPC_Linux": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "powerpc-linux"+                                                                    ]+                                                                  ],+                                                                  "X86_64_Cygwin": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "x86_64-cygwin"+                                                                    ]+                                                                  ],+                                                                  "X86_64_Darwin": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "x86_64-darwin"+                                                                    ]+                                                                  ],+                                                                  "X86_64_FreeBSD": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "x86_64-freebsd"+                                                                    ]+                                                                  ],+                                                                  "X86_64_Linux": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "x86_64-linux"+                                                                    ]+                                                                  ],+                                                                  "X86_64_Solaris": [+                                                                    1,+                                                                    [+                                                                      7,+                                                                      {}+                                                                    ],+                                                                    [+                                                                      18,+                                                                      "x86_64-solaris"+                                                                    ]+                                                                  ]+                                                                }+                                                              ],+                                                              "element"+                                                            ],+                                                            [+                                                              18,+                                                              ","+                                                            ]+                                                          ],+                                                          "result"+                                                        ],+                                                        {+                                                          "Empty": [+                                                            7,+                                                            {}+                                                          ]+                                                        }+                                                      ]+                                                    ]+                                                  }+                                                ],+                                                "status",+                                                [+                                                  11,+                                                  {+                                                    "Empty": [+                                                      7,+                                                      {}+                                                    ],+                                                    "NonEmpty": "Text"+                                                  }+                                                ]+                                              ]+                                            ]+                                          ]+                                        ],+                                        [+                                          12,+                                          "Empty",+                                          [+                                            8,+                                            {}+                                          ],+                                          {+                                            "NonEmpty": "Text"+                                          }+                                        ]+                                      ],+                                      "Text"+                                    ]+                                  ],+                                  [+                                    18,+                                    " "+                                  ]+                                ],+                                [+                                  9,+                                  "x",+                                  "key"+                                ]+                              ],+                              [+                                18,+                                " "+                              ]+                            ],+                            [+                              0,+                              "Integer/show",+                              [+                                0,+                                "Natural/toInteger",+                                [+                                  9,+                                  "x",+                                  "cores"+                                ]+                              ]+                            ]+                          ],+                          [+                            18,+                            " "+                          ]+                        ],+                        [+                          0,+                          "Integer/show",+                          [+                            0,+                            "Natural/toInteger",+                            [+                              9,+                              "x",+                              "speedFactor"+                            ]+                          ]+                        ]+                      ],+                      [+                        18,+                        " "+                      ]+                    ],+                    [+                      6,+                      [+                        8,+                        {+                          "Empty": [+                            1,+                            [+                              7,+                              {}+                            ],+                            [+                              18,+                              ""+                            ]+                          ],+                          "NonEmpty": [+                            1,+                            "result",+                            "Text",+                            "result"+                          ]+                        }+                      ],+                      [+                        0,+                        [+                          0,+                          [+                            0,+                            [+                              0,+                              [+                                0,+                                "List/fold",+                                "Text"+                              ],+                              [+                                9,+                                "x",+                                "supportedFeatures"+                              ]+                            ],+                            [+                              11,+                              {+                                "Empty": [+                                  7,+                                  {}+                                ],+                                "NonEmpty": "Text"+                              }+                            ]+                          ],+                          [+                            1,+                            "element",+                            "Text",+                            [+                              1,+                              "status",+                              [+                                11,+                                {+                                  "Empty": [+                                    7,+                                    {}+                                  ],+                                  "NonEmpty": "Text"+                                }+                              ],+                              [+                                6,+                                [+                                  8,+                                  {+                                    "Empty": [+                                      1,+                                      [+                                        7,+                                        {}+                                      ],+                                      [+                                        12,+                                        "NonEmpty",+                                        "element",+                                        {+                                          "Empty": [+                                            7,+                                            {}+                                          ]+                                        }+                                      ]+                                    ],+                                    "NonEmpty": [+                                      1,+                                      "result",+                                      "Text",+                                      [+                                        12,+                                        "NonEmpty",+                                        [+                                          3,+                                          6,+                                          [+                                            3,+                                            6,+                                            "element",+                                            [+                                              18,+                                              ","+                                            ]+                                          ],+                                          "result"+                                        ],+                                        {+                                          "Empty": [+                                            7,+                                            {}+                                          ]+                                        }+                                      ]+                                    ]+                                  }+                                ],+                                "status",+                                [+                                  11,+                                  {+                                    "Empty": [+                                      7,+                                      {}+                                    ],+                                    "NonEmpty": "Text"+                                  }+                                ]+                              ]+                            ]+                          ]+                        ],+                        [+                          12,+                          "Empty",+                          [+                            8,+                            {}+                          ],+                          {+                            "NonEmpty": "Text"+                          }+                        ]+                      ],+                      "Text"+                    ]+                  ],+                  [+                    18,+                    " "+                  ]+                ],+                [+                  6,+                  [+                    8,+                    {+                      "Empty": [+                        1,+                        [+                          7,+                          {}+                        ],+                        [+                          18,+                          ""+                        ]+                      ],+                      "NonEmpty": [+                        1,+                        "result",+                        "Text",+                        "result"+                      ]+                    }+                  ],+                  [+                    0,+                    [+                      0,+                      [+                        0,+                        [+                          0,+                          [+                            0,+                            "List/fold",+                            "Text"+                          ],+                          [+                            9,+                            "x",+                            "mandatoryFeatures"+                          ]+                        ],+                        [+                          11,+                          {+                            "Empty": [+                              7,+                              {}+                            ],+                            "NonEmpty": "Text"+                          }+                        ]+                      ],+                      [+                        1,+                        "element",+                        "Text",+                        [+                          1,+                          "status",+                          [+                            11,+                            {+                              "Empty": [+                                7,+                                {}+                              ],+                              "NonEmpty": "Text"+                            }+                          ],+                          [+                            6,+                            [+                              8,+                              {+                                "Empty": [+                                  1,+                                  [+                                    7,+                                    {}+                                  ],+                                  [+                                    12,+                                    "NonEmpty",+                                    "element",+                                    {+                                      "Empty": [+                                        7,+                                        {}+                                      ]+                                    }+                                  ]+                                ],+                                "NonEmpty": [+                                  1,+                                  "result",+                                  "Text",+                                  [+                                    12,+                                    "NonEmpty",+                                    [+                                      3,+                                      6,+                                      [+                                        3,+                                        6,+                                        "element",+                                        [+                                          18,+                                          ","+                                        ]+                                      ],+                                      "result"+                                    ],+                                    {+                                      "Empty": [+                                        7,+                                        {}+                                      ]+                                    }+                                  ]+                                ]+                              }+                            ],+                            "status",+                            [+                              11,+                              {+                                "Empty": [+                                  7,+                                  {}+                                ],+                                "NonEmpty": "Text"+                              }+                            ]+                          ]+                        ]+                      ]+                    ],+                    [+                      12,+                      "Empty",+                      [+                        8,+                        {}+                      ],+                      {+                        "NonEmpty": "Text"+                      }+                    ]+                  ],+                  "Text"+                ]+              ],+              [+                18,+                "\n"+              ]+            ],+            "y"+          ]+        ]+      ]+    ],+    [+      18,+      ""+    ]+  ]+]
+ tests/parser/success/letA.dhall view
@@ -0,0 +1,3 @@+    let x = 1+in  let y : Integer = 2+in  x
+ tests/parser/success/letB.dhall view
@@ -0,0 +1,19 @@+[+  25,+  "x",+  null,+  [+    15,+    1+  ],+  [+    25,+    "y",+    "Integer",+    [+      15,+      2+    ],+    "x"+  ]+]
+ tests/parser/success/lineCommentA.dhall view
@@ -0,0 +1,3 @@+-- foo++1
+ tests/parser/success/lineCommentB.dhall view
@@ -0,0 +1,4 @@+[+  15,+  1+]
+ tests/parser/success/listA.dhall view
@@ -0,0 +1,4 @@+[ [1, 2, 3]+, [1, 2, 3] : List Integer+, [] : List Integer+]
+ tests/parser/success/listB.dhall view
@@ -0,0 +1,40 @@+[+  4,+  null,+  [+    4,+    null,+    [+      15,+      1+    ],+    [+      15,+      2+    ],+    [+      15,+      3+    ]+  ],+  [+    4,+    null,+    [+      15,+      1+    ],+    [+      15,+      2+    ],+    [+      15,+      3+    ]+  ],+  [+    4,+    "Integer"+  ]+]
+ tests/parser/success/mergeA.dhall view
@@ -0,0 +1,7 @@+  λ(x : <>)+→ { bar = merge {=} x : Integer+  , foo =+      merge+      { Left = λ(b : Bool) → b, Right = Natural/even }+      < Left = True | Right : Natural >+  }
+ tests/parser/success/mergeB.dhall view
@@ -0,0 +1,45 @@+[+  1,+  "x",+  [+    11,+    {}+  ],+  [+    8,+    {+      "bar": [+        6,+        [+          8,+          {}+        ],+        "x",+        "Integer"+      ],+      "foo": [+        6,+        [+          8,+          {+            "Left": [+              1,+              "b",+              "Bool",+              "b"+            ],+            "Right": "Natural/even"+          }+        ],+        [+          12,+          "Left",+          true,+          {+            "Right": "Natural"+          }+        ]+      ]+    }+  ]+]
+ tests/parser/success/multiletA.dhall view
@@ -0,0 +1,3 @@+let a = 1+let b = 2+in  a + b
+ tests/parser/success/multiletB.dhall view
@@ -0,0 +1,21 @@+[+  25,+  "a",+  null,+  [+    15,+    1+  ],+  "b",+  null,+  [+    15,+    2+  ],+  [+    3,+    4,+    "a",+    "b"+  ]+]
+ tests/parser/success/naturalA.dhall view
@@ -0,0 +1,1 @@+[ +0, +1, +01, +10 ]
+ tests/parser/success/naturalB.dhall view
@@ -0,0 +1,20 @@+[+  4,+  null,+  [+    16,+    0+  ],+  [+    16,+    1+  ],+  [+    16,+    1+  ],+  [+    16,+    10+  ]+]
+ tests/parser/success/nestedBlockCommentA.dhall view
@@ -0,0 +1,3 @@+{- foo {- bar -} baz -}++1
+ tests/parser/success/nestedBlockCommentB.dhall view
@@ -0,0 +1,4 @@+[+  15,+  1+]
+ tests/parser/success/operatorsA.dhall view
@@ -0,0 +1,2 @@+  { foo = (False && Natural/even (+1 + +2 * +3)) || True == False != True }+∧ { bar = [ "ABC" ++ "DEF" ] # [ "GHI" ] } ⫽ { baz = True }
+ tests/parser/success/operatorsB.dhall view
@@ -0,0 +1,96 @@+[+  3,+  8,+  [+    8,+    {+      "foo": [+        3,+        0,+        [+          3,+          1,+          false,+          [+            0,+            "Natural/even",+            [+              3,+              4,+              [+                16,+                1+              ],+              [+                3,+                5,+                [+                  16,+                  2+                ],+                [+                  16,+                  3+                ]+              ]+            ]+          ]+        ],+        [+          3,+          3,+          [+            3,+            2,+            true,+            false+          ],+          true+        ]+      ]+    }+  ],+  [+    3,+    9,+    [+      8,+      {+        "bar": [+          3,+          7,+          [+            4,+            null,+            [+              3,+              6,+              [+                18,+                "ABC"+              ],+              [+                18,+                "DEF"+              ]+            ]+          ],+          [+            4,+            null,+            [+              18,+              "GHI"+            ]+          ]+        ]+      }+    ],+    [+      8,+      {+        "baz": true+      }+    ]+  ]+]
+ tests/parser/success/parenthesizeUsingA.dhall view
@@ -0,0 +1,1 @@+https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate using (./a.dhall sha256:16173e984d35ee3ffd8b6b79167df89480e67d1cd03ea5d0fc93689e4d928e61) sha256:b0e3ec1797b32c80c0bcb7e8254b08c7e9e35e75e6b410c7ac21477ab90167ad
+ tests/parser/success/parenthesizeUsingB.dhall view
@@ -0,0 +1,12 @@+[+  24,+  1,+  "raw.githubusercontent.com",+  "dhall-lang",+  "Prelude",+  "c79c2bc3c46f129cc5b6d594ce298a381bcae92c",+  "List",+  "replicate",+  null,+  null+]
+ tests/parser/success/pathTerminationA.dhall view
@@ -0,0 +1,3 @@+-- Verify that certain punctuation marks terminate paths correctly+  λ(x : ./example)+→ ./example[./example, ./example{bar = ./example<baz = ./example>, qux = ./example}, ./example]
+ tests/parser/success/pathTerminationB.dhall view
@@ -0,0 +1,67 @@+[+  1,+  "x",+  [+    24,+    3,+    "example"+  ],+  [+    0,+    [+      24,+      3,+      "example"+    ],+    [+      4,+      null,+      [+        24,+        3,+        "example"+      ],+      [+        0,+        [+          24,+          3,+          "example"+        ],+        [+          8,+          {+            "bar": [+              0,+              [+                24,+                3,+                "example"+              ],+              [+                12,+                "baz",+                [+                  24,+                  3,+                  "example"+                ],+                {}+              ]+            ],+            "qux": [+              24,+              3,+              "example"+            ]+          }+        ]+      ],+      [+        24,+        3,+        "example"+      ]+    ]+  ]+]
+ tests/parser/success/pathsA.dhall view
@@ -0,0 +1,5 @@+[ /absolute/path+, ./relative/path+, ~/home/anchored/path+, /ipfs/QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx/Prelude+]
+ tests/parser/success/pathsB.dhall view
@@ -0,0 +1,30 @@+[+  4,+  null,+  [+    24,+    2,+    "absolute",+    "path"+  ],+  [+    24,+    3,+    "relative",+    "path"+  ],+  [+    24,+    5,+    "home",+    "anchored",+    "path"+  ],+  [+    24,+    2,+    "ipfs",+    "QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx",+    "Prelude"+  ]+]
+ tests/parser/success/quotedLabelA.dhall view
@@ -0,0 +1,4 @@+{ example1 = let `let` = 1 in `let`+, example2 = let `:.` = 1 in `:.`+, example3 = let `$ref` = 1 in `$ref`+}
+ tests/parser/success/quotedLabelB.dhall view
@@ -0,0 +1,35 @@+[+  8,+  {+    "example1": [+      25,+      "let",+      null,+      [+        15,+        1+      ],+      "let"+    ],+    "example2": [+      25,+      ":.",+      null,+      [+        15,+        1+      ],+      ":."+    ],+    "example3": [+      25,+      "$ref",+      null,+      [+        15,+        1+      ],+      "$ref"+    ]+  }+]
+ tests/parser/success/quotedPathsA.dhall view
@@ -0,0 +1,3 @@+{ example0 = /"foo"/bar/"baz qux"+, example1 = https://example.com/foo/"bar?baz"?qux+}
+ tests/parser/success/quotedPathsB.dhall view
@@ -0,0 +1,21 @@+[+  8,+  {+    "example0": [+      24,+      2,+      "foo",+      "bar",+      "baz qux"+    ],+    "example1": [+      24,+      1,+      "example.com",+      "foo",+      "bar?baz",+      "qux",+      null+    ]+  }+]
+ tests/parser/success/recordA.dhall view
@@ -0,0 +1,4 @@+{ foo = 1+, bar = +2+, baz = True+} : { foo : Integer, bar : Natural, baz : Bool }
+ tests/parser/success/recordB.dhall view
@@ -0,0 +1,25 @@+[+  26,+  [+    8,+    {+      "foo": [+        15,+        1+      ],+      "bar": [+        16,+        2+      ],+      "baz": true+    }+  ],+  [+    7,+    {+      "foo": "Integer",+      "bar": "Natural",+      "baz": "Bool"+    }+  ]+]
+ tests/parser/success/reservedPrefixA.dhall view
@@ -0,0 +1,1 @@+let TypeSynonym = Integer in 1 : TypeSynonym
+ tests/parser/success/reservedPrefixB.dhall view
@@ -0,0 +1,14 @@+[+  25,+  "TypeSynonym",+  null,+  "Integer",+  [+    26,+    [+      15,+      1+    ],+    "TypeSynonym"+  ]+]
+ tests/parser/success/singleQuotedStringA.dhall view
@@ -0,0 +1,4 @@+''+ABC+DEF+''
+ tests/parser/success/singleQuotedStringB.dhall view
@@ -0,0 +1,4 @@+[+  18,+  "ABC\nDEF\n"+]
+ tests/parser/success/sortA.dhall view
@@ -0,0 +1,1 @@+Sort
+ tests/parser/success/sortB.dhall view
@@ -0,0 +1,1 @@+"Sort"
+ tests/parser/success/templateA.dhall view
@@ -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 ""+ }+''
+ tests/parser/success/templateB.dhall view
@@ -0,0 +1,60 @@+[+  1,+  "record",+  [+    7,+    {+      "name": "Text",+      "value": "Double",+      "taxed_value": "Double",+      "in_ca": "Bool"+    }+  ],+  [+    18,+    "Hello ",+    [+      9,+      "record",+      "name"+    ],+    "\nYou have just won ",+    [+      0,+      "Double/show",+      [+        9,+        "record",+        "value"+      ]+    ],+    " dollars!\n",+    [+      14,+      [+        9,+        "record",+        "in_ca"+      ],+      [+        18,+        "Well, ",+        [+          0,+          "Double/show",+          [+            9,+            "record",+            "taxed_value"+          ]+        ],+        " dollars, after taxes"+      ],+      [+        18,+        ""+      ]+    ],+    "\n"+  ]+]
+ tests/parser/success/unicodeCommentA.dhall view
@@ -0,0 +1,3 @@+{- ∀(a : Type) → a -}++1
+ tests/parser/success/unicodeCommentB.dhall view
@@ -0,0 +1,4 @@+[+  15,+  1+]
+ tests/parser/success/unicodeDoubleQuotedStringA.dhall view
@@ -0,0 +1,1 @@+"∀(a : Type) → a"
+ tests/parser/success/unicodeDoubleQuotedStringB.dhall view
@@ -0,0 +1,4 @@+[+  18,+  "∀(a : Type) → a"+]
+ tests/parser/success/unionA.dhall view
@@ -0,0 +1,4 @@+< A : {   }+| B = { = }+| C : {}+> : < A : {} | B : {} | C : {} >
+ tests/parser/success/unionB.dhall view
@@ -0,0 +1,38 @@+[+  26,+  [+    12,+    "B",+    [+      8,+      {}+    ],+    {+      "A": [+        7,+        {}+      ],+      "C": [+        7,+        {}+      ]+    }+  ],+  [+    11,+    {+      "A": [+        7,+        {}+      ],+      "B": [+        7,+        {}+      ],+      "C": [+        7,+        {}+      ]+    }+  ]+]
+ tests/parser/success/urlsA.dhall view
@@ -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!$&'()*+,;=:@/?+]
+ tests/parser/success/urlsB.dhall view
@@ -0,0 +1,83 @@+[+  4,+  null,+  [+    24,+    0,+    "example.com",+    "someFile.dhall",+    null,+    null+  ],+  [+    24,+    1,+    "john:doe@example.com:8080",+    "foo",+    "bar",+    "qux=0",+    "xyzzy"+  ],+  [+    24,+    0,+    "prelude.dhall-lang.org",+    "package.dhall",+    null,+    null+  ],+  [+    24,+    1,+    "ipfs.io",+    "ipfs",+    "QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx",+    "Prelude",+    null,+    null+  ],+  [+    24,+    1,+    "raw.githubusercontent.com",+    "dhall-lang",+    "dhall-haskell",+    "18e4e9a18dc53271146df3ccf5b4177c3552236b",+    "examples",+    "True",+    null,+    null+  ],+  [+    24,+    1,+    "127.0.0.1",+    "index.dhall",+    null,+    null+  ],+  [+    24,+    1,+    "[::]",+    "index.dhall",+    null,+    null+  ],+  [+    24,+    1,+    "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]",+    "tutorial.dhall",+    null,+    null+  ],+  [+    24,+    1,+    "-._~%2C!$&'()*+,;=:@-._~%2C!$&'()*+,;=:",+    "foo",+    "/-._~%2C!$&'()*+,;=:@/?",+    "/-._~%2C!$&'()*+,;=:@/?"+  ]+]
+ tests/parser/success/whitespaceA.dhall view
@@ -0,0 +1,3 @@++1+
+ tests/parser/success/whitespaceB.dhall view
@@ -0,0 +1,4 @@+[+  15,+  1+]
+ tests/parser/success/whitespaceBuffetA.dhall view
@@ -0,0 +1,9 @@+    -- This+
+     Natural/even {-+
+{- file+-}
+  has+
+ -}  +2 -- mixed {- line endings -}
+ tests/parser/success/whitespaceBuffetB.dhall view
@@ -0,0 +1,8 @@+[+  0,+  "Natural/even",+  [+    16,+    2+  ]+]
− tests/parser/template.dhall 
@@ -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 ""- }-''
− tests/parser/unicodeComment.dhall 
@@ -1,3 +0,0 @@-{- ∀(a : Type) → a -}--1
− tests/parser/unicodeDoubleQuotedString.dhall 
@@ -1,1 +0,0 @@-"∀(a : Type) → a"
− tests/parser/union.dhall 
@@ -1,4 +0,0 @@-< A : {   }-| B = { = }-| C : {}-> : < A : {} | B : {} | C : {} >
− tests/parser/urls.dhall 
@@ -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!$&'()*+,;=:@/?-]
− tests/parser/whitespace.dhall 
@@ -1,3 +0,0 @@--1-
− tests/parser/whitespaceBuffet.dhall 
@@ -1,9 +0,0 @@-    -- This-
-     Natural/even {--
-{- file--}
-  has-
- -}  +2 -- mixed {- line endings -}
− tests/typecheck/alternativesAreTypesA.dhall 
@@ -1,1 +0,0 @@-< Left = List | Right : Type >
− tests/typecheck/alternativesAreTypesB.dhall 
@@ -1,1 +0,0 @@-< Left : Type → Type | Right : Type >
− tests/typecheck/anonymousFunctionsInTypesA.dhall 
@@ -1,5 +0,0 @@-    let anonymousFunction = λ(a : Type) → List a--in    λ(HigherOrderType : (Type → Type) → Type)-    → λ(x : HigherOrderType anonymousFunction)-    → (x : HigherOrderType anonymousFunction)
− tests/typecheck/anonymousFunctionsInTypesB.dhall 
@@ -1,4 +0,0 @@-  ∀(HigherOrderType : (Type → Type) → Type)-→ ∀(x : HigherOrderType (λ(a : Type) → List a))-→ HigherOrderType (λ(a : Type) → List a)-
− tests/typecheck/examples/Monoid/00A.dhall 
@@ -1,1 +0,0 @@-(../../../../Prelude/package.dhall).`Bool`.and
− tests/typecheck/examples/Monoid/00B.dhall 
@@ -1,1 +0,0 @@-../../../../Prelude/Monoid Bool
− tests/typecheck/examples/Monoid/01A.dhall 
@@ -1,1 +0,0 @@-(../../../../Prelude/package.dhall).`Bool`.or
− tests/typecheck/examples/Monoid/01B.dhall 
@@ -1,1 +0,0 @@-../../../../Prelude/Monoid Bool
− tests/typecheck/examples/Monoid/02A.dhall 
@@ -1,1 +0,0 @@-(../../../../Prelude/package.dhall).`Bool`.even
− tests/typecheck/examples/Monoid/02B.dhall 
@@ -1,1 +0,0 @@-../../../../Prelude/Monoid Bool
− tests/typecheck/examples/Monoid/03A.dhall 
@@ -1,1 +0,0 @@-(../../../../Prelude/package.dhall).`Bool`.odd
− tests/typecheck/examples/Monoid/03B.dhall 
@@ -1,1 +0,0 @@-../../../../Prelude/Monoid Bool
− tests/typecheck/examples/Monoid/04A.dhall 
@@ -1,1 +0,0 @@-(../../../../Prelude/package.dhall).`List`.concat
− tests/typecheck/examples/Monoid/04B.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → ../../../../Prelude/Monoid (List a)
− tests/typecheck/examples/Monoid/05A.dhall 
@@ -1,1 +0,0 @@-(../../../../Prelude/package.dhall).`List`.shifted
− tests/typecheck/examples/Monoid/05B.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → ../../../../Prelude/Monoid (List { index : Natural, value : a })
− tests/typecheck/examples/Monoid/06A.dhall 
@@ -1,1 +0,0 @@-(../../../../Prelude/package.dhall).`Natural`.sum
− tests/typecheck/examples/Monoid/06B.dhall 
@@ -1,1 +0,0 @@-../../../../Prelude/Monoid Natural
− tests/typecheck/examples/Monoid/07A.dhall 
@@ -1,1 +0,0 @@-(../../../../Prelude/package.dhall).`Natural`.product
− tests/typecheck/examples/Monoid/07B.dhall 
@@ -1,1 +0,0 @@-../../../../Prelude/Monoid Natural
− tests/typecheck/examples/Monoid/08A.dhall 
@@ -1,1 +0,0 @@-(../../../../Prelude/package.dhall).`Optional`.head
− tests/typecheck/examples/Monoid/08B.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → ../../../../Prelude/Monoid (Optional a)
− tests/typecheck/examples/Monoid/09A.dhall 
@@ -1,1 +0,0 @@-(../../../../Prelude/package.dhall).`Optional`.last
− tests/typecheck/examples/Monoid/09B.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → ../../../../Prelude/Monoid (Optional a)
− tests/typecheck/examples/Monoid/10A.dhall 
@@ -1,1 +0,0 @@-(../../../../Prelude/package.dhall).`Text`.concat
− tests/typecheck/examples/Monoid/10B.dhall 
@@ -1,1 +0,0 @@-../../../../Prelude/Monoid Text
+ tests/typecheck/failure/hurkensParadox.dhall view
@@ -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
− tests/typecheck/fieldsAreTypesA.dhall 
@@ -1,1 +0,0 @@-{ x = Bool, y = Text, z = List }
− tests/typecheck/fieldsAreTypesB.dhall 
@@ -1,1 +0,0 @@-{ x : Type, y : Type, z : Type → Type }
− tests/typecheck/kindParameterA.dhall 
@@ -1,1 +0,0 @@-λ(k : Kind) → λ(a : k → k → Type) → λ(x : k) → a x
− tests/typecheck/kindParameterB.dhall 
@@ -1,1 +0,0 @@-∀(k : Kind) → (k → k → Type) → k → k → Type
− tests/typecheck/mergeEquivalenceA.dhall 
@@ -1,6 +0,0 @@-    let Foo = < Bar : {} | Baz : {} >--in    λ(a : Type)-    → λ(f : {} → a)-    → λ(ts : Foo)-    → merge { Bar = λ(a : {}) → f a, Baz = f } ts
− tests/typecheck/mergeEquivalenceB.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → ∀(f : {} → a) → ∀(ts : < Bar : {} | Baz : {} >) → a
+ tests/typecheck/success/accessEncodedTypeA.dhall view
@@ -0,0 +1,4 @@+  λ ( record+    : ∀(k : Kind) → ∀(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k) → k+    )+→ record Type (λ(x : Type) → λ(y : Type → Type) → x)
+ tests/typecheck/success/accessEncodedTypeB.dhall view
@@ -0,0 +1,4 @@+  ∀ ( record+    : ∀(k : Kind) → ∀(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k) → k+    )+→ Type
+ tests/typecheck/success/accessTypeA.dhall view
@@ -0,0 +1,1 @@+λ(record : { x : Type, y : Type → Type }) → record.x
+ tests/typecheck/success/accessTypeB.dhall view
@@ -0,0 +1,1 @@+∀(record : { x : Type, y : Type → Type }) → Type
+ tests/typecheck/success/encodedRecordOfTypesA.dhall view
@@ -0,0 +1,3 @@+  λ(k : Kind)+→ λ(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k)+→ makeRecord Text List
+ tests/typecheck/success/encodedRecordOfTypesB.dhall view
@@ -0,0 +1,1 @@+∀(k : Kind) → ∀(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k) → k
+ tests/typecheck/success/prelude/Bool/and/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/and [ True, False, True ]
+ tests/typecheck/success/prelude/Bool/and/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/and/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/and ([] : List Bool)
+ tests/typecheck/success/prelude/Bool/and/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/build/0A.dhall view
@@ -0,0 +1,2 @@+../../../../../../Prelude/Bool/build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → true)
+ tests/typecheck/success/prelude/Bool/build/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/build/1A.dhall view
@@ -0,0 +1,2 @@+../../../../../../Prelude/Bool/build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → false)
+ tests/typecheck/success/prelude/Bool/build/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/even/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even [ False, True, False ]
+ tests/typecheck/success/prelude/Bool/even/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/even/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even [ False, True ]
+ tests/typecheck/success/prelude/Bool/even/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/even/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even [ False ]
+ tests/typecheck/success/prelude/Bool/even/2B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/even/3A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even ([] : List Bool)
+ tests/typecheck/success/prelude/Bool/even/3B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/fold/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/fold True Natural 0 1
+ tests/typecheck/success/prelude/Bool/fold/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Bool/fold/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/fold False Natural 0 1
+ tests/typecheck/success/prelude/Bool/fold/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Bool/not/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/not True
+ tests/typecheck/success/prelude/Bool/not/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/not/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/not False
+ tests/typecheck/success/prelude/Bool/not/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/odd/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd [ True, False, True ]
+ tests/typecheck/success/prelude/Bool/odd/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/odd/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd [ True, False ]
+ tests/typecheck/success/prelude/Bool/odd/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/odd/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd [ True ]
+ tests/typecheck/success/prelude/Bool/odd/2B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/odd/3A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd ([] : List Bool)
+ tests/typecheck/success/prelude/Bool/odd/3B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/or/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/or [ True, False, True ]
+ tests/typecheck/success/prelude/Bool/or/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/or/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/or ([] : List Bool)
+ tests/typecheck/success/prelude/Bool/or/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Bool/show/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/show True
+ tests/typecheck/success/prelude/Bool/show/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Bool/show/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/show False
+ tests/typecheck/success/prelude/Bool/show/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Double/show/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Double/show -3.1
+ tests/typecheck/success/prelude/Double/show/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Double/show/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Double/show 0.4
+ tests/typecheck/success/prelude/Double/show/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Integer/show/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/show -3
+ tests/typecheck/success/prelude/Integer/show/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Integer/show/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/show +0
+ tests/typecheck/success/prelude/Integer/show/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Integer/toDouble/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/toDouble -3
+ tests/typecheck/success/prelude/Integer/toDouble/0B.dhall view
@@ -0,0 +1,1 @@+Double
+ tests/typecheck/success/prelude/Integer/toDouble/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/toDouble +2
+ tests/typecheck/success/prelude/Integer/toDouble/1B.dhall view
@@ -0,0 +1,1 @@+Double
+ tests/typecheck/success/prelude/List/all/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/all Natural Natural/even [ 2, 3, 5 ]
+ tests/typecheck/success/prelude/List/all/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/List/all/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/all Natural Natural/even ([] : List Natural)
+ tests/typecheck/success/prelude/List/all/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/List/any/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/any Natural Natural/even [ 2, 3, 5 ]
+ tests/typecheck/success/prelude/List/any/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/List/any/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/any Natural Natural/even ([] : List Natural)
+ tests/typecheck/success/prelude/List/any/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/List/build/0A.dhall view
@@ -0,0 +1,7 @@+../../../../../../Prelude/List/build+Text+( λ(list : Type)+→ λ(cons : Text → list → list)+→ λ(nil : list)+→ cons "ABC" (cons "DEF" nil)+)
+ tests/typecheck/success/prelude/List/build/0B.dhall view
@@ -0,0 +1,1 @@+List Text
+ tests/typecheck/success/prelude/List/build/1A.dhall view
@@ -0,0 +1,7 @@+../../../../../../Prelude/List/build+Text+( λ(list : Type)+→ λ(cons : Text → list → list)+→ λ(nil : list)+→ nil+)
+ tests/typecheck/success/prelude/List/build/1B.dhall view
@@ -0,0 +1,1 @@+List Text
+ tests/typecheck/success/prelude/List/concat/0A.dhall view
@@ -0,0 +1,5 @@+../../../../../../Prelude/List/concat Natural+[ [ 0, 1, 2 ]+, [ 3, 4 ]+, [ 5, 6, 7, 8 ]+]
+ tests/typecheck/success/prelude/List/concat/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/concat/1A.dhall view
@@ -0,0 +1,5 @@+../../../../../../Prelude/List/concat Natural+[ [] : List Natural+, [] : List Natural+, [] : List Natural+]
+ tests/typecheck/success/prelude/List/concat/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/concatMap/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/concatMap Natural Natural (λ(n : Natural) → [ n, n ]) [ 2, 3, 5 ]
+ tests/typecheck/success/prelude/List/concatMap/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/concatMap/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/concatMap Natural Natural (λ(n : Natural) → [ n, n ]) ([] : List Natural)
+ tests/typecheck/success/prelude/List/concatMap/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/filter/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/filter Natural Natural/even [ 2, 3, 5 ]
+ tests/typecheck/success/prelude/List/filter/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/filter/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/filter Natural Natural/odd [ 2, 3, 5 ]
+ tests/typecheck/success/prelude/List/filter/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/fold/0A.dhall view
@@ -0,0 +1,6 @@+../../../../../../Prelude/List/fold+Natural+[ 2, 3, 5 ]+Natural+(λ(x : Natural) → λ(y : Natural) → x + y)+0
+ tests/typecheck/success/prelude/List/fold/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/List/fold/1A.dhall view
@@ -0,0 +1,7 @@+  λ(nil : Natural)+→ ../../../../../../Prelude/List/fold+  Natural+  [ 2, 3, 5 ]+  Natural+  (λ(x : Natural) → λ(y : Natural) → x + y)+  nil
+ tests/typecheck/success/prelude/List/fold/1B.dhall view
@@ -0,0 +1,1 @@+∀(nil : Natural) → Natural
+ tests/typecheck/success/prelude/List/fold/2A.dhall view
@@ -0,0 +1,4 @@+  λ(list : Type)+→ λ(cons : Natural → list → list)+→ λ(nil : list)+→ ../../../../../../Prelude/List/fold Natural [ 2, 3, 5 ] list cons nil
+ tests/typecheck/success/prelude/List/fold/2B.dhall view
@@ -0,0 +1,1 @@+∀(list : Type) → ∀(cons : Natural → list → list) → ∀(nil : list) → list
+ tests/typecheck/success/prelude/List/generate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/generate 5 Bool Natural/even
+ tests/typecheck/success/prelude/List/generate/0B.dhall view
@@ -0,0 +1,1 @@+List Bool
+ tests/typecheck/success/prelude/List/generate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/generate 0 Bool Natural/even
+ tests/typecheck/success/prelude/List/generate/1B.dhall view
@@ -0,0 +1,1 @@+List Bool
+ tests/typecheck/success/prelude/List/head/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/head Natural [ 0, 1, 2 ]
+ tests/typecheck/success/prelude/List/head/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/List/head/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/head Natural ([] : List Natural)
+ tests/typecheck/success/prelude/List/head/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/List/indexed/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/indexed Bool [ True, False, True ]
+ tests/typecheck/success/prelude/List/indexed/0B.dhall view
@@ -0,0 +1,1 @@+List { index : Natural, value : Bool }
+ tests/typecheck/success/prelude/List/indexed/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/indexed Bool ([] : List Bool)
+ tests/typecheck/success/prelude/List/indexed/1B.dhall view
@@ -0,0 +1,1 @@+List { index : Natural, value : Bool }
+ tests/typecheck/success/prelude/List/iterate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/iterate 10 Natural (λ(x : Natural) → x * 2) 1
+ tests/typecheck/success/prelude/List/iterate/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/iterate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/iterate 0 Natural (λ(x : Natural) → x * 2) 1
+ tests/typecheck/success/prelude/List/iterate/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/last/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/last Natural [ 0, 1, 2 ]
+ tests/typecheck/success/prelude/List/last/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/List/last/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/last Natural ([] : List Natural)
+ tests/typecheck/success/prelude/List/last/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/List/length/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/length Natural [ 0, 1, 2 ]
+ tests/typecheck/success/prelude/List/length/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/List/length/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/length Natural ([] : List Natural)
+ tests/typecheck/success/prelude/List/length/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/List/map/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/map Natural Bool Natural/even [ 2, 3, 5 ]
+ tests/typecheck/success/prelude/List/map/0B.dhall view
@@ -0,0 +1,1 @@+List Bool
+ tests/typecheck/success/prelude/List/map/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/map Natural Bool Natural/even ([] : List Natural)
+ tests/typecheck/success/prelude/List/map/1B.dhall view
@@ -0,0 +1,1 @@+List Bool
+ tests/typecheck/success/prelude/List/null/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/null Natural [ 0, 1, 2 ]
+ tests/typecheck/success/prelude/List/null/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/List/null/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/null Natural ([] : List Natural)
+ tests/typecheck/success/prelude/List/null/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/List/replicate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/replicate 9 Natural 1
+ tests/typecheck/success/prelude/List/replicate/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/replicate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/replicate 0 Natural 1
+ tests/typecheck/success/prelude/List/replicate/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/reverse/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/reverse Natural [ 0, 1, 2 ]
+ tests/typecheck/success/prelude/List/reverse/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/reverse/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/reverse Natural ([] : List Natural)
+ tests/typecheck/success/prelude/List/reverse/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/List/shifted/0A.dhall view
@@ -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 }+  ]+]
+ tests/typecheck/success/prelude/List/shifted/0B.dhall view
@@ -0,0 +1,1 @@+List { index : Natural, value : Bool }
+ tests/typecheck/success/prelude/List/shifted/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/shifted Bool ([] : List (List { index : Natural, value : Bool }))
+ tests/typecheck/success/prelude/List/shifted/1B.dhall view
@@ -0,0 +1,1 @@+List { index : Natural, value : Bool }
+ tests/typecheck/success/prelude/List/unzip/0A.dhall view
@@ -0,0 +1,7 @@+../../../../../../Prelude/List/unzip+Text+Bool+[ { _1 = "ABC", _2 = True }+, { _1 = "DEF", _2 = False }+, { _1 = "GHI", _2 = True }+]
+ tests/typecheck/success/prelude/List/unzip/0B.dhall view
@@ -0,0 +1,1 @@+{ _1 : List Text, _2 : List Bool }
+ tests/typecheck/success/prelude/List/unzip/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/unzip Text Bool ([] : List { _1 : Text, _2 : Bool })
+ tests/typecheck/success/prelude/List/unzip/1B.dhall view
@@ -0,0 +1,1 @@+{ _1 : List Text, _2 : List Bool }
+ tests/typecheck/success/prelude/Monoid/00A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Bool`.and
+ tests/typecheck/success/prelude/Monoid/00B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Bool
+ tests/typecheck/success/prelude/Monoid/01A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Bool`.or
+ tests/typecheck/success/prelude/Monoid/01B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Bool
+ tests/typecheck/success/prelude/Monoid/02A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Bool`.even
+ tests/typecheck/success/prelude/Monoid/02B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Bool
+ tests/typecheck/success/prelude/Monoid/03A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Bool`.odd
+ tests/typecheck/success/prelude/Monoid/03B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Bool
+ tests/typecheck/success/prelude/Monoid/04A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`List`.concat
+ tests/typecheck/success/prelude/Monoid/04B.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → ../../../../../Prelude/Monoid (List a)
+ tests/typecheck/success/prelude/Monoid/05A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`List`.shifted
+ tests/typecheck/success/prelude/Monoid/05B.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → ../../../../../Prelude/Monoid (List { index : Natural, value : a })
+ tests/typecheck/success/prelude/Monoid/06A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Natural`.sum
+ tests/typecheck/success/prelude/Monoid/06B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Natural
+ tests/typecheck/success/prelude/Monoid/07A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Natural`.product
+ tests/typecheck/success/prelude/Monoid/07B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Natural
+ tests/typecheck/success/prelude/Monoid/08A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Optional`.head
+ tests/typecheck/success/prelude/Monoid/08B.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → ../../../../../Prelude/Monoid (Optional a)
+ tests/typecheck/success/prelude/Monoid/09A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Optional`.last
+ tests/typecheck/success/prelude/Monoid/09B.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → ../../../../../Prelude/Monoid (Optional a)
+ tests/typecheck/success/prelude/Monoid/10A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Text`.concat
+ tests/typecheck/success/prelude/Monoid/10B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Text
+ tests/typecheck/success/prelude/Natural/build/0A.dhall view
@@ -0,0 +1,6 @@+../../../../../../Prelude/Natural/build+( λ(natural : Type)+→ λ(succ : natural → natural)+→ λ(zero : natural)+→ succ (succ (succ zero))+)
+ tests/typecheck/success/prelude/Natural/build/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Natural/build/1A.dhall view
@@ -0,0 +1,6 @@+../../../../../../Prelude/Natural/build+( λ(natural : Type)+→ λ(succ : natural → natural)+→ λ(zero : natural)+→ zero+)
+ tests/typecheck/success/prelude/Natural/build/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Natural/enumerate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/enumerate 10
+ tests/typecheck/success/prelude/Natural/enumerate/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/Natural/enumerate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/enumerate 0
+ tests/typecheck/success/prelude/Natural/enumerate/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/Natural/even/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/even 3
+ tests/typecheck/success/prelude/Natural/even/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Natural/even/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/even 0
+ tests/typecheck/success/prelude/Natural/even/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Natural/fold/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/fold 3 Natural (λ(x : Natural) → 5 * x) 1
+ tests/typecheck/success/prelude/Natural/fold/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Natural/fold/1A.dhall view
@@ -0,0 +1,1 @@+λ(zero : Natural) → ../../../../../../Prelude/Natural/fold 3 Natural (λ(x : Natural) → 5 * x) zero
+ tests/typecheck/success/prelude/Natural/fold/1B.dhall view
@@ -0,0 +1,1 @@+∀(zero : Natural) → Natural
+ tests/typecheck/success/prelude/Natural/fold/2A.dhall view
@@ -0,0 +1,4 @@+  λ(natural : Type)+→ λ(succ : natural → natural)+→ λ(zero : natural)+→ ../../../../../../Prelude/Natural/fold 3 natural succ zero
+ tests/typecheck/success/prelude/Natural/fold/2B.dhall view
@@ -0,0 +1,1 @@+∀(natural : Type) → ∀(succ : natural → natural) → ∀(zero : natural) → natural
+ tests/typecheck/success/prelude/Natural/isZero/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/isZero 2
+ tests/typecheck/success/prelude/Natural/isZero/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Natural/isZero/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/isZero 0
+ tests/typecheck/success/prelude/Natural/isZero/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Natural/odd/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/odd 3
+ tests/typecheck/success/prelude/Natural/odd/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Natural/odd/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/odd 0
+ tests/typecheck/success/prelude/Natural/odd/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Natural/product/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/product [ 2, 3, 5 ]
+ tests/typecheck/success/prelude/Natural/product/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Natural/product/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/product ([] : List Natural)
+ tests/typecheck/success/prelude/Natural/product/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Natural/show/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/show 3
+ tests/typecheck/success/prelude/Natural/show/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Natural/show/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/show 0
+ tests/typecheck/success/prelude/Natural/show/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Natural/sum/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/sum [ 2, 3, 5 ]
+ tests/typecheck/success/prelude/Natural/sum/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Natural/sum/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/sum ([] : List Natural)
+ tests/typecheck/success/prelude/Natural/sum/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Natural/toDouble/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/toDouble 3
+ tests/typecheck/success/prelude/Natural/toDouble/0B.dhall view
@@ -0,0 +1,1 @@+Double
+ tests/typecheck/success/prelude/Natural/toDouble/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/toDouble 0
+ tests/typecheck/success/prelude/Natural/toDouble/1B.dhall view
@@ -0,0 +1,1 @@+Double
+ tests/typecheck/success/prelude/Natural/toInteger/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/toInteger 3
+ tests/typecheck/success/prelude/Natural/toInteger/0B.dhall view
@@ -0,0 +1,1 @@+Integer
+ tests/typecheck/success/prelude/Natural/toInteger/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/toInteger 0
+ tests/typecheck/success/prelude/Natural/toInteger/1B.dhall view
@@ -0,0 +1,1 @@+Integer
+ tests/typecheck/success/prelude/Optional/all/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/all Natural Natural/even (Some 3)
+ tests/typecheck/success/prelude/Optional/all/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Optional/all/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/all Natural Natural/even (None Natural)
+ tests/typecheck/success/prelude/Optional/all/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Optional/any/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/any Natural Natural/even (Some 2)
+ tests/typecheck/success/prelude/Optional/any/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Optional/any/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/any Natural Natural/even (None Natural)
+ tests/typecheck/success/prelude/Optional/any/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Optional/build/0A.dhall view
@@ -0,0 +1,7 @@+../../../../../../Prelude/Optional/build+Natural+( λ(optional : Type)+→ λ(some : Natural → optional)+→ λ(none : optional)+→ some 1+)
+ tests/typecheck/success/prelude/Optional/build/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/build/1A.dhall view
@@ -0,0 +1,7 @@+../../../../../../Prelude/Optional/build+Natural+( λ(optional : Type)+→ λ(some : Natural → optional)+→ λ(none : optional)+→ none+)
+ tests/typecheck/success/prelude/Optional/build/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/concat/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/concat Natural (Some (Some 1))
+ tests/typecheck/success/prelude/Optional/concat/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/concat/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/concat Natural (Some (None Natural))
+ tests/typecheck/success/prelude/Optional/concat/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/concat/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/concat Natural (None (Optional Natural))
+ tests/typecheck/success/prelude/Optional/concat/2B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/filter/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/filter Natural Natural/even (Some 2)
+ tests/typecheck/success/prelude/Optional/filter/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/filter/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/filter Natural Natural/odd (Some 2)
+ tests/typecheck/success/prelude/Optional/filter/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/fold/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/fold Natural (Some 2) Natural (λ(x : Natural) → x) 0
+ tests/typecheck/success/prelude/Optional/fold/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Optional/fold/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/fold Natural (None Natural) Natural (λ(x : Natural) → x) 0
+ tests/typecheck/success/prelude/Optional/fold/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Optional/head/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/head Natural [ None Natural, Some 1, Some 2 ]
+ tests/typecheck/success/prelude/Optional/head/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/head/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/head Natural [ None Natural, None Natural ]
+ tests/typecheck/success/prelude/Optional/head/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/head/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/head Natural ([] : List (Optional Natural))
+ tests/typecheck/success/prelude/Optional/head/2B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/last/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/last Natural [ None Natural, Some 1, Some 2 ]
+ tests/typecheck/success/prelude/Optional/last/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/last/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/last Natural [ None Natural, None Natural ]
+ tests/typecheck/success/prelude/Optional/last/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/last/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/last Natural ([] : List (Optional Natural))
+ tests/typecheck/success/prelude/Optional/last/2B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ tests/typecheck/success/prelude/Optional/length/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/length Natural (Some 2)
+ tests/typecheck/success/prelude/Optional/length/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Optional/length/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/length Natural (None Natural)
+ tests/typecheck/success/prelude/Optional/length/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ tests/typecheck/success/prelude/Optional/map/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/map Natural Bool Natural/even (Some 3)
+ tests/typecheck/success/prelude/Optional/map/0B.dhall view
@@ -0,0 +1,1 @@+Optional Bool
+ tests/typecheck/success/prelude/Optional/map/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/map Natural Bool Natural/even (None Natural)
+ tests/typecheck/success/prelude/Optional/map/1B.dhall view
@@ -0,0 +1,1 @@+Optional Bool
+ tests/typecheck/success/prelude/Optional/null/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/null Natural (Some 2)
+ tests/typecheck/success/prelude/Optional/null/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Optional/null/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/null Natural (None Natural)
+ tests/typecheck/success/prelude/Optional/null/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ tests/typecheck/success/prelude/Optional/toList/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/toList Natural (Some 1)
+ tests/typecheck/success/prelude/Optional/toList/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/Optional/toList/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/toList Natural (None Natural)
+ tests/typecheck/success/prelude/Optional/toList/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ tests/typecheck/success/prelude/Optional/unzip/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/unzip Text Bool (Some { _1 = "ABC", _2 = True })
+ tests/typecheck/success/prelude/Optional/unzip/0B.dhall view
@@ -0,0 +1,1 @@+{ _1 : Optional Text, _2 : Optional Bool }
+ tests/typecheck/success/prelude/Optional/unzip/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/unzip Text Bool (None { _1 : Text, _2 : Bool })
+ tests/typecheck/success/prelude/Optional/unzip/1B.dhall view
@@ -0,0 +1,1 @@+{ _1 : Optional Text, _2 : Optional Bool }
+ tests/typecheck/success/prelude/Text/concat/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concat [ "ABC", "DEF", "GHI" ]
+ tests/typecheck/success/prelude/Text/concat/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Text/concat/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concat ([] : List Text)
+ tests/typecheck/success/prelude/Text/concat/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Text/concatMap/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concatMap Natural (λ(n : Natural) → "${Natural/show n} ") [ 0, 1, 2 ]
+ tests/typecheck/success/prelude/Text/concatMap/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Text/concatMap/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concatMap Natural (λ(n : Natural) → "${Natural/show n} ") ([] : List Natural)
+ tests/typecheck/success/prelude/Text/concatMap/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concatMapSep ", " Natural Natural/show [ 0, 1, 2 ]
+ tests/typecheck/success/prelude/Text/concatMapSep/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concatMapSep ", " Natural Natural/show ([] : List Natural)
+ tests/typecheck/success/prelude/Text/concatMapSep/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Text/concatSep/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concatSep ", " [ "ABC", "DEF", "GHI" ]
+ tests/typecheck/success/prelude/Text/concatSep/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/prelude/Text/concatSep/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concatSep ", " ([] : List Text)
+ tests/typecheck/success/prelude/Text/concatSep/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ tests/typecheck/success/recordOfTypesA.dhall view
@@ -0,0 +1,1 @@+{ x = Text, y = List }
+ tests/typecheck/success/recordOfTypesB.dhall view
@@ -0,0 +1,1 @@+{ x : Type, y : Type → Type }
+ tests/typecheck/success/simple/access/0A.dhall view
@@ -0,0 +1,1 @@+{ x = Text }.x
+ tests/typecheck/success/simple/access/0B.dhall view
@@ -0,0 +1,1 @@+Type
+ tests/typecheck/success/simple/access/1A.dhall view
@@ -0,0 +1,1 @@+< Foo : Text | Bar : Natural >.Foo
+ tests/typecheck/success/simple/access/1B.dhall view
@@ -0,0 +1,1 @@+∀(Foo : Text) → < Bar : Natural | Foo : Text >
+ tests/typecheck/success/simple/alternativesAreTypesA.dhall view
@@ -0,0 +1,1 @@+< Left = List | Right : Type >
+ tests/typecheck/success/simple/alternativesAreTypesB.dhall view
@@ -0,0 +1,1 @@+< Left : Type → Type | Right : Type >
+ tests/typecheck/success/simple/anonymousFunctionsInTypesA.dhall view
@@ -0,0 +1,5 @@+    let anonymousFunction = λ(a : Type) → List a++in    λ(HigherOrderType : (Type → Type) → Type)+    → λ(x : HigherOrderType anonymousFunction)+    → (x : HigherOrderType anonymousFunction)
+ tests/typecheck/success/simple/anonymousFunctionsInTypesB.dhall view
@@ -0,0 +1,4 @@+  ∀(HigherOrderType : (Type → Type) → Type)+→ ∀(x : HigherOrderType (λ(a : Type) → List a))+→ HigherOrderType (λ(a : Type) → List a)+
+ tests/typecheck/success/simple/fieldsAreTypesA.dhall view
@@ -0,0 +1,1 @@+{ x = Bool, y = Text, z = List }
+ tests/typecheck/success/simple/fieldsAreTypesB.dhall view
@@ -0,0 +1,1 @@+{ x : Type, y : Type, z : Type → Type }
+ tests/typecheck/success/simple/kindParameterA.dhall view
@@ -0,0 +1,1 @@+λ(k : Kind) → λ(a : k → k → Type) → λ(x : k) → a x
+ tests/typecheck/success/simple/kindParameterB.dhall view
@@ -0,0 +1,1 @@+∀(k : Kind) → (k → k → Type) → k → k → Type
+ tests/typecheck/success/simple/mergeEquivalenceA.dhall view
@@ -0,0 +1,6 @@+    let Foo = < Bar : {} | Baz : {} >++in    λ(a : Type)+    → λ(f : {} → a)+    → λ(ts : Foo)+    → merge { Bar = λ(a : {}) → f a, Baz = f } ts
+ tests/typecheck/success/simple/mergeEquivalenceB.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → ∀(f : {} → a) → ∀(ts : < Bar : {} | Baz : {} >) → a
+ tests/typecheck/success/simple/mixedFieldAccessA.dhall view
@@ -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 {=}
+ tests/typecheck/success/simple/mixedFieldAccessB.dhall view
@@ -0,0 +1,1 @@+< Private : {} | Public : {} >