packages feed

dhall 1.20.1 → 1.21.0

raw patch · 1591 files changed

+5477/−5380 lines, 1591 filesdep ~QuickCheckbinary-addedPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: QuickCheck

API changes (from Hackage documentation)

- 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: instance GHC.Show.Show Dhall.InvalidType
- Dhall.Binary: CannotDecodeVersionString :: Term -> DecodingFailure
- Dhall.Binary: UnsupportedVersionString :: Text -> DecodingFailure
- Dhall.Binary: decodeWithVersion :: Term -> Either DecodingFailure (Expr s Import)
- Dhall.Binary: encodeWithVersion :: StandardVersion -> Expr s Import -> Term
- Dhall.Binary: instance GHC.Exception.Exception Dhall.Binary.DecodingFailure
- Dhall.Core: Constructors :: (Expr s a) -> Expr s a
- Dhall.Freeze: hashImport :: FilePath -> StandardVersion -> Import -> IO Import
- 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.Main: [dot] :: Mode -> Bool
- Dhall.Parser: instance GHC.Exception.Exception Dhall.Parser.ParseError
- 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: (>|<) :: UnionInputType a -> UnionInputType b -> UnionInputType (Either a b)
+ Dhall: UnionInputType :: Product (Const (Map Text (Expr Src X))) (Op (Text, Expr Src X)) a -> UnionInputType a
+ Dhall: UnionType :: Compose (Map Text) Type a -> UnionType a
+ Dhall: [inputNormalizer] :: InterpretOptions -> ReifiedNormalizer X
+ Dhall: [invalidTypeExpected] :: InvalidType s a -> Expr s a
+ Dhall: [invalidTypeExpression] :: InvalidType s a -> Expr s a
+ Dhall: constructor :: Text -> Type a -> UnionType a
+ Dhall: inputConstructor :: Inject a => Text -> UnionInputType a
+ Dhall: inputConstructorWith :: Text -> InputType a -> UnionInputType a
+ Dhall: inputUnion :: UnionInputType a -> InputType a
+ Dhall: instance (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.InvalidType s a)
+ Dhall: instance (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.Show.Show (Dhall.InvalidType s a)
+ Dhall: instance Data.Functor.Contravariant.Contravariant Dhall.UnionInputType
+ 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.Base.Functor Dhall.UnionType
+ Dhall: instance GHC.Base.Monoid (Dhall.UnionType a)
+ Dhall: instance GHC.Base.Semigroup (Dhall.UnionType a)
+ Dhall: newtype UnionInputType a
+ Dhall: newtype UnionType a
+ Dhall: union :: UnionType a -> Type a
+ Dhall.Binary: NoVersion :: StandardVersion
+ Dhall.Binary: V_1_0_0 :: StandardVersion
+ Dhall.Binary: V_2_0_0 :: StandardVersion
+ Dhall.Binary: V_3_0_0 :: StandardVersion
+ Dhall.Binary: V_4_0_0 :: StandardVersion
+ Dhall.Binary: decode :: Term -> Either DecodingFailure (Expr s Import)
+ Dhall.Binary: encode :: Expr s Import -> Term
+ Dhall.Binary: instance GHC.Enum.Bounded Dhall.Binary.StandardVersion
+ Dhall.Binary: instance GHC.Enum.Enum Dhall.Binary.StandardVersion
+ Dhall.Binary: instance GHC.Exception.Type.Exception Dhall.Binary.DecodingFailure
+ Dhall.Binary: renderStandardVersion :: StandardVersion -> Text
+ Dhall.Core: TextShow :: Expr s a
+ Dhall.Format: Check :: Maybe FilePath -> FormatMode
+ Dhall.Format: Format :: CharacterSet -> FormatMode -> Format
+ Dhall.Format: Modify :: Maybe FilePath -> FormatMode
+ Dhall.Format: [characterSet] :: Format -> CharacterSet
+ Dhall.Format: [formatMode] :: Format -> FormatMode
+ Dhall.Format: [inplace] :: FormatMode -> Maybe FilePath
+ Dhall.Format: [path] :: FormatMode -> Maybe FilePath
+ Dhall.Format: data Format
+ Dhall.Format: data FormatMode
+ Dhall.Format: instance GHC.Exception.Type.Exception Dhall.Format.NotFormatted
+ Dhall.Format: instance GHC.Show.Show Dhall.Format.NotFormatted
+ Dhall.Freeze: freezeImport :: FilePath -> StandardVersion -> Import -> IO Import
+ Dhall.Freeze: freezeRemoteImport :: FilePath -> StandardVersion -> Import -> IO Import
+ 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.Lint: optionalLitToSomeNone :: Expr s a -> Maybe (Expr s a)
+ Dhall.Lint: removeLetInLet :: Eq a => Expr s a -> Maybe (Expr s a)
+ Dhall.Lint: removeUnusedBindings :: Eq a => Expr s a -> Maybe (Expr s a)
+ Dhall.Main: [all_] :: Mode -> Bool
+ Dhall.Main: [formatMode] :: Mode -> FormatMode
+ Dhall.Main: [resolveMode] :: Mode -> Maybe ResolveMode
+ Dhall.Parser: SourcedException :: Src -> e -> SourcedException e
+ Dhall.Parser: data SourcedException e
+ Dhall.Parser: instance GHC.Exception.Type.Exception Dhall.Parser.ParseError
+ 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) -> ReifiedNormalizer X -> InterpretOptions
- Dhall: InvalidType :: InvalidType
+ Dhall: InvalidType :: Expr s a -> Expr s a -> InvalidType s a
- 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: data InvalidType
+ Dhall: data InvalidType s 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: 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 :: (NonEmpty (Binding 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.Format: format :: CharacterSet -> Maybe FilePath -> IO ()
+ Dhall.Format: format :: Format -> IO ()
- Dhall.Freeze: freeze :: Maybe FilePath -> StandardVersion -> IO ()
+ Dhall.Freeze: freeze :: Maybe FilePath -> Bool -> StandardVersion -> IO ()
- Dhall.Import: hashExpression :: StandardVersion -> Expr s X -> (Digest SHA256)
+ Dhall.Import: hashExpression :: StandardVersion -> Expr s X -> Digest SHA256
- Dhall.Main: Format :: Maybe FilePath -> Mode
+ Dhall.Main: Format :: FormatMode -> Mode
- Dhall.Main: Freeze :: Maybe FilePath -> Mode
+ Dhall.Main: Freeze :: Maybe FilePath -> Bool -> Mode
- Dhall.Main: Resolve :: Bool -> Mode
+ Dhall.Main: Resolve :: Maybe ResolveMode -> Mode
- Dhall.Set: Set :: (Set a) -> (Seq a) -> Set a
+ Dhall.Set: Set :: Set a -> Seq a -> Set a
- Dhall.TypeCheck: AlternativeAnnotationMismatch :: Text -> (Expr s a) -> Const -> Text -> (Expr s a) -> Const -> TypeMessage s a
+ Dhall.TypeCheck: AlternativeAnnotationMismatch :: Text -> Expr s a -> Const -> Text -> Expr s a -> Const -> TypeMessage s a
- 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: CantAccess :: Text -> (Expr s a) -> (Expr s a) -> TypeMessage s a
+ Dhall.TypeCheck: CantAccess :: Text -> 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: CantProject :: 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: 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,105 @@+1.21.0++* Supports version 6.0.0 of the language standard+    * See: https://github.com/dhall-lang/dhall-lang/releases/tag/v6.0.0+* BREAKING CHANGE: Remove the `constructors` keyword+    * ... as standardized in version 6.0.0 of the language standard+    * The deprecation cycle is over, so the keyword is no longer supported+    * For more details, see: https://github.com/dhall-lang/dhall-lang/wiki/Migration%3A-Deprecation-of-constructors-keyword+    * See: https://github.com/dhall-lang/dhall-haskell/pull/829+* BREAKING CHANGE: CBOR-encode only special `Double`s as half-floats+    * ... as standardized in version 6.0.0 of the language standard+    * CBOR `Double`s except `Infinity`/`-Infinity`/`NaN`/`0.0` are now encoded in at+      least 32 bits+    * See: https://github.com/dhall-lang/dhall-haskell/pull/822+* BREAKING CHANGE: Sort record and union fields when CBOR-encoding+    * Fields and alternatives are now sorted when serialized+    * This does not affect semantic integrity checks, which already sorted these+      fields/alternatives before hashing expressions+    * This does affect the serialization of expressions that have not been+      normalized (e.g. uninterpreted expressions transmitted over the wire)+    * See: https://github.com/dhall-lang/dhall-haskell/pull/835+* BUG FIX: Fix non-exhaustive pattern match in `dhall lint`+    * This fixes: `Irrefutable pattern failed for pattern Let (l' :| ls') d'`+    * This bug would cause `dhall lint` to fail on some nested `let`/`in`+      expressions+    * See: https://github.com/dhall-lang/dhall-haskell/pull/780+    * See: https://github.com/dhall-lang/dhall-haskell/pull/784+* BUG FIX: Don't fail if `$HOME` environment variable is unset+    * The interpreter was incorrectly throwing an exception if `HOME` was unset+    * The standard requires that implementations should handle the `HOME`+      environment variable being missing+    * See: https://github.com/dhall-lang/dhall-haskell/pull/789+* Feature: Remove version tag from semantic integrity check+    * ... as standardized in version 6.0.0 of the language standard+    * This is not a breaking change because this change also includes+      backwards-compatible support for semantic integrity checks produced by+      older versions of the interpreter+* Feature: Support Unicode path components+    * ... as standardized in version 6.0.0 of the language standard+    * You can now use Unicode in path components if they are quoted+    * i.e. `./families/"禺.dhall"` is now legal+* Feature: Add `Text/show` built-in+    * ... as standardized in version 6.0.0 of the language standard+    * You can now convert a `Text` literal to its equivalent Dhall source code+      (which is itself a `Text` literal)+    * This comes in handy when using Dhall code to generate JSON or Dhall code+    * See: https://github.com/dhall-lang/dhall-haskell/pull/811+* Feature: Add `--immediate-dependencies`/`--transitive-dependencies` flags for+  `dhall resolve`+    * You can now retrieve all of your immediate or transitive dependencies as a+      textual list+    * This simplifies integration with other command-line tools (such as file+      watchers)+    * See: https://github.com/dhall-lang/dhall-haskell/pull/795+    * See: https://github.com/dhall-lang/dhall-haskell/pull/803+* Feature: `dhall freeze` now only freezes remote imports by default+    * `dhall freeze` used to freeze all imports (including local imports and+      environment variables)+    * Now `dhall freeze` only freezes remote imports by default, which is what+      most users want+    * You can install freeze all imports using the `--all` flag+    * See: https://github.com/dhall-lang/dhall-haskell/pull/808+* Feature: `:save` and `:load` REPL state+    * `:save` with no arguments now saves the REPL state to a `.dhall-repl-N`+       file+    * The file format is a list of `dhall repl` commands+    * You can use `:load` to load the saved state back into the REPL+    * See: https://github.com/dhall-lang/dhall-haskell/pull/807+* Feature: Add `:hash` command to `dhall repl`+    * This lets you conveniently hash expressions within the `dhall repl`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/806+* Feature: Add `--check` flag to `dhall format`+    * Use this to check if the input is already formatted+    * Useful for continuous integration when you want to ensure that all code+      under version control remains formatted+    * See: https://github.com/dhall-lang/dhall-haskell/pull/810+* Feature: Add  `UnionInputType` builder for `InputType`s+    * This is the union analog of `RecordInputType`, letting you build a+      record explicitly instead of deriving the instance using GHC generics+    * See: https://github.com/dhall-lang/dhall-haskell/pull/775+* Feature: Add `:set`/`:unset` commands to `dhall repl`+    * You can use these commands to set or unset command-line options+    * Currently only setting/unsetting `--explain` is supported+* Standards-compliance fixes:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/779+    * See: https://github.com/dhall-lang/dhall-haskell/pull/804+    * See: https://github.com/dhall-lang/dhall-haskell/pull/833+* Documentation fixes:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/792+    * See: https://github.com/dhall-lang/dhall-haskell/pull/825+* Test fixes:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/782+    * See: https://github.com/dhall-lang/dhall-haskell/pull/836+* Improved error messages:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/812+    * See: https://github.com/dhall-lang/dhall-haskell/pull/815+    * See: https://github.com/dhall-lang/dhall-haskell/pull/824+* Formatting fixes:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/831+* REPL fixes:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/837+ 1.20.1  * BUG FIX: Fix binary encoding to use correct standard version
− Prelude/Monoid 
@@ -1,1 +0,0 @@-https://raw.githubusercontent.com/dhall-lang/Prelude/a22da69657b9316a3c51ba0bf80c9d4024db3fce/Monoid sha256:b306524b2f7fedd7dad0d328990e0b6271d93d6f2fbe7156474b757f5d8de187
− Prelude/package.dhall 
@@ -1,1 +0,0 @@-https://raw.githubusercontent.com/dhall-lang/Prelude/e9c90396c02f9eb0fe66c00c544615cbfa068f34/package.dhall sha256:26e13b153cb428366610110d4d8f0c135e22b20179d5478bb16b1b83b3f2ca13
benchmark/parser/Main.hs view
@@ -72,7 +72,7 @@         term <- case Codec.Serialise.deserialiseOrFail bytes of             Left  _    -> Nothing             Right term -> return term-        case Dhall.Binary.decodeWithVersion term of+        case Dhall.Binary.decode term of             Left  _          -> Nothing             Right expression -> return expression
+ dhall-lang/Prelude/Bool/and view
@@ -0,0 +1,18 @@+{-+The `and` function returns `False` if there are any `False` elements in the+`List` and returns `True` otherwise++Examples:++```+./and [ True, False, True ] = False++./and ([] : List Bool) = True+```+-}+    let and+        : List Bool → Bool+        =   λ(xs : List Bool)+          → List/fold Bool xs Bool (λ(l : Bool) → λ(r : Bool) → l && r) True++in  and
+ dhall-lang/Prelude/Bool/build view
@@ -0,0 +1,17 @@+{-+`build` is the inverse of `fold`++Examples:++```+./build (λ(bool : Type) → λ(true : bool) → λ(false : bool) → true) = True++./build (λ(bool : Type) → λ(true : bool) → λ(false : bool) → false) = False+```+-}+    let build+        : (∀(bool : Type) → ∀(true : bool) → ∀(false : bool) → bool) → Bool+        =   λ(f : ∀(bool : Type) → ∀(true : bool) → ∀(false : bool) → bool)+          → f Bool True False++in  build
+ dhall-lang/Prelude/Bool/even view
@@ -0,0 +1,22 @@+{-+Returns `True` if there are an even number of `False` elements in the list and+returns `False` otherwise++Examples:++```+./even [ False, True, False ] = True++./even [ False, True ] = False++./even [ False ] = False++./even ([] : List Bool) = True+```+-}+    let even+        : List Bool → Bool+        =   λ(xs : List Bool)+          → List/fold Bool xs Bool (λ(x : Bool) → λ(y : Bool) → x == y) True++in  even
+ dhall-lang/Prelude/Bool/fold view
@@ -0,0 +1,20 @@+{-+`fold` is essentially the same as `if`/`then`/else` except as a function++Examples:++```+./fold True Natural 0 1 = 0++./fold False Natural 0 1 = 1+```+-}+    let fold+        : ∀(b : Bool) → ∀(bool : Type) → ∀(true : bool) → ∀(false : bool) → bool+        =   λ(b : Bool)+          → λ(bool : Type)+          → λ(true : bool)+          → λ(false : bool)+          → if b then true else false++in  fold
+ dhall-lang/Prelude/Bool/not view
@@ -0,0 +1,12 @@+{-+Flip the value of a `Bool`++Examples:++```+./not True = False++./not False = True+```+-}+let not : Bool → Bool = λ(b : Bool) → b == False in not
+ dhall-lang/Prelude/Bool/odd view
@@ -0,0 +1,22 @@+{-+Returns `True` if there are an odd number of `True` elements in the list and+returns `False` otherwise++Examples:++```+./odd [ True, False, True ] = False++./odd [ True, False ] = True++./odd [ True ] = True++./odd ([] : List Bool) = False+```+-}+    let odd+        : List Bool → Bool+        =   λ(xs : List Bool)+          → List/fold Bool xs Bool (λ(x : Bool) → λ(y : Bool) → x != y) False++in  odd
+ dhall-lang/Prelude/Bool/or view
@@ -0,0 +1,18 @@+{-+The `or` function returns `True` if there are any `True` elements in the `List`+and returns `False` otherwise++Examples:++```+./or [ True, False, True ] = True++./or ([] : List Bool) = False+```+-}+    let or+        : List Bool → Bool+        =   λ(xs : List Bool)+          → List/fold Bool xs Bool (λ(l : Bool) → λ(r : Bool) → l || r) False++in  or
+ dhall-lang/Prelude/Bool/package.dhall view
@@ -0,0 +1,17 @@+{ and =+    ./and+, build =+    ./build+, even =+    ./even+, fold =+    ./fold+, not =+    ./not+, odd =+    ./odd+, or =+    ./or+, show =+    ./show+}
+ dhall-lang/Prelude/Bool/show view
@@ -0,0 +1,13 @@+{-+Render a `Bool` as `Text` using the same representation as Dhall source code+(i.e. beginning with a capital letter)++Examples:++```+./show True  = "True"++./show False = "False"+```+-}+let show : Bool → Text = λ(b : Bool) → if b then "True" else "False" in show
+ dhall-lang/Prelude/Double/package.dhall view
@@ -0,0 +1,1 @@+{ show = ./show }
+ dhall-lang/Prelude/Double/show view
@@ -0,0 +1,13 @@+{-+Render a `Double` as `Text` using the same representation as Dhall source+code (i.e. a decimal floating point number with a leading `-` sign if negative)++Examples:++```+./show -3.1 = "-3.1"++./show  0.4 =  "0.4"+```+-}+let show : Double → Text = Double/show in show
+ dhall-lang/Prelude/Function/compose view
@@ -0,0 +1,21 @@+{-+Compose two functions into one.++Examples:++```+./compose Natural Natural Bool (λ(n : Natural) → n + n) ../Natural/even 3+= True+```+-}+    let compose+        : ∀(a : Type) → ∀(b : Type) → ∀(c : Type) → (a → b) → (b → c) → a → c+        =   λ(A : Type)+          → λ(B : Type)+          → λ(C : Type)+          → λ(f : A → B)+          → λ(g : B → C)+          → λ(x : A)+          → g (f x)++in  compose
+ dhall-lang/Prelude/Function/package.dhall view
@@ -0,0 +1,1 @@+{ compose = ./compose }
+ dhall-lang/Prelude/Integer/package.dhall view
@@ -0,0 +1,1 @@+{ show = ./show, toDouble = ./toDouble }
+ dhall-lang/Prelude/Integer/show view
@@ -0,0 +1,14 @@+{-+Render an `Integer` as `Text` using the same representation as Dhall source+code (i.e. a decimal number with a leading `-` sign if negative and a leading+`+` sign if non-negative)++Examples:++```+./show -3 = "-3"++./show +0 = "+0"+```+-}+let show : Integer → Text = Integer/show in show
+ dhall-lang/Prelude/Integer/toDouble view
@@ -0,0 +1,12 @@+{-+Convert an `Integer` to the corresponding `Double`++Examples:++```+./toDouble -3 = -3.0++./toDouble +2 = 2.0+```+-}+let toDouble : Integer → Double = Integer/toDouble in toDouble
+ dhall-lang/Prelude/JSON/Nesting view
@@ -0,0 +1,32 @@+{-+This type is used as part of `dhall-json`'s support for preserving alternative+names++For example, this Dhall code:++```+    let Example = < Left : { foo : Natural } | Right : { bar : Bool } >++in  let example = constructors Example++in  let Nesting = < Inline : {} | Nested : Text >++in  let nesting = constructors Nesting++in  { field    = "name"+    , nesting  = nesting.Inline {=}+    , contents = example.Left { foo = 2 }+    }+```++... generates this JSON:++```+{+  "foo": 2,+  "name": "Left"+ }+```++-}+let Nesting : Type = < Inline : {} | Nested : Text > in Nesting
+ dhall-lang/Prelude/JSON/Tagged view
@@ -0,0 +1,69 @@+{-+This is a convenient type-level function when using `dhall-to-json`'s support+for preserving alternative names++For example, this code:++```+    let map = ../List/map++in  let Provisioner =+          < shell :+              { inline : List Text }+          | file :+              { source : Text, destination : Text }+          >++in  let provisioner = constructors Provisioner++in  let Tagged = ./Tagged++in  let nesting = constructors ./Nesting++in  let wrap+        : Provisioner → Tagged Provisioner+        =   λ(x : Provisioner)+          → { field = "type", nesting = nesting.Nested "params", contents = x }++in  { provisioners =+        map+        Provisioner+        (Tagged Provisioner)+        wrap+        [ provisioner.shell { inline = [ "echo foo" ] }+        , provisioner.file+          { source = "app.tar.gz", destination = "/tmp/app.tar.gz" }+        ]+    }+```++... produces this JSON:++```+{+  "provisioners": [+    {+      "params": {+        "inline": [+          "echo foo"+        ]+      },+      "type": "shell"+    },+    {+      "params": {+        "destination": "/tmp/app.tar.gz",+        "source": "app.tar.gz"+      },+      "type": "file"+    }+  ]+}+```++-}+    let Tagged+        : Type → Type+        = λ(a : Type) → { field : Text, nesting : ./Nesting, contents : a }++in  Tagged
+ dhall-lang/Prelude/JSON/keyText view
@@ -0,0 +1,17 @@+{-+Builds a key-value record such that a List of them will be converted to a+homogeneous record by dhall-to-json and dhall-to-yaml.+Both key and value are fixed to Text.+Take a look at `Record/keyValue` for a polymorphic version.++Example:++```+./keyText "foo" "bar" = { mapKey = "foo", mapValue = "bar" }+```+-}++    let keyText =+          λ(key : Text) → λ(value : Text) → { mapKey = key, mapValue = value }++in  keyText
+ dhall-lang/Prelude/JSON/keyValue view
@@ -0,0 +1,20 @@+{-+Builds a key-value record such that a List of them will be converted to a+homogeneous record by dhall-to-json and dhall-to-yaml.++Examples:++```+./keyValue Natural "foo" 2 = { mapKey = "foo", mapValue = 2 }++./keyValue Text "bar" "baz" = { mapKey = "bar", mapValue = "baz" }+```+-}++    let keyValue =+            λ(v : Type)+          → λ(key : Text)+          → λ(value : v)+          → { mapKey = key, mapValue = value }++in  keyValue
+ dhall-lang/Prelude/JSON/package.dhall view
@@ -0,0 +1,1 @@+{ keyText = ./keyText, keyValue = ./keyValue }
+ dhall-lang/Prelude/List/all view
@@ -0,0 +1,20 @@+{-+Returns `True` if the supplied function returns `True` for all elements in the+`List`++Examples:++```+./all Natural Natural/even [ 2, 3, 5 ] = False++./all Natural Natural/even ([] : List Natural) = True+```+-}+    let all+        : ∀(a : Type) → (a → Bool) → List a → Bool+        =   λ(a : Type)+          → λ(f : a → Bool)+          → λ(xs : List a)+          → List/fold a xs Bool (λ(x : a) → λ(r : Bool) → f x && r) True++in  all
+ dhall-lang/Prelude/List/any view
@@ -0,0 +1,20 @@+{-+Returns `True` if the supplied function returns `True` for any element in the+`List`++Examples:++```+./any Natural Natural/even [ 2, 3, 5 ] = True++./any Natural Natural/even ([] : List Natural) = False+```+-}+    let any+        : ∀(a : Type) → (a → Bool) → List a → Bool+        =   λ(a : Type)+          → λ(f : a → Bool)+          → λ(xs : List a)+          → List/fold a xs Bool (λ(x : a) → λ(r : Bool) → f x || r) False++in  any
+ dhall-lang/Prelude/List/build view
@@ -0,0 +1,32 @@+{-+`build` is the inverse of `fold`++Examples:++```+./build+Text+(   λ(list : Type)+→   λ(cons : Text → list → list)+→   λ(nil : list)+→   cons "ABC" (cons "DEF" nil)+)+= [ "ABC", "DEF" ]++./build+Text+(   λ(list : Type)+→   λ(cons : Text → list → list)+→   λ(nil : list)+→   nil+)+= [] : List Text+```+-}+    let build+        :   ∀(a : Type)+          → (∀(list : Type) → ∀(cons : a → list → list) → ∀(nil : list) → list)+          → List a+        = List/build++in  build
+ dhall-lang/Prelude/List/concat view
@@ -0,0 +1,42 @@+{-+Concatenate a `List` of `List`s into a single `List`++Examples:++```+./concat Natural+[   [0, 1, 2]+,   [3, 4]+,   [5, 6, 7, 8]+]+= [ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]++./concat Natural+(   [   [] : List Natural+    ,   [] : List Natural+    ,   [] : List Natural+    ]+)+= [] : List Natural++./concat Natural ([] : List (List Natural)) = [] : List Natural+```+-}+    let concat+        : ∀(a : Type) → List (List a) → List a+        =   λ(a : Type)+          → λ(xss : List (List a))+          → List/build+            a+            (   λ(list : Type)+              → λ(cons : a → list → list)+              → λ(nil : list)+              → List/fold+                (List a)+                xss+                list+                (λ(xs : List a) → λ(ys : list) → List/fold a xs list cons ys)+                nil+            )++in  concat
+ dhall-lang/Prelude/List/concatMap view
@@ -0,0 +1,28 @@+{-+Transform a list by applying a function to each element and flattening the+results++Examples:++```+./concatMap Natural Natural (λ(n : Natural) → [n, n]) [2, 3, 5]+= [ 2, 2, 3, 3, 5, 5 ]++./concatMap Natural Natural (λ(n : Natural) → [n, n]) ([] : List Natural)+= [] : List Natural+```+-}+    let concatMap+        : ∀(a : Type) → ∀(b : Type) → (a → List b) → List a → List b+        =   λ(a : Type)+          → λ(b : Type)+          → λ(f : a → List b)+          → λ(xs : List a)+          → List/build+            b+            (   λ(list : Type)+              → λ(cons : b → list → list)+              → List/fold a xs list (λ(x : a) → List/fold b (f x) list cons)+            )++in  concatMap
+ dhall-lang/Prelude/List/filter view
@@ -0,0 +1,30 @@+{-+Only keep elements of the list where the supplied function returns `True`++Examples:++```+./filter Natural Natural/even [ 2, 3, 5 ]+= [ 2 ]++./filter Natural Natural/odd [ 2, 3, 5 ]+= [ 3, 5 ]+```+-}+    let filter+        : ∀(a : Type) → (a → Bool) → List a → List a+        =   λ(a : Type)+          → λ(f : a → Bool)+          → λ(xs : List a)+          → List/build+            a+            (   λ(list : Type)+              → λ(cons : a → list → list)+              → List/fold+                a+                xs+                list+                (λ(x : a) → λ(xs : list) → if f x then cons x xs else xs)+            )++in  filter
+ dhall-lang/Prelude/List/fold view
@@ -0,0 +1,46 @@+{-+`fold` is the primitive function for consuming `List`s++If you treat the list `[ x, y, z ]` as `cons x (cons y (cons z nil))`, then a+`fold` just replaces each `cons` and `nil` with something else++Examples:++```+    ./fold+    Natural+    [ 2, 3, 5 ]+    Natural+    (λ(x : Natural) → λ(y : Natural) → x + y)+    0+=   10++    λ(nil : Natural)+→   ./fold+    Natural+    [ 2, 3, 5 ]+    Natural+    (λ(x : Natural) → λ(y : Natural) → x + y)+    nil+=   λ(nil : Natural) → 2 + (3 + (5 + nil))++    λ(list : Type)+→   λ(cons : Natural → list → list)+→   λ(nil : list)+→   ./fold Natural [ 2, 3, 5 ] list cons nil+=   λ(list : Type)+→   λ(cons : Natural → list → list)+→   λ(nil : list)+→   cons 2 (cons 3 (cons 5 nil))+```+-}+    let fold+        :   ∀(a : Type)+          → List a+          → ∀(list : Type)+          → ∀(cons : a → list → list)+          → ∀(nil : list)+          → list+        = List/fold++in  fold
+ dhall-lang/Prelude/List/generate view
@@ -0,0 +1,38 @@+{-+Build a list by calling the supplied function on all `Natural` numbers from `0`+up to but not including the supplied `Natural` number++Examples:++```+./generate 5 Bool Natural/even = [ True, False, True, False, True ]++./generate 0 Bool Natural/even = [] : List Bool+```+-}+    let generate+        : Natural → ∀(a : Type) → (Natural → a) → List a+        =   λ(n : Natural)+          → λ(a : Type)+          → λ(f : Natural → a)+          → List/build+            a+            (   λ(list : Type)+              → λ(cons : a → list → list)+              → List/fold+                { index : Natural, value : {} }+                ( List/indexed+                  {}+                  ( List/build+                    {}+                    (   λ(list : Type)+                      → λ(cons : {} → list → list)+                      → Natural/fold n list (cons {=})+                    )+                  )+                )+                list+                (λ(x : { index : Natural, value : {} }) → cons (f x.index))+            )++in  generate
+ dhall-lang/Prelude/List/head view
@@ -0,0 +1,12 @@+{-+Retrieve the first element of the list++Examples:++```+./head Natural [ 0, 1, 2 ] = Some 0++./head Natural ([] : List Natural) = None Natural+```+-}+let head : ∀(a : Type) → List a → Optional a = List/head in head
+ dhall-lang/Prelude/List/indexed view
@@ -0,0 +1,21 @@+{-+Tag each element of the list with its index++Examples:++```+./indexed Bool [ True, False, True ]+=   [   { index = 0, value = True  }+    ,   { index = 1, value = False }+    ,   { index = 2, value = True  }+    ] : List { index : Natural, value : Bool }++./indexed Bool ([] : List Bool)+= [] : List { index : Natural, value : Bool }+```+-}+    let indexed+        : ∀(a : Type) → List a → List { index : Natural, value : a }+        = List/indexed++in  indexed
+ dhall-lang/Prelude/List/iterate view
@@ -0,0 +1,43 @@+{-+Generate a list of the specified length given a seed value and transition+function++Examples:++```+./iterate 10 Natural (λ(x : Natural) → x * 2) 1+= [ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 ]++./iterate 0 Natural (λ(x : Natural) → x * 2) 1+= [] : List Natural+```+-}+    let iterate+        : Natural → ∀(a : Type) → (a → a) → a → List a+        =   λ(n : Natural)+          → λ(a : Type)+          → λ(f : a → a)+          → λ(x : a)+          → List/build+            a+            (   λ(list : Type)+              → λ(cons : a → list → list)+              → List/fold+                { index : Natural, value : {} }+                ( List/indexed+                  {}+                  ( List/build+                    {}+                    (   λ(list : Type)+                      → λ(cons : {} → list → list)+                      → Natural/fold n list (cons {=})+                    )+                  )+                )+                list+                (   λ(y : { index : Natural, value : {} })+                  → cons (Natural/fold y.index a f x)+                )+            )++in  iterate
+ dhall-lang/Prelude/List/last view
@@ -0,0 +1,12 @@+{-+Retrieve the last element of the list++Examples:++```+./last Natural [ 0, 1, 2 ] = Some 2++./last Natural ([] : List Natural) = None Natural+```+-}+let last : ∀(a : Type) → List a → Optional a = List/last in last
+ dhall-lang/Prelude/List/length view
@@ -0,0 +1,12 @@+{-+Returns the number of elements in a list++Examples:++```+./length Natural [ 0, 1, 2 ] = 3++./length Natural ([] : List Natural) = 0+```+-}+let length : ∀(a : Type) → List a → Natural = List/length in length
+ dhall-lang/Prelude/List/map view
@@ -0,0 +1,27 @@+{-+Transform a list by applying a function to each element++Examples:++```+./map Natural Bool Natural/even [ 2, 3, 5 ]+= [ True, False, False ]++./map Natural Bool Natural/even ([] : List Natural)+= [] : List Bool+```+-}+    let map+        : ∀(a : Type) → ∀(b : Type) → (a → b) → List a → List b+        =   λ(a : Type)+          → λ(b : Type)+          → λ(f : a → b)+          → λ(xs : List a)+          → List/build+            b+            (   λ(list : Type)+              → λ(cons : b → list → list)+              → List/fold a xs list (λ(x : a) → cons (f x))+            )++in  map
+ dhall-lang/Prelude/List/null view
@@ -0,0 +1,16 @@+{-+Returns `True` if the `List` is empty and `False` otherwise++Examples:++```+./null Natural [ 0, 1, 2 ] = False++./null Natural ([] : List Natural) = True+```+-}+    let null+        : ∀(a : Type) → List a → Bool+        = λ(a : Type) → λ(xs : List a) → Natural/isZero (List/length a xs)++in  null
+ dhall-lang/Prelude/List/package.dhall view
@@ -0,0 +1,39 @@+{ all =+    ./all+, any =+    ./any+, build =+    ./build+, concat =+    ./concat+, concatMap =+    ./concatMap+, filter =+    ./filter+, fold =+    ./fold+, generate =+    ./generate+, head =+    ./head+, indexed =+    ./indexed+, iterate =+    ./iterate+, last =+    ./last+, length =+    ./length+, map =+    ./map+, null =+    ./null+, replicate =+    ./replicate+, reverse =+    ./reverse+, shifted =+    ./shifted+, unzip =+    ./unzip+}
+ dhall-lang/Prelude/List/replicate view
@@ -0,0 +1,24 @@+{-+Build a list by copying the given element the specified number of times++Examples:++```+./replicate 9 Natural 1 = [ 1, 1, 1, 1, 1, 1, 1, 1, 1 ]++./replicate 0 Natural 1 = [] : List Natural+```+-}+    let replicate+        : Natural → ∀(a : Type) → a → List a+        =   λ(n : Natural)+          → λ(a : Type)+          → λ(x : a)+          → List/build+            a+            (   λ(list : Type)+              → λ(cons : a → list → list)+              → Natural/fold n list (cons x)+            )++in  replicate
+ dhall-lang/Prelude/List/reverse view
@@ -0,0 +1,12 @@+{-+Reverse a list++Examples:++```+./reverse Natural [ 0, 1, 2 ] = [ 2, 1, 0 ] : List Natural++./reverse Natural ([] : List Natural) = [] : List Natural+```+-}+let reverse : ∀(a : Type) → List a → List a = List/reverse in reverse
+ dhall-lang/Prelude/List/shifted view
@@ -0,0 +1,90 @@+{-+Combine a `List` of `List`s, offsetting the `index` of each element by the+number of elements in preceding lists++Examples:++```+./shifted+Bool+[   [   { index = 0, value = True  }+    ,   { index = 1, value = True  }+    ,   { index = 2, value = True  }+    ]+,   [   { index = 0, value = False }+    ,   { index = 1, value = False }+    ]+,   [   { index = 0, value = True  }+    ,   { index = 1, value = True  }+    ,   { index = 2, value = True  }+    ,   { index = 3, value = True  }+    ]+]+=   [   { index = 0, value = True  }+    ,   { index = 1, value = True  }+    ,   { index = 2, value = True  }+    ,   { index = 3, value = False }+    ,   { index = 4, value = False }+    ,   { index = 5, value = True  }+    ,   { index = 6, value = True  }+    ,   { index = 7, value = True  }+    ,   { index = 8, value = True  }+    ]++./shifted Bool ([] : List (List { index : Natural, value : Bool }))+= [] : List { index : Natural, value : Bool }+```+-}+    let shifted+        :   ∀(a : Type)+          → List (List { index : Natural, value : a })+          → List { index : Natural, value : a }+        =   λ(a : Type)+          → λ(kvss : List (List { index : Natural, value : a }))+          → List/build+            { index : Natural, value : a }+            (   λ(list : Type)+              → λ(cons : { index : Natural, value : a } → list → list)+              → λ(nil : list)+              →     let result =+                          List/fold+                          (List { index : Natural, value : a })+                          kvss+                          { count : Natural, diff : Natural → list }+                          (   λ(kvs : List { index : Natural, value : a })+                            → λ(y : { count : Natural, diff : Natural → list })+                            →     let length =+                                        List/length+                                        { index : Natural, value : a }+                                        kvs+                              +                              in  { count =+                                      y.count + length+                                  , diff =+                                        λ(n : Natural)+                                      → List/fold+                                        { index : Natural, value : a }+                                        kvs+                                        list+                                        (   λ ( kvOld+                                              : { index : Natural, value : a }+                                              )+                                          → λ(z : list)+                                          →     let kvNew =+                                                      { index =+                                                          kvOld.index + n+                                                      , value =+                                                          kvOld.value+                                                      }+                                            +                                            in  cons kvNew z+                                        )+                                        (y.diff (n + length))+                                  }+                          )+                          { count = 0, diff = λ(_ : Natural) → nil }+                +                in  result.diff 0+            )++in  shifted
+ dhall-lang/Prelude/List/unzip view
@@ -0,0 +1,55 @@+{-+Unzip a `List` into two separate `List`s++Examples:++```+./unzip+Text+Bool+(   [   { _1 = "ABC", _2 = True  }+    ,   { _1 = "DEF", _2 = False }+    ,   { _1 = "GHI", _2 = True  }+    ]+)+=   { _1 = [ "ABC", "DEF", "GHI" ]+    , _2 = [ True, False, True ]+    }++./unzip Text Bool ([] : List { _1 : Text, _2 : Bool })+= { _1 = [] : List Text, _2 = [] : List Bool }+```+-}+    let unzip+        :   ∀(a : Type)+          → ∀(b : Type)+          → List { _1 : a, _2 : b }+          → { _1 : List a, _2 : List b }+        =   λ(a : Type)+          → λ(b : Type)+          → λ(xs : List { _1 : a, _2 : b })+          → { _1 =+                List/build+                a+                (   λ(list : Type)+                  → λ(cons : a → list → list)+                  → List/fold+                    { _1 : a, _2 : b }+                    xs+                    list+                    (λ(x : { _1 : a, _2 : b }) → cons x._1)+                )+            , _2 =+                List/build+                b+                (   λ(list : Type)+                  → λ(cons : b → list → list)+                  → List/fold+                    { _1 : a, _2 : b }+                    xs+                    list+                    (λ(x : { _1 : a, _2 : b }) → cons x._2)+                )+            }++in  unzip
+ dhall-lang/Prelude/Monoid view
@@ -0,0 +1,39 @@+{-+Any function `f` that is a `Monoid` must satisfy the following law:++```+t  : Type+f  : ./Monoid t+xs : List (List t)++f (./List/concat t xs) = f (./map (List t) t f xs)+```++Examples:++```+./Bool/and+    : ./Monoid Bool+./Bool/or+    : ./Monoid Bool+./Bool/even+    : ./Monoid Bool+./Bool/odd+    : ./Monoid Bool+./List/concat+    : ∀(a : Type) → ./Monoid (List a)+./List/shifted+    : ∀(a : Type) → ./Monoid (List { index : Natural, value : a })+./Natural/sum+    : ./Monoid Natural+./Natural/product+    : ./Monoid Natural+./Optional/head+    : ∀(a : Type) → ./Monoid (Optional a)+./Optional/last+    : ∀(a : Type) → ./Monoid (Optional a)+./Text/concat+    : ./Monoid Text+```+-}+let Monoid : ∀(m : Type) → Type = λ(m : Type) → List m → m in Monoid
+ dhall-lang/Prelude/Natural/build view
@@ -0,0 +1,33 @@+{-+`build` is the inverse of `fold`++Examples:++```+./build+(   λ(natural : Type)+→   λ(succ : natural → natural)+→   λ(zero : natural)+→   succ (succ (succ zero))+)+= 3++./build+(   λ(natural : Type)+→   λ(succ : natural → natural)+→   λ(zero : natural)+→   zero+)+= 0+```+-}+    let build+        :   (   ∀(natural : Type)+              → ∀(succ : natural → natural)+              → ∀(zero : natural)+              → natural+            )+          → Natural+        = Natural/build++in  build
+ dhall-lang/Prelude/Natural/enumerate view
@@ -0,0 +1,36 @@+{-+Generate a list of numbers from `0` up to but not including the specified+number++Examples:++```+./enumerate 10 = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]++./enumerate 0 = [] : List Natural+```+-}+    let enumerate+        : Natural → List Natural+        =   λ(n : Natural)+          → List/build+            Natural+            (   λ(list : Type)+              → λ(cons : Natural → list → list)+              → List/fold+                { index : Natural, value : {} }+                ( List/indexed+                  {}+                  ( List/build+                    {}+                    (   λ(list : Type)+                      → λ(cons : {} → list → list)+                      → Natural/fold n list (cons {=})+                    )+                  )+                )+                list+                (λ(x : { index : Natural, value : {} }) → cons x.index)+            )++in  enumerate
+ dhall-lang/Prelude/Natural/even view
@@ -0,0 +1,12 @@+{-+Returns `True` if a number if even and returns `False` otherwise++Examples:++```+./even 3 = False++./even 0 = True+```+-}+let even : Natural → Bool = Natural/even in even
+ dhall-lang/Prelude/Natural/fold view
@@ -0,0 +1,33 @@+{-+`fold` is the primitive function for consuming `Natural` numbers++If you treat the number `3` as `succ (succ (succ zero))` then a `fold` just+replaces each `succ` and `zero` with something else++Examples:++```+./fold 3 Natural (λ(x : Natural) → 5 * x) 1 = 125++λ(zero : Natural) → ./fold 3 Natural (λ(x : Natural) → 5 * x) zero+= λ(zero : Natural) → 5 * (5 * (5 * zero))++    λ(natural : Type)+→   λ(succ : natural → natural)+→   λ(zero : natural)+→   ./fold 3 natural succ zero+=   λ(natural : Type)+→   λ(succ : natural → natural)+→   λ(zero : natural)+→   succ (succ (succ zero))+```+-}+    let fold+        :   Natural+          → ∀(natural : Type)+          → ∀(succ : natural → natural)+          → ∀(zero : natural)+          → natural+        = Natural/fold++in  fold
+ dhall-lang/Prelude/Natural/isZero view
@@ -0,0 +1,12 @@+{-+Returns `True` if a number is `0` and returns `False` otherwise++Examples:++```+./isZero 2 = False++./isZero 0 = True+```+-}+let isZero : Natural → Bool = Natural/isZero in isZero
+ dhall-lang/Prelude/Natural/odd view
@@ -0,0 +1,12 @@+{-+Returns `True` if a number is odd and returns `False` otherwise++Examples:++```+./odd 3 = True++./odd 0 = False+```+-}+let odd : Natural → Bool = Natural/odd in odd
+ dhall-lang/Prelude/Natural/package.dhall view
@@ -0,0 +1,23 @@+{ build =+    ./build+, enumerate =+    ./enumerate+, even =+    ./even+, fold =+    ./fold+, isZero =+    ./isZero+, odd =+    ./odd+, product =+    ./product+, sum =+    ./sum+, show =+    ./show+, toDouble =+    ./toDouble+, toInteger =+    ./toInteger+}
+ dhall-lang/Prelude/Natural/product view
@@ -0,0 +1,22 @@+{-+Multiply all the numbers in a `List`++Examples:++```+./product [ 2, 3, 5 ] = 30++./product ([] : List Natural) = 1+```+-}+    let product+        : List Natural → Natural+        =   λ(xs : List Natural)+          → List/fold+            Natural+            xs+            Natural+            (λ(l : Natural) → λ(r : Natural) → l * r)+            1++in  product
+ dhall-lang/Prelude/Natural/show view
@@ -0,0 +1,13 @@+{-+Render a `Natural` number as `Text` using the same representation as Dhall+source code (i.e. a decimal number)++Examples:++```+./show 3 = "3"++./show 0 = "0"+```+-}+let show : Natural → Text = Natural/show in show
+ dhall-lang/Prelude/Natural/sum view
@@ -0,0 +1,22 @@+{-+Add all the numbers in a `List`++Examples:++```+./sum [ 2, 3, 5 ] = 10++./sum ([] : List Natural) = 0+```+-}+    let sum+        : List Natural → Natural+        =   λ(xs : List Natural)+          → List/fold+            Natural+            xs+            Natural+            (λ(l : Natural) → λ(r : Natural) → l + r)+            0++in  sum
+ dhall-lang/Prelude/Natural/toDouble view
@@ -0,0 +1,16 @@+{-+Convert a `Natural` number to the corresponding `Double`++Examples:++```+./toDouble 3 = 3.0++./toDouble 0 = 0.0+```+-}+    let toDouble+        : Natural → Double+        = λ(n : Natural) → Integer/toDouble (Natural/toInteger n)++in  toDouble
+ dhall-lang/Prelude/Natural/toInteger view
@@ -0,0 +1,12 @@+{-+Convert a `Natural` number to the corresponding `Integer`++Examples:++```+./toInteger 3 = +3++./toInteger 0 = +0+```+-}+let toInteger : Natural → Integer = Natural/toInteger in toInteger
+ dhall-lang/Prelude/Optional/all view
@@ -0,0 +1,20 @@+{-+Returns `False` if the supplied function returns `False` for a present element+and `True` otherwise:++Examples:++```+./all Natural Natural/even (Some 3) = False++./all Natural Natural/even (None Natural) = True+```+-}+    let all+        : ∀(a : Type) → (a → Bool) → Optional a → Bool+        =   λ(a : Type)+          → λ(f : a → Bool)+          → λ(xs : Optional a)+          → Optional/fold a xs Bool f True++in  all
+ dhall-lang/Prelude/Optional/any view
@@ -0,0 +1,20 @@+{-+Returns `True` if the supplied function returns `True` for a present element and+`False` otherwise++Examples:++```+./any Natural Natural/even (Some 2) = True++./any Natural Natural/even (None Natural) = False+```+-}+    let any+        : ∀(a : Type) → (a → Bool) → Optional a → Bool+        =   λ(a : Type)+          → λ(f : a → Bool)+          → λ(xs : Optional a)+          → Optional/fold a xs Bool f False++in  any
+ dhall-lang/Prelude/Optional/build view
@@ -0,0 +1,36 @@+{-+`build` is the inverse of `fold`++Examples:++```+./build+Natural+(   λ(optional : Type)+→   λ(some : Natural → optional)+→   λ(none : optional)+→   some 1+)+= Some 1++./build+Natural+(   λ(optional : Type)+→   λ(some : Natural → optional)+→   λ(none : optional)+→   none+)+= None Natural+```+-}+    let build+        :   ∀(a : Type)+          → (   ∀(optional : Type)+              → ∀(some : a → optional)+              → ∀(none : optional)+              → optional+            )+          → Optional a+        = Optional/build++in  build
+ dhall-lang/Prelude/Optional/concat view
@@ -0,0 +1,28 @@+{-+Flatten two `Optional` layers into a single `Optional` layer++Examples:++```+./concat Natural (Some (Some 1))+= Some 1++./concat Natural (Some (None Natural))+= None Natural++./concat Natural (None (Optional Natural))+= None Natural+```+-}+    let concat+        : ∀(a : Type) → Optional (Optional a) → Optional a+        =   λ(a : Type)+          → λ(x : Optional (Optional a))+          → Optional/fold+            (Optional a)+            x+            (Optional a)+            (λ(y : Optional a) → y)+            (None a)++in  concat
+ dhall-lang/Prelude/Optional/filter view
@@ -0,0 +1,32 @@+{-+Only keep an `Optional` element if the supplied function returns `True`++Examples:++```+./filter Natural Natural/even (Some 2)+= Some 2++./filter Natural Natural/odd (Some 2)+= None Natural+```+-}+    let filter+        : ∀(a : Type) → (a → Bool) → Optional a → Optional a+        =   λ(a : Type)+          → λ(f : a → Bool)+          → λ(xs : Optional a)+          → Optional/build+            a+            (   λ(optional : Type)+              → λ(some : a → optional)+              → λ(none : optional)+              → Optional/fold+                a+                xs+                optional+                (λ(x : a) → if f x then some x else none)+                none+            )++in  filter
+ dhall-lang/Prelude/Optional/fold view
@@ -0,0 +1,21 @@+{-+`fold` is the primitive function for consuming `Optional` values++Examples:++```+./fold Natural (Some 2) Natural (λ(x : Natural) → x) 0 = 2++./fold Natural (None Natural) Natural (λ(x : Natural) → x) 0 = 0+```+-}+    let fold+        :   ∀(a : Type)+          → Optional a+          → ∀(optional : Type)+          → ∀(some : a → optional)+          → ∀(none : optional)+          → optional+        = Optional/fold++in  fold
+ dhall-lang/Prelude/Optional/head view
@@ -0,0 +1,28 @@+{-+Returns the first non-empty `Optional` value in a `List`++Examples:++```+./head Natural [ None Natural, Some 1, Some 2 ] = Some 1++./head Natural [ None Natural, None Natural ] = None Natural++./head Natural ([] : List (Optional Natural)) = None Natural+```+-}+    let head+        : ∀(a : Type) → List (Optional a) → Optional a+        =   λ(a : Type)+          → λ(xs : List (Optional a))+          → List/fold+            (Optional a)+            xs+            (Optional a)+            (   λ(l : Optional a)+              → λ(r : Optional a)+              → Optional/fold a l (Optional a) (λ(x : a) → Some x) r+            )+            (None a)++in  head
+ dhall-lang/Prelude/Optional/last view
@@ -0,0 +1,28 @@+{-+Returns the last non-empty `Optional` value in a `List`++Examples:++```+./last Natural [ None Natural, Some 1, Some 2 ] = Some 2++./last Natural [ None Natural, None Natural ] = None Natural++./last Natural ([] : List (Optional Natural)) = None Natural+```+-}+    let last+        : ∀(a : Type) → List (Optional a) → Optional a+        =   λ(a : Type)+          → λ(xs : List (Optional a))+          → List/fold+            (Optional a)+            xs+            (Optional a)+            (   λ(l : Optional a)+              → λ(r : Optional a)+              → Optional/fold a r (Optional a) (λ(x : a) → Some x) l+            )+            (None a)++in  last
+ dhall-lang/Prelude/Optional/length view
@@ -0,0 +1,18 @@+{-+Returns `1` if the `Optional` value is present and `0` if the value is absent++Examples:++```+./length Natural (Some 2) = 1++./length Natural (None Natural) = 0+```+-}+    let length+        : ∀(a : Type) → Optional a → Natural+        =   λ(a : Type)+          → λ(xs : Optional a)+          → Optional/fold a xs Natural (λ(_ : a) → 1) 0++in  length
+ dhall-lang/Prelude/Optional/map view
@@ -0,0 +1,20 @@+{-+Transform an `Optional` value with a function++Examples:++```+./map Natural Bool Natural/even (Some 3) = Some False++./map Natural Bool Natural/even (None Natural) = None Bool+```+-}+    let map+        : ∀(a : Type) → ∀(b : Type) → (a → b) → Optional a → Optional b+        =   λ(a : Type)+          → λ(b : Type)+          → λ(f : a → b)+          → λ(o : Optional a)+          → Optional/fold a o (Optional b) (λ(x : a) → Some (f x)) (None b)++in  map
+ dhall-lang/Prelude/Optional/null view
@@ -0,0 +1,18 @@+{-+Returns `True` if the `Optional` value is absent and `False` if present++Examples:++```+./null Natural (Some 2) = False++./null Natural (None Natural) = True+```+-}+    let null+        : ∀(a : Type) → Optional a → Bool+        =   λ(a : Type)+          → λ(xs : Optional a)+          → Optional/fold a xs Bool (λ(_ : a) → False) True++in  null
+ dhall-lang/Prelude/Optional/package.dhall view
@@ -0,0 +1,27 @@+{ all =+    ./all+, any =+    ./any+, build =+    ./build+, concat =+    ./concat+, filter =+    ./filter+, fold =+    ./fold+, head =+    ./head+, last =+    ./last+, length =+    ./length+, map =+    ./map+, null =+    ./null+, toList =+    ./toList+, unzip =+    ./unzip+}
+ dhall-lang/Prelude/Optional/toList view
@@ -0,0 +1,18 @@+{-+Convert an `Optional` value into the equivalent `List`++Examples:++```+./toList Natural (Some 1) = [ 1 ]++./toList Natural (None Natural) = [] : List Natural+```+-}+    let toList+        : ∀(a : Type) → Optional a → List a+        =   λ(a : Type)+          → λ(o : Optional a)+          → Optional/fold a o (List a) (λ(x : a) → [ x ] : List a) ([] : List a)++in  toList
+ dhall-lang/Prelude/Optional/unzip view
@@ -0,0 +1,38 @@+{-+Unzip an `Optional` value into two separate `Optional` values++Examples:++```+./unzip Text Bool (Some { _1 = "ABC", _2 = True  })+= { _1 = Some "ABC", _2 = Some True }++./unzip Text Bool (None { _1 : Text, _2 : Bool })+= { _1 = None Text, _2 = None Bool }+```+-}+    let unzip+        :   ∀(a : Type)+          → ∀(b : Type)+          → Optional { _1 : a, _2 : b }+          → { _1 : Optional a, _2 : Optional b }+        =   λ(a : Type)+          → λ(b : Type)+          → λ(xs : Optional { _1 : a, _2 : b })+          → { _1 =+                Optional/fold+                { _1 : a, _2 : b }+                xs+                (Optional a)+                (λ(x : { _1 : a, _2 : b }) → Some x._1)+                (None a)+            , _2 =+                Optional/fold+                { _1 : a, _2 : b }+                xs+                (Optional b)+                (λ(x : { _1 : a, _2 : b }) → Some x._2)+                (None b)+            }++in  unzip
+ dhall-lang/Prelude/Text/concat view
@@ -0,0 +1,17 @@+{-+Concatenate all the `Text` values in a `List`++Examples:++```+./concat [ "ABC", "DEF", "GHI" ] = "ABCDEFGHI"++./concat ([] : List Text) = ""+```+-}+    let concat+        : List Text → Text+        =   λ(xs : List Text)+          → List/fold Text xs Text (λ(x : Text) → λ(y : Text) → x ++ y) ""++in  concat
+ dhall-lang/Prelude/Text/concatMap view
@@ -0,0 +1,21 @@+{-+Transform each value in a `List` into `Text` and concatenate the result++Examples:++```+./concatMap Natural (λ(n : Natural) → "${Natural/show n} ") [ 0, 1, 2 ]+= "0 1 2 "++./concatMap Natural (λ(n : Natural) → "${Natural/show n} ") ([] : List Natural)+= ""+```+-}+    let concatMap+        : ∀(a : Type) → (a → Text) → List a → Text+        =   λ(a : Type)+          → λ(f : a → Text)+          → λ(xs : List a)+          → List/fold a xs Text (λ(x : a) → λ(y : Text) → f x ++ y) ""++in  concatMap
+ dhall-lang/Prelude/Text/concatMapSep view
@@ -0,0 +1,47 @@+{-+Transform each value in a `List` to `Text` and then concatenate them with a+separator in between each value++Examples:++```+./concatMapSep ", " Natural Natural/show [ 0, 1, 2 ] = "0, 1, 2"++./concatMapSep ", " Natural Natural/show ([] : List Natural) = ""+```+-}+    let concatMapSep+        : ∀(separator : Text) → ∀(a : Type) → (a → Text) → List a → Text+        =   λ(separator : Text)+          → λ(a : Type)+          → λ(f : a → Text)+          → λ(elements : List a)+          →     let status =+                      List/fold+                      a+                      elements+                      < Empty : {} | NonEmpty : Text >+                      (   λ(element : a)+                        → λ(status : < Empty : {} | NonEmpty : Text >)+                        → merge+                          { Empty =+                              λ(_ : {}) → < NonEmpty = f element | Empty : {} >+                          , NonEmpty =+                                λ(result : Text)+                              → < NonEmpty =+                                    f element ++ separator ++ result+                                | Empty :+                                    {}+                                >+                          }+                          status+                          : < Empty : {} | NonEmpty : Text >+                      )+                      < Empty = {=} | NonEmpty : Text >+            +            in  merge+                { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result }+                status+                : Text++in  concatMapSep
+ dhall-lang/Prelude/Text/concatSep view
@@ -0,0 +1,44 @@+{-+Concatenate a `List` of `Text` values with a separator in between each value++Examples:++```+./concatSep ", " [ "ABC", "DEF", "GHI" ] = "ABC, DEF, GHI"++./concatSep ", " ([] : List Text) = ""+```+-}+    let concatSep+        : ∀(separator : Text) → ∀(elements : List Text) → Text+        =   λ(separator : Text)+          → λ(elements : List Text)+          →     let status =+                      List/fold+                      Text+                      elements+                      < Empty : {} | NonEmpty : Text >+                      (   λ(element : Text)+                        → λ(status : < Empty : {} | NonEmpty : Text >)+                        → merge+                          { Empty =+                              λ(_ : {}) → < NonEmpty = element | Empty : {} >+                          , NonEmpty =+                                λ(result : Text)+                              → < NonEmpty =+                                    element ++ separator ++ result+                                | Empty :+                                    {}+                                >+                          }+                          status+                          : < Empty : {} | NonEmpty : Text >+                      )+                      < Empty = {=} | NonEmpty : Text >+            +            in  merge+                { Empty = λ(_ : {}) → "", NonEmpty = λ(result : Text) → result }+                status+                : Text++in  concatSep
+ dhall-lang/Prelude/Text/package.dhall view
@@ -0,0 +1,11 @@+{ concat =+    ./concat+, concatMap =+    ./concatMap+, concatMapSep =+    ./concatMapSep+, concatSep =+    ./concatSep+, show =+    ./show+}
+ dhall-lang/Prelude/Text/show view
@@ -0,0 +1,13 @@+{-+Render a `Text` literal as its own representation as Dhall source code (i.e. a+double-quoted string literal)++Examples:++```+./show "ABC" = "\"ABC\""++./show "\u0000 \$ \\ \n \u263a" = "\"\\u0000 \\u0024 \\\\ \\n ☺\""+```+-}+let show : Text → Text = Text/show in show
+ dhall-lang/Prelude/package.dhall view
@@ -0,0 +1,19 @@+{ `Bool` =+    ./Bool/package.dhall+, `Double` =+    ./Double/package.dhall+, Function =+    ./Function/package.dhall+, `Integer` =+    ./Integer/package.dhall+, `List` =+    ./List/package.dhall+, `Natural` =+    ./Natural/package.dhall+, `Optional` =+    ./Optional/package.dhall+, JSON =+    ./JSON/package.dhall+, `Text` =+    ./Text/package.dhall+}
+ dhall-lang/tests/import/data/fieldOrder/1.dhall view
@@ -0,0 +1,1 @@+{ foo = 1, bar = True }
+ dhall-lang/tests/import/data/fieldOrder/2.dhall view
@@ -0,0 +1,1 @@+{ bar = True, foo = 1 }
+ dhall-lang/tests/import/failure/alternativeEnv.dhall view
@@ -0,0 +1,1 @@+env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3
+ dhall-lang/tests/import/failure/alternativeEnvMissing.dhall view
@@ -0,0 +1,1 @@+env:UNSET ? missing
+ dhall-lang/tests/import/failure/cycle.dhall view
@@ -0,0 +1,1 @@+../data/cycle.dhall
+ dhall-lang/tests/import/failure/missing.dhall view
@@ -0,0 +1,1 @@+missing
+ dhall-lang/tests/import/failure/referentiallyInsane.dhall view
@@ -0,0 +1,13 @@+{- The following remote import attempts to import an environment variable, which+   must be disallowed by the referential sanity check++   One reason for doing this is to protect against remote imports exfiltrating+   environment variables (such as via custom headers).  Only referentially+   opaque imports (i.e. local imports) have permission to refer to other+   referentially opaque imports in order to protect against this attack.++   The referential sanity check also ensures that remote imports are+   referentially transparent.  Or in other words, any import that is globally+   addressable must have a meaning that is not context-sensitive.+-}+https://raw.githubusercontent.com/dhall-lang/dhall-lang/master/tests/import/data/referentiallyOpaque.dhall
+ dhall-lang/tests/import/success/alternativeEnvNaturalA.dhall view
@@ -0,0 +1,1 @@+env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2
+ dhall-lang/tests/import/success/alternativeEnvNaturalB.dhall view
@@ -0,0 +1,1 @@+2
+ dhall-lang/tests/import/success/alternativeEnvSimpleA.dhall view
@@ -0,0 +1,1 @@+env:UNSET ? 3
+ dhall-lang/tests/import/success/alternativeEnvSimpleB.dhall view
@@ -0,0 +1,1 @@+3
+ dhall-lang/tests/import/success/alternativeNaturalA.dhall view
@@ -0,0 +1,1 @@+4 ? missing
+ dhall-lang/tests/import/success/alternativeNaturalB.dhall view
@@ -0,0 +1,1 @@+4
+ dhall-lang/tests/import/success/asTextA.dhall view
@@ -0,0 +1,1 @@+../data/example.txt as Text
+ dhall-lang/tests/import/success/asTextB.dhall view
@@ -0,0 +1,3 @@+''+Hello, world!+''
+ dhall-lang/tests/import/success/fieldOrderA.dhall view
@@ -0,0 +1,5 @@+{ example0 =+    ../data/fieldOrder/1.dhall sha256:d8ae15ff5a40ee7973a23ba75cd98f8e39d14aeb6e1e3f18aadb092fcb825194+, example1 =+    ../data/fieldOrder/2.dhall sha256:d8ae15ff5a40ee7973a23ba75cd98f8e39d14aeb6e1e3f18aadb092fcb825194+}
+ dhall-lang/tests/import/success/fieldOrderB.dhall view
@@ -0,0 +1,1 @@+{ example0 = { bar = True, foo = 1 }, example1 = { bar = True, foo = 1 } }
+ dhall-lang/tests/normalization/success/haskell-tutorial/access/0A.dhall view
@@ -0,0 +1,1 @@+{ x = "foo" }.x
+ dhall-lang/tests/normalization/success/haskell-tutorial/access/0B.dhall view
@@ -0,0 +1,1 @@+"foo"
+ dhall-lang/tests/normalization/success/haskell-tutorial/access/1A.dhall view
@@ -0,0 +1,1 @@+< Foo : Text | Bar : Natural >.Foo
+ dhall-lang/tests/normalization/success/haskell-tutorial/access/1B.dhall view
@@ -0,0 +1,1 @@+λ(Foo : Text) → < Foo = Foo | Bar : Natural >
+ dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/0A.dhall view
@@ -0,0 +1,1 @@+{ foo : { bar : Text } } ⩓ { foo : { baz : Bool }, qux : Integer }
+ dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/0B.dhall view
@@ -0,0 +1,1 @@+{ foo : { bar : Text, baz : Bool }, qux : Integer }
+ dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/1A.dhall view
@@ -0,0 +1,1 @@+{ foo : { bar : Text } } //\\ { foo : { baz : Bool }, qux : Integer }
+ dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/1B.dhall view
@@ -0,0 +1,1 @@+{ foo : { bar : Text, baz : Bool }, qux : Integer }
+ dhall-lang/tests/normalization/success/haskell-tutorial/prefer/0A.dhall view
@@ -0,0 +1,1 @@+{ foo = 1, bar = "ABC" } // { baz = True }
+ dhall-lang/tests/normalization/success/haskell-tutorial/prefer/0B.dhall view
@@ -0,0 +1,1 @@+{ bar = "ABC", baz = True, foo = 1 }
+ dhall-lang/tests/normalization/success/haskell-tutorial/projection/0A.dhall view
@@ -0,0 +1,1 @@+{ x = 1, y = True, z = "ABC" }.{ x, y }
+ dhall-lang/tests/normalization/success/haskell-tutorial/projection/0B.dhall view
@@ -0,0 +1,1 @@+{ x = 1, y = True }
+ dhall-lang/tests/normalization/success/multiline/escapeA.dhall view
@@ -0,0 +1,9 @@+-- Verify that an implementation is processing escape sequences correctly++''+''${+'''+$+"+\+''
+ dhall-lang/tests/normalization/success/multiline/escapeB.dhall view
@@ -0,0 +1,1 @@+"\${\n''\n\$\n\"\n\\\n"
+ dhall-lang/tests/normalization/success/multiline/hangingIndentA.dhall view
@@ -0,0 +1,15 @@+{- The indent is computed as the minimum number of leading spaces over all lines+   in a multi-line literal, including the line right before the closing quotes.+   In this case, there are three lines:++   * The first line containing "  foo" with two leading spaces+   * The second line containing "  bar" with two leading spaces+   * The third line containing "  " with two leading spaces++   Therefore we strip two leading spaces from all three lines+-}++''+  foo+  bar+  ''
+ dhall-lang/tests/normalization/success/multiline/hangingIndentB.dhall view
@@ -0,0 +1,1 @@+"foo\nbar\n"
+ dhall-lang/tests/normalization/success/multiline/interestingA.dhall view
@@ -0,0 +1,7 @@+-- Non-trivial example that combines several multi-line literal features++λ(x : Text) → ''+  ${x}    baz+      bar+    foo+    ''
+ dhall-lang/tests/normalization/success/multiline/interestingB.dhall view
@@ -0,0 +1,1 @@+λ(x : Text) → "${x}    baz\n    bar\n  foo\n  "
+ dhall-lang/tests/normalization/success/multiline/interiorIndentA.dhall view
@@ -0,0 +1,16 @@+{- The indent is computed as the minimum number of leading spaces over all lines+   in a multi-line literal, including the line right before the closing quotes.+   In this case, there are three lines:++   * The first line containing "  foo" with two leading spaces+   * The second line containing "  bar" with two leading spaces+   * The third line containing "" with zero leading spaces++   Since the last line has zero leading spaces, the minimum number of leading+   spaces over all three lines is zero, so we don't strip any spaces.+-}++''+  foo+  bar+''
+ dhall-lang/tests/normalization/success/multiline/interiorIndentB.dhall view
@@ -0,0 +1,1 @@+"  foo\n  bar\n"
+ dhall-lang/tests/normalization/success/multiline/interpolationA.dhall view
@@ -0,0 +1,9 @@+{- This example verifies that an implementation is correctly breaking leading+   spaces at interpolated expressions.  The first line has the fewest number of+   leading spaces (2) due to the interruption by the interpolated expression.+-}++''+${Natural/show 1}      foo+  bar+''
+ dhall-lang/tests/normalization/success/multiline/interpolationB.dhall view
@@ -0,0 +1,1 @@+"${Natural/show 1}      foo\n  bar\n"
+ dhall-lang/tests/normalization/success/multiline/preserveCommentA.dhall view
@@ -0,0 +1,8 @@+{- A comment within the interior of a multi-line literal counts as part of the+   literal+-}++''+-- Hello+{- world -}+''
+ dhall-lang/tests/normalization/success/multiline/preserveCommentB.dhall view
@@ -0,0 +1,1 @@+"-- Hello\n{- world -}\n"
+ dhall-lang/tests/normalization/success/multiline/singleLineA.dhall view
@@ -0,0 +1,6 @@+{- This is how you encode a multi-line literal that contains no newlines++   The leading newline is stripped+-}+''+foo''
+ dhall-lang/tests/normalization/success/multiline/singleLineB.dhall view
@@ -0,0 +1,1 @@+"foo"
+ dhall-lang/tests/normalization/success/multiline/twoLinesA.dhall view
@@ -0,0 +1,7 @@+{- Verify that an implementation is correctly preserving newlines in the+   corresponding double-quoted literal+-}++''+foo+bar''
+ dhall-lang/tests/normalization/success/multiline/twoLinesB.dhall view
@@ -0,0 +1,1 @@+"foo\nbar"
+ dhall-lang/tests/normalization/success/prelude/Bool/and/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.and [ True, False, True ]
+ dhall-lang/tests/normalization/success/prelude/Bool/and/0B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Bool/and/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.and ([] : List Bool)
+ dhall-lang/tests/normalization/success/prelude/Bool/and/1B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/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)
+ dhall-lang/tests/normalization/success/prelude/Bool/build/0B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/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)
+ dhall-lang/tests/normalization/success/prelude/Bool/build/1B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Bool/even/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.even [ False, True, False ]
+ dhall-lang/tests/normalization/success/prelude/Bool/even/0B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/Bool/even/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.even [ False, True ]
+ dhall-lang/tests/normalization/success/prelude/Bool/even/1B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Bool/even/2A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.even [ False ]
+ dhall-lang/tests/normalization/success/prelude/Bool/even/2B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Bool/even/3A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.even ([] : List Bool)
+ dhall-lang/tests/normalization/success/prelude/Bool/even/3B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/Bool/fold/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.fold True Natural 0 1
+ dhall-lang/tests/normalization/success/prelude/Bool/fold/0B.dhall view
@@ -0,0 +1,1 @@+0
+ dhall-lang/tests/normalization/success/prelude/Bool/fold/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.fold False Natural 0 1
+ dhall-lang/tests/normalization/success/prelude/Bool/fold/1B.dhall view
@@ -0,0 +1,1 @@+1
+ dhall-lang/tests/normalization/success/prelude/Bool/not/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.not True
+ dhall-lang/tests/normalization/success/prelude/Bool/not/0B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Bool/not/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.not False
+ dhall-lang/tests/normalization/success/prelude/Bool/not/1B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/Bool/odd/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.odd [ True, False, True ]
+ dhall-lang/tests/normalization/success/prelude/Bool/odd/0B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Bool/odd/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.odd [ True, False ]
+ dhall-lang/tests/normalization/success/prelude/Bool/odd/1B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/Bool/odd/2A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.odd [ True ]
+ dhall-lang/tests/normalization/success/prelude/Bool/odd/2B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/Bool/odd/3A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.odd ([] : List Bool)
+ dhall-lang/tests/normalization/success/prelude/Bool/odd/3B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Bool/or/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.or [ True, False, True ]
+ dhall-lang/tests/normalization/success/prelude/Bool/or/0B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/Bool/or/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.or ([] : List Bool)
+ dhall-lang/tests/normalization/success/prelude/Bool/or/1B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Bool/show/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.show True
+ dhall-lang/tests/normalization/success/prelude/Bool/show/0B.dhall view
@@ -0,0 +1,1 @@+"True"
+ dhall-lang/tests/normalization/success/prelude/Bool/show/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Bool`.show False
+ dhall-lang/tests/normalization/success/prelude/Bool/show/1B.dhall view
@@ -0,0 +1,1 @@+"False"
+ dhall-lang/tests/normalization/success/prelude/Double/show/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Double`.show -3.1
+ dhall-lang/tests/normalization/success/prelude/Double/show/0B.dhall view
@@ -0,0 +1,1 @@+"-3.1"
+ dhall-lang/tests/normalization/success/prelude/Double/show/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Double`.show 0.4
+ dhall-lang/tests/normalization/success/prelude/Double/show/1B.dhall view
@@ -0,0 +1,1 @@+"0.4"
+ dhall-lang/tests/normalization/success/prelude/Integer/show/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Integer`.show -3
+ dhall-lang/tests/normalization/success/prelude/Integer/show/0B.dhall view
@@ -0,0 +1,1 @@+"-3"
+ dhall-lang/tests/normalization/success/prelude/Integer/show/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Integer`.show +0
+ dhall-lang/tests/normalization/success/prelude/Integer/show/1B.dhall view
@@ -0,0 +1,1 @@+"+0"
+ dhall-lang/tests/normalization/success/prelude/Integer/toDouble/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Integer`.toDouble -3
+ dhall-lang/tests/normalization/success/prelude/Integer/toDouble/0B.dhall view
@@ -0,0 +1,1 @@+-3.0
+ dhall-lang/tests/normalization/success/prelude/Integer/toDouble/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Integer`.toDouble +2
+ dhall-lang/tests/normalization/success/prelude/Integer/toDouble/1B.dhall view
@@ -0,0 +1,1 @@+2.0
+ dhall-lang/tests/normalization/success/prelude/List/all/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.all Natural Natural/even [ 2, 3, 5 ]
+ dhall-lang/tests/normalization/success/prelude/List/all/0B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/List/all/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.all Natural Natural/even ([] : List Natural)
+ dhall-lang/tests/normalization/success/prelude/List/all/1B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/List/any/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.any Natural Natural/even [ 2, 3, 5 ]
+ dhall-lang/tests/normalization/success/prelude/List/any/0B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/List/any/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.any Natural Natural/even ([] : List Natural)
+ dhall-lang/tests/normalization/success/prelude/List/any/1B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/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)+)
+ dhall-lang/tests/normalization/success/prelude/List/build/0B.dhall view
@@ -0,0 +1,1 @@+[ "ABC", "DEF" ]
+ dhall-lang/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+)
+ dhall-lang/tests/normalization/success/prelude/List/build/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Text
+ dhall-lang/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 ]+]
+ dhall-lang/tests/normalization/success/prelude/List/concat/0B.dhall view
@@ -0,0 +1,1 @@+[ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]
+ dhall-lang/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+]
+ dhall-lang/tests/normalization/success/prelude/List/concat/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ dhall-lang/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 ]
+ dhall-lang/tests/normalization/success/prelude/List/concatMap/0B.dhall view
@@ -0,0 +1,1 @@+[ 2, 2, 3, 3, 5, 5 ]
+ dhall-lang/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)
+ dhall-lang/tests/normalization/success/prelude/List/concatMap/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ dhall-lang/tests/normalization/success/prelude/List/filter/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.filter Natural Natural/even [ 2, 3, 5 ]
+ dhall-lang/tests/normalization/success/prelude/List/filter/0B.dhall view
@@ -0,0 +1,1 @@+[ 2 ]
+ dhall-lang/tests/normalization/success/prelude/List/filter/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.filter Natural Natural/odd [ 2, 3, 5 ]
+ dhall-lang/tests/normalization/success/prelude/List/filter/1B.dhall view
@@ -0,0 +1,1 @@+[ 3, 5 ]
+ dhall-lang/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
+ dhall-lang/tests/normalization/success/prelude/List/fold/0B.dhall view
@@ -0,0 +1,1 @@+10
+ dhall-lang/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
+ dhall-lang/tests/normalization/success/prelude/List/fold/1B.dhall view
@@ -0,0 +1,1 @@+λ(nil : Natural) → 2 + (3 + (5 + nil))
+ dhall-lang/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
+ dhall-lang/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))
+ dhall-lang/tests/normalization/success/prelude/List/generate/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.generate 5 Bool Natural/even
+ dhall-lang/tests/normalization/success/prelude/List/generate/0B.dhall view
@@ -0,0 +1,1 @@+[ True, False, True, False, True ]
+ dhall-lang/tests/normalization/success/prelude/List/generate/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.generate 0 Bool Natural/even
+ dhall-lang/tests/normalization/success/prelude/List/generate/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Bool
+ dhall-lang/tests/normalization/success/prelude/List/head/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.head Natural [ 0, 1, 2 ]
+ dhall-lang/tests/normalization/success/prelude/List/head/0B.dhall view
@@ -0,0 +1,1 @@+Some 0
+ dhall-lang/tests/normalization/success/prelude/List/head/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.head Natural ([] : List Natural)
+ dhall-lang/tests/normalization/success/prelude/List/head/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ dhall-lang/tests/normalization/success/prelude/List/indexed/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.indexed Bool [ True, False, True ]
+ dhall-lang/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 }+]
+ dhall-lang/tests/normalization/success/prelude/List/indexed/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.indexed Bool ([] : List Bool)
+ dhall-lang/tests/normalization/success/prelude/List/indexed/1B.dhall view
@@ -0,0 +1,1 @@+[] : List { index : Natural, value : Bool }
+ dhall-lang/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
+ dhall-lang/tests/normalization/success/prelude/List/iterate/0B.dhall view
@@ -0,0 +1,1 @@+[ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 ]
+ dhall-lang/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
+ dhall-lang/tests/normalization/success/prelude/List/iterate/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ dhall-lang/tests/normalization/success/prelude/List/last/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.last Natural [ 0, 1, 2 ]
+ dhall-lang/tests/normalization/success/prelude/List/last/0B.dhall view
@@ -0,0 +1,1 @@+Some 2
+ dhall-lang/tests/normalization/success/prelude/List/last/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.last Natural ([] : List Natural)
+ dhall-lang/tests/normalization/success/prelude/List/last/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ dhall-lang/tests/normalization/success/prelude/List/length/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.length Natural [ 0, 1, 2 ]
+ dhall-lang/tests/normalization/success/prelude/List/length/0B.dhall view
@@ -0,0 +1,1 @@+3
+ dhall-lang/tests/normalization/success/prelude/List/length/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.length Natural ([] : List Natural)
+ dhall-lang/tests/normalization/success/prelude/List/length/1B.dhall view
@@ -0,0 +1,1 @@+0
+ dhall-lang/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 ]
+ dhall-lang/tests/normalization/success/prelude/List/map/0B.dhall view
@@ -0,0 +1,1 @@+[ True, False, False ]
+ dhall-lang/tests/normalization/success/prelude/List/map/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.map Natural Bool Natural/even ([] : List Natural)
+ dhall-lang/tests/normalization/success/prelude/List/map/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Bool
+ dhall-lang/tests/normalization/success/prelude/List/null/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.null Natural [ 0, 1, 2 ]
+ dhall-lang/tests/normalization/success/prelude/List/null/0B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/List/null/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.null Natural ([] : List Natural)
+ dhall-lang/tests/normalization/success/prelude/List/null/1B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/List/replicate/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.replicate 9 Natural 1
+ dhall-lang/tests/normalization/success/prelude/List/replicate/0B.dhall view
@@ -0,0 +1,1 @@+[ 1, 1, 1, 1, 1, 1, 1, 1, 1 ]
+ dhall-lang/tests/normalization/success/prelude/List/replicate/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.replicate 0 Natural 1
+ dhall-lang/tests/normalization/success/prelude/List/replicate/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ dhall-lang/tests/normalization/success/prelude/List/reverse/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.reverse Natural [ 0, 1, 2 ]
+ dhall-lang/tests/normalization/success/prelude/List/reverse/0B.dhall view
@@ -0,0 +1,1 @@+[ 2, 1, 0 ]
+ dhall-lang/tests/normalization/success/prelude/List/reverse/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`List`.reverse Natural ([] : List Natural)
+ dhall-lang/tests/normalization/success/prelude/List/reverse/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ dhall-lang/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 }+  ]+]
+ dhall-lang/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 }+]
+ dhall-lang/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 }))
+ dhall-lang/tests/normalization/success/prelude/List/shifted/1B.dhall view
@@ -0,0 +1,1 @@+[] : List { index : Natural, value : Bool }
+ dhall-lang/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 }+]
+ dhall-lang/tests/normalization/success/prelude/List/unzip/0B.dhall view
@@ -0,0 +1,1 @@+{ _1 = [ "ABC", "DEF", "GHI" ], _2 = [ True, False, True ] }
+ dhall-lang/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 })
+ dhall-lang/tests/normalization/success/prelude/List/unzip/1B.dhall view
@@ -0,0 +1,1 @@+{ _1 = [] : List Text, _2 = [] : List Bool }
+ dhall-lang/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))+)
+ dhall-lang/tests/normalization/success/prelude/Natural/build/0B.dhall view
@@ -0,0 +1,1 @@+3
+ dhall-lang/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+)
+ dhall-lang/tests/normalization/success/prelude/Natural/build/1B.dhall view
@@ -0,0 +1,1 @@+0
+ dhall-lang/tests/normalization/success/prelude/Natural/enumerate/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.enumerate 10
+ dhall-lang/tests/normalization/success/prelude/Natural/enumerate/0B.dhall view
@@ -0,0 +1,1 @@+[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
+ dhall-lang/tests/normalization/success/prelude/Natural/enumerate/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.enumerate 0
+ dhall-lang/tests/normalization/success/prelude/Natural/enumerate/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ dhall-lang/tests/normalization/success/prelude/Natural/even/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.even 3
+ dhall-lang/tests/normalization/success/prelude/Natural/even/0B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Natural/even/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.even 0
+ dhall-lang/tests/normalization/success/prelude/Natural/even/1B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/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
+ dhall-lang/tests/normalization/success/prelude/Natural/fold/0B.dhall view
@@ -0,0 +1,1 @@+125
+ dhall-lang/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
+ dhall-lang/tests/normalization/success/prelude/Natural/fold/1B.dhall view
@@ -0,0 +1,1 @@+λ(zero : Natural) → 5 * (5 * (5 * zero))
+ dhall-lang/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
+ dhall-lang/tests/normalization/success/prelude/Natural/fold/2B.dhall view
@@ -0,0 +1,1 @@+λ(natural : Type) → λ(succ : natural → natural) → λ(zero : natural) → succ (succ (succ zero))
+ dhall-lang/tests/normalization/success/prelude/Natural/isZero/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.isZero 2
+ dhall-lang/tests/normalization/success/prelude/Natural/isZero/0B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Natural/isZero/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.isZero 0
+ dhall-lang/tests/normalization/success/prelude/Natural/isZero/1B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/Natural/odd/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.odd 3
+ dhall-lang/tests/normalization/success/prelude/Natural/odd/0B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/Natural/odd/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.odd 0
+ dhall-lang/tests/normalization/success/prelude/Natural/odd/1B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Natural/product/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.product [ 2, 3, 5 ]
+ dhall-lang/tests/normalization/success/prelude/Natural/product/0B.dhall view
@@ -0,0 +1,1 @@+30
+ dhall-lang/tests/normalization/success/prelude/Natural/product/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.product ([] : List Natural)
+ dhall-lang/tests/normalization/success/prelude/Natural/product/1B.dhall view
@@ -0,0 +1,1 @@+1
+ dhall-lang/tests/normalization/success/prelude/Natural/show/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.show 3
+ dhall-lang/tests/normalization/success/prelude/Natural/show/0B.dhall view
@@ -0,0 +1,1 @@+"3"
+ dhall-lang/tests/normalization/success/prelude/Natural/show/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.show 0
+ dhall-lang/tests/normalization/success/prelude/Natural/show/1B.dhall view
@@ -0,0 +1,1 @@+"0"
+ dhall-lang/tests/normalization/success/prelude/Natural/sum/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.sum [ 2, 3, 5 ]
+ dhall-lang/tests/normalization/success/prelude/Natural/sum/0B.dhall view
@@ -0,0 +1,1 @@+10
+ dhall-lang/tests/normalization/success/prelude/Natural/sum/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.sum ([] : List Natural)
+ dhall-lang/tests/normalization/success/prelude/Natural/sum/1B.dhall view
@@ -0,0 +1,1 @@+0
+ dhall-lang/tests/normalization/success/prelude/Natural/toDouble/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.toDouble 3
+ dhall-lang/tests/normalization/success/prelude/Natural/toDouble/0B.dhall view
@@ -0,0 +1,1 @@+3.0
+ dhall-lang/tests/normalization/success/prelude/Natural/toDouble/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.toDouble 0
+ dhall-lang/tests/normalization/success/prelude/Natural/toDouble/1B.dhall view
@@ -0,0 +1,1 @@+0.0
+ dhall-lang/tests/normalization/success/prelude/Natural/toInteger/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.toInteger 3
+ dhall-lang/tests/normalization/success/prelude/Natural/toInteger/0B.dhall view
@@ -0,0 +1,1 @@++3
+ dhall-lang/tests/normalization/success/prelude/Natural/toInteger/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Natural`.toInteger 0
+ dhall-lang/tests/normalization/success/prelude/Natural/toInteger/1B.dhall view
@@ -0,0 +1,1 @@++0
+ dhall-lang/tests/normalization/success/prelude/Optional/all/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (Some 3)
+ dhall-lang/tests/normalization/success/prelude/Optional/all/0B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Optional/all/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (None Natural)
+ dhall-lang/tests/normalization/success/prelude/Optional/all/1B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/Optional/any/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (Some 2)
+ dhall-lang/tests/normalization/success/prelude/Optional/any/0B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/Optional/any/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (None Natural)
+ dhall-lang/tests/normalization/success/prelude/Optional/any/1B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/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+)
+ dhall-lang/tests/normalization/success/prelude/Optional/build/0B.dhall view
@@ -0,0 +1,1 @@+Some 1
+ dhall-lang/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+)
+ dhall-lang/tests/normalization/success/prelude/Optional/build/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ dhall-lang/tests/normalization/success/prelude/Optional/concat/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (Some 1))
+ dhall-lang/tests/normalization/success/prelude/Optional/concat/0B.dhall view
@@ -0,0 +1,1 @@+Some 1
+ dhall-lang/tests/normalization/success/prelude/Optional/concat/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (None Natural))
+ dhall-lang/tests/normalization/success/prelude/Optional/concat/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ dhall-lang/tests/normalization/success/prelude/Optional/concat/2A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (None (Optional Natural))
+ dhall-lang/tests/normalization/success/prelude/Optional/concat/2B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ dhall-lang/tests/normalization/success/prelude/Optional/filter/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/even (Some 2)
+ dhall-lang/tests/normalization/success/prelude/Optional/filter/0B.dhall view
@@ -0,0 +1,1 @@+Some 2
+ dhall-lang/tests/normalization/success/prelude/Optional/filter/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/odd (Some 2)
+ dhall-lang/tests/normalization/success/prelude/Optional/filter/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ dhall-lang/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
+ dhall-lang/tests/normalization/success/prelude/Optional/fold/0B.dhall view
@@ -0,0 +1,1 @@+2
+ dhall-lang/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
+ dhall-lang/tests/normalization/success/prelude/Optional/fold/1B.dhall view
@@ -0,0 +1,1 @@+0
+ dhall-lang/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 ]
+ dhall-lang/tests/normalization/success/prelude/Optional/head/0B.dhall view
@@ -0,0 +1,1 @@+Some 1
+ dhall-lang/tests/normalization/success/prelude/Optional/head/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.head Natural [ None Natural, None Natural ]
+ dhall-lang/tests/normalization/success/prelude/Optional/head/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ dhall-lang/tests/normalization/success/prelude/Optional/head/2A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.head Natural ([] : List (Optional Natural))
+ dhall-lang/tests/normalization/success/prelude/Optional/head/2B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ dhall-lang/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 ]
+ dhall-lang/tests/normalization/success/prelude/Optional/last/0B.dhall view
@@ -0,0 +1,1 @@+Some 2
+ dhall-lang/tests/normalization/success/prelude/Optional/last/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.last Natural [ None Natural, None Natural ]
+ dhall-lang/tests/normalization/success/prelude/Optional/last/1B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ dhall-lang/tests/normalization/success/prelude/Optional/last/2A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.last Natural ([] : List (Optional Natural))
+ dhall-lang/tests/normalization/success/prelude/Optional/last/2B.dhall view
@@ -0,0 +1,1 @@+None Natural
+ dhall-lang/tests/normalization/success/prelude/Optional/length/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.length Natural (Some 2)
+ dhall-lang/tests/normalization/success/prelude/Optional/length/0B.dhall view
@@ -0,0 +1,1 @@+1
+ dhall-lang/tests/normalization/success/prelude/Optional/length/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.length Natural (None Natural)
+ dhall-lang/tests/normalization/success/prelude/Optional/length/1B.dhall view
@@ -0,0 +1,1 @@+0
+ dhall-lang/tests/normalization/success/prelude/Optional/map/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (Some 3)
+ dhall-lang/tests/normalization/success/prelude/Optional/map/0B.dhall view
@@ -0,0 +1,1 @@+Some False
+ dhall-lang/tests/normalization/success/prelude/Optional/map/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (None Natural)
+ dhall-lang/tests/normalization/success/prelude/Optional/map/1B.dhall view
@@ -0,0 +1,1 @@+None Bool
+ dhall-lang/tests/normalization/success/prelude/Optional/null/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.null Natural (Some 2)
+ dhall-lang/tests/normalization/success/prelude/Optional/null/0B.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/normalization/success/prelude/Optional/null/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.null Natural (None Natural)
+ dhall-lang/tests/normalization/success/prelude/Optional/null/1B.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/normalization/success/prelude/Optional/toList/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.toList Natural (Some 1)
+ dhall-lang/tests/normalization/success/prelude/Optional/toList/0B.dhall view
@@ -0,0 +1,1 @@+[ 1 ] : List Natural
+ dhall-lang/tests/normalization/success/prelude/Optional/toList/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Optional`.toList Natural (None Natural)
+ dhall-lang/tests/normalization/success/prelude/Optional/toList/1B.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ dhall-lang/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 })
+ dhall-lang/tests/normalization/success/prelude/Optional/unzip/0B.dhall view
@@ -0,0 +1,1 @@+{ _1 = Some "ABC", _2 = Some True }
+ dhall-lang/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 })
+ dhall-lang/tests/normalization/success/prelude/Optional/unzip/1B.dhall view
@@ -0,0 +1,1 @@+{ _1 = None Text, _2 = None Bool }
+ dhall-lang/tests/normalization/success/prelude/Text/concat/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concat [ "ABC", "DEF", "GHI" ]
+ dhall-lang/tests/normalization/success/prelude/Text/concat/0B.dhall view
@@ -0,0 +1,1 @@+"ABCDEFGHI"
+ dhall-lang/tests/normalization/success/prelude/Text/concat/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concat ([] : List Text)
+ dhall-lang/tests/normalization/success/prelude/Text/concat/1B.dhall view
@@ -0,0 +1,1 @@+""
+ dhall-lang/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 ]
+ dhall-lang/tests/normalization/success/prelude/Text/concatMap/0B.dhall view
@@ -0,0 +1,1 @@+"0 1 2 "
+ dhall-lang/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)
+ dhall-lang/tests/normalization/success/prelude/Text/concatMap/1B.dhall view
@@ -0,0 +1,1 @@+""
+ dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show [ 0, 1, 2 ]
+ dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/0B.dhall view
@@ -0,0 +1,1 @@+"0, 1, 2"
+ dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show ([] : List Natural)
+ dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/1B.dhall view
@@ -0,0 +1,1 @@+""
+ dhall-lang/tests/normalization/success/prelude/Text/concatSep/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concatSep ", " [ "ABC", "DEF", "GHI" ]
+ dhall-lang/tests/normalization/success/prelude/Text/concatSep/0B.dhall view
@@ -0,0 +1,1 @@+"ABC, DEF, GHI"
+ dhall-lang/tests/normalization/success/prelude/Text/concatSep/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.concatSep ", " ([] : List Text)
+ dhall-lang/tests/normalization/success/prelude/Text/concatSep/1B.dhall view
@@ -0,0 +1,1 @@+""
+ dhall-lang/tests/normalization/success/prelude/Text/show/0A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.show "ABC"
+ dhall-lang/tests/normalization/success/prelude/Text/show/0B.dhall view
@@ -0,0 +1,1 @@+"\"ABC\""
+ dhall-lang/tests/normalization/success/prelude/Text/show/1A.dhall view
@@ -0,0 +1,1 @@+(../../../../../../Prelude/package.dhall).`Text`.show "\u0000 \$ \\ \n \u263a"
+ dhall-lang/tests/normalization/success/prelude/Text/show/1B.dhall view
@@ -0,0 +1,1 @@+"\"\\u0000 \\u0024 \\\\ \\n ☺\""
+ dhall-lang/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
+ dhall-lang/tests/normalization/success/remoteSystemsB.dhall view
@@ -0,0 +1,212 @@+  λ ( _+    : List+      { cores :+          Natural+      , host :+          Text+      , key :+          Text+      , mandatoryFeatures :+          List Text+      , platforms :+          List Text+      , speedFactor :+          Natural+      , supportedFeatures :+          List Text+      , user :+          Optional Text+      }+    )+→ List/fold+  { cores :+      Natural+  , host :+      Text+  , key :+      Text+  , mandatoryFeatures :+      List Text+  , platforms :+      List Text+  , speedFactor :+      Natural+  , supportedFeatures :+      List Text+  , user :+      Optional Text+  }+  _+  Text+  (   λ ( _+        : { cores :+              Natural+          , host :+              Text+          , key :+              Text+          , mandatoryFeatures :+              List Text+          , platforms :+              List Text+          , speedFactor :+              Natural+          , supportedFeatures :+              List Text+          , user :+              Optional Text+          }+        )+    → λ(_ : Text)+    →     ''+          ${Optional/fold+            Text+            _@1.user+            Text+            (λ(user : Text) → "${user}@${_@1.host}")+            _@1.host} ${merge+                        { Empty = λ(_ : {}) → "", NonEmpty = λ(_ : Text) → _ }+                        ( List/fold+                          Text+                          _@1.platforms+                          < Empty : {} | NonEmpty : Text >+                          (   λ(_ : Text)+                            → λ(_ : < Empty : {} | NonEmpty : Text >)+                            → merge+                              { Empty =+                                  λ(_ : {}) → < NonEmpty = _@2 | Empty : {} >+                              , NonEmpty =+                                    λ(_ : Text)+                                  → < NonEmpty = _@2 ++ "," ++ _ | Empty : {} >+                              }+                              _+                              : < Empty : {} | NonEmpty : Text >+                          )+                          < Empty = {=} | NonEmpty : Text >+                        )+                        : Text} ${_@1.key} ${Integer/show+                                             ( Natural/toInteger _@1.cores+                                             )} ${Integer/show+                                                  ( Natural/toInteger+                                                    _@1.speedFactor+                                                  )} ${merge+                                                       { Empty =+                                                           λ(_ : {}) → ""+                                                       , NonEmpty =+                                                           λ(_ : Text) → _+                                                       }+                                                       ( List/fold+                                                         Text+                                                         _@1.supportedFeatures+                                                         < Empty :+                                                             {}+                                                         | NonEmpty :+                                                             Text+                                                         >+                                                         (   λ(_ : Text)+                                                           → λ ( _+                                                               : < Empty :+                                                                     {}+                                                                 | NonEmpty :+                                                                     Text+                                                                 >+                                                               )+                                                           → merge+                                                             { Empty =+                                                                   λ(_ : {})+                                                                 → < NonEmpty =+                                                                       _@2+                                                                   | Empty :+                                                                       {}+                                                                   >+                                                             , NonEmpty =+                                                                   λ(_ : Text)+                                                                 → < NonEmpty =+                                                                           _@2+                                                                       ++  ","+                                                                       ++  _+                                                                   | Empty :+                                                                       {}+                                                                   >+                                                             }+                                                             _+                                                             : < Empty :+                                                                   {}+                                                               | NonEmpty :+                                                                   Text+                                                               >+                                                         )+                                                         < Empty =+                                                             {=}+                                                         | NonEmpty :+                                                             Text+                                                         >+                                                       )+                                                       : Text} ${merge+                                                                 { Empty =+                                                                       λ(_ : {})+                                                                     → ""+                                                                 , NonEmpty =+                                                                       λ ( _+                                                                         : Text+                                                                         )+                                                                     → _+                                                                 }+                                                                 ( List/fold+                                                                   Text+                                                                   _@1.mandatoryFeatures+                                                                   < Empty :+                                                                       {}+                                                                   | NonEmpty :+                                                                       Text+                                                                   >+                                                                   (   λ ( _+                                                                         : Text+                                                                         )+                                                                     → λ ( _+                                                                         : < Empty :+                                                                               {}+                                                                           | NonEmpty :+                                                                               Text+                                                                           >+                                                                         )+                                                                     → merge+                                                                       { Empty =+                                                                             λ ( _+                                                                               : {}+                                                                               )+                                                                           → < NonEmpty =+                                                                                 _@2+                                                                             | Empty :+                                                                                 {}+                                                                             >+                                                                       , NonEmpty =+                                                                             λ ( _+                                                                               : Text+                                                                               )+                                                                           → < NonEmpty =+                                                                                     _@2+                                                                                 ++  ","+                                                                                 ++  _+                                                                             | Empty :+                                                                                 {}+                                                                             >+                                                                       }+                                                                       _+                                                                       : < Empty :+                                                                             {}+                                                                         | NonEmpty :+                                                                             Text+                                                                         >+                                                                   )+                                                                   < Empty =+                                                                       {=}+                                                                   | NonEmpty :+                                                                       Text+                                                                   >+                                                                 )+                                                                 : Text}+          ''+      ++  _+  )+  ""
+ dhall-lang/tests/normalization/success/simple/doubleShowA.dhall view
@@ -0,0 +1,6 @@+{ example0 = Double/show -0.42+, example1 = Double/show 13.37+, example2 = Double/show NaN+, example3 = Double/show Infinity+, example4 = Double/show -Infinity+}
+ dhall-lang/tests/normalization/success/simple/doubleShowB.dhall view
@@ -0,0 +1,6 @@+{ example0 = "-0.42"+, example1 = "13.37"+, example2 = "NaN"+, example3 = "Infinity"+, example4 = "-Infinity"+}
+ dhall-lang/tests/normalization/success/simple/integerShowA.dhall view
@@ -0,0 +1,4 @@+{ example0 = Integer/show +1337+, example1 = Integer/show -42+, example2 = Integer/show +0+}
+ dhall-lang/tests/normalization/success/simple/integerShowB.dhall view
@@ -0,0 +1,1 @@+{ example0 = "+1337", example1 = "-42", example2 = "+0" }
+ dhall-lang/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+]
+ dhall-lang/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+]
+ dhall-lang/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
+ dhall-lang/tests/normalization/success/simple/letletB.dhall view
@@ -0,0 +1,1 @@+1337
+ dhall-lang/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))+      )+}
+ dhall-lang/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 ]+}
+ dhall-lang/tests/normalization/success/simple/multiLineA.dhall view
@@ -0,0 +1,4 @@+''+ foo+bar+''
+ dhall-lang/tests/normalization/success/simple/multiLineB.dhall view
@@ -0,0 +1,4 @@+''+ foo+bar+''
+ dhall-lang/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)+      )+}
+ dhall-lang/tests/normalization/success/simple/naturalBuildB.dhall view
@@ -0,0 +1,7 @@+{ example0 =+    1+, example1 =+    1+, example2 =+    λ(id : ∀(a : Type) → a → a) → id Natural 1+}
+ dhall-lang/tests/normalization/success/simple/naturalPlusA.dhall view
@@ -0,0 +1,1 @@+1 + 2
+ dhall-lang/tests/normalization/success/simple/naturalPlusB.dhall view
@@ -0,0 +1,1 @@+3
+ dhall-lang/tests/normalization/success/simple/naturalShowA.dhall view
@@ -0,0 +1,1 @@+Natural/show 42
+ dhall-lang/tests/normalization/success/simple/naturalShowB.dhall view
@@ -0,0 +1,1 @@+"42"
+ dhall-lang/tests/normalization/success/simple/naturalToIntegerA.dhall view
@@ -0,0 +1,1 @@+Natural/toInteger 1
+ dhall-lang/tests/normalization/success/simple/naturalToIntegerB.dhall view
@@ -0,0 +1,1 @@++1
+ dhall-lang/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+      )+}
+ dhall-lang/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+}
+ dhall-lang/tests/normalization/success/simple/optionalBuildFoldA.dhall view
@@ -0,0 +1,1 @@+Optional/build Text (Optional/fold Text ([ "foo" ] : Optional Text))
+ dhall-lang/tests/normalization/success/simple/optionalBuildFoldB.dhall view
@@ -0,0 +1,1 @@+[ "foo" ] : Optional Text
+ dhall-lang/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)+    }
+ dhall-lang/tests/normalization/success/simple/optionalFoldB.dhall view
@@ -0,0 +1,1 @@+{ example0 = 1, example1 = 2 }
+ dhall-lang/tests/normalization/success/simple/sortOperatorA.dhall view
@@ -0,0 +1,1 @@+{ b = 2 } // { a = 1 }
+ dhall-lang/tests/normalization/success/simple/sortOperatorB.dhall view
@@ -0,0 +1,1 @@+{ a = 1, b = 2 }
+ dhall-lang/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+}
+ dhall-lang/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+}
+ dhall-lang/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+}
+ dhall-lang/tests/normalization/success/simplifications/eqB.dhall view
@@ -0,0 +1,4 @@+{ example0 = λ(x : Bool) → x+, example1 = λ(x : Bool) → x+, example2 = λ(x : Bool) → True+}
+ dhall-lang/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+}
+ dhall-lang/tests/normalization/success/simplifications/ifThenElseB.dhall view
@@ -0,0 +1,3 @@+{ example0 = λ(x : Bool) → x+, example1 = λ(x : Bool) → λ(y : Text) → y+}
+ dhall-lang/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+}
+ dhall-lang/tests/normalization/success/simplifications/neB.dhall view
@@ -0,0 +1,4 @@+{ example0 = λ(x : Bool) → x+, example1 = λ(x : Bool) → x+, example2 = λ(x : Bool) → False+}
+ dhall-lang/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+}
+ dhall-lang/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+}
+ dhall-lang/tests/parser/failure/annotation.dhall view
@@ -0,0 +1,1 @@+let a:Natural = 1 in a
+ dhall-lang/tests/parser/failure/doubleBoundsNeg.dhall view
@@ -0,0 +1,1 @@+-179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0
+ dhall-lang/tests/parser/failure/doubleBoundsPos.dhall view
@@ -0,0 +1,1 @@+179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0
+ dhall-lang/tests/parser/failure/importAccess.dhall view
@@ -0,0 +1,1 @@+./testImport .hello
+ dhall-lang/tests/parser/failure/incompleteIf.dhall view
@@ -0,0 +1,10 @@+-- This test verifies that an implementation rejects the following expression at+-- parse time (i.e. due to an incomplete `if` expression) rather than at+-- type-checking time (i.e. due to an unbound variable named `if` or `else`)+--+-- This ensures that implementations are not treating keywords as potential+-- identifier names.  In other words, if they fail to parse an incomplete+-- `if` expression they don't try to alternatively parse the expression as+-- function application instead.++if a then b else
+ dhall-lang/tests/parser/failure/mandatoryNewline.dhall view
@@ -0,0 +1,2 @@+-- Multi-line literals require a mandatory newline after the opening quotes+''ABC''
+ dhall-lang/tests/parser/failure/missingSpace.dhall view
@@ -0,0 +1,2 @@+-- There needs to be a space between a function and its argument+./example.dhall[1]
+ dhall-lang/tests/parser/failure/spaceAfterListAppend.dhall view
@@ -0,0 +1,2 @@+-- Some operators require a space after them+[ 1 ]#[ 2 ]
+ dhall-lang/tests/parser/success/annotationsA.dhall view
@@ -0,0 +1,4 @@+{ foo = ([] : List Natural) # [1, 2, 3] # ([1, 2, 3] : List Natural)+, bar = [] : Optional Natural+, baz = [1] : Optional Natural+} : { foo : List Natural, bar : Optional Natural, baz : Optional Natural }
+ dhall-lang/tests/parser/success/annotationsB.dhallb view

binary file changed (absent → 167 bytes)

+ dhall-lang/tests/parser/success/asTextA.dhall view
@@ -0,0 +1,1 @@+https://example.com/foo as Text
+ dhall-lang/tests/parser/success/asTextB.dhallb view
@@ -0,0 +1,1 @@+‰öökexample.comcfooöö
+ dhall-lang/tests/parser/success/blockCommentA.dhall view
@@ -0,0 +1,3 @@+{- foo -}++1
+ dhall-lang/tests/parser/success/blockCommentB.dhallb view
@@ -0,0 +1,1 @@+‚
+ dhall-lang/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+  }
+ dhall-lang/tests/parser/success/builtinsB.dhallb view

binary file changed (absent → 531 bytes)

+ dhall-lang/tests/parser/success/collectionImportTypeA.dhall view
@@ -0,0 +1,3 @@+{ example0 = [] : Optional ./type.dhall+, example1 = [] : List ./type.dhall+}
+ dhall-lang/tests/parser/success/collectionImportTypeB.dhallb view

binary file changed (absent → 59 bytes)

+ dhall-lang/tests/parser/success/doubleA.dhall view
@@ -0,0 +1,1 @@+[ 1.1, -1.1, 1e1, 1.1e1, NaN, Infinity, -Infinity, 0.0 ]
+ dhall-lang/tests/parser/success/doubleB.dhallb view

binary file changed (absent → 43 bytes)

+ dhall-lang/tests/parser/success/doubleQuotedStringA.dhall view
@@ -0,0 +1,1 @@+"ABC"
+ dhall-lang/tests/parser/success/doubleQuotedStringB.dhallb view
@@ -0,0 +1,1 @@+‚cABC
+ dhall-lang/tests/parser/success/environmentVariablesA.dhall view
@@ -0,0 +1,5 @@+[ env:FOO++  -- Yes, this is legal+, env:"\"\\\a\b\f\n\r\t\v"+]
+ dhall-lang/tests/parser/success/environmentVariablesB.dhallb view

binary file changed (absent → 38 bytes)

+ dhall-lang/tests/parser/success/escapedDoubleQuotedStringA.dhall view
@@ -0,0 +1,1 @@+"\\\"\$\\\/\b\f\n\r\t \u2200(a : Type) \u2192 a"
+ dhall-lang/tests/parser/success/escapedDoubleQuotedStringB.dhallb view
@@ -0,0 +1,2 @@+‚x\"$\/+
	 ∀(a : Type) → a
+ dhall-lang/tests/parser/success/escapedSingleQuotedStringA.dhall view
@@ -0,0 +1,4 @@+''+''${+'''+''
+ dhall-lang/tests/parser/success/escapedSingleQuotedStringB.dhallb view
@@ -0,0 +1,2 @@+‚f${+''
+ dhall-lang/tests/parser/success/fieldsA.dhall view
@@ -0,0 +1,1 @@+({ foo = { bar = { baz = 1 } } }).foo. bar .baz
+ dhall-lang/tests/parser/success/fieldsB.dhallb view
@@ -0,0 +1,1 @@+ƒ	ƒ	ƒ	‚¡cfoo‚¡cbar‚¡cbaz‚cfoocbarcbaz
+ dhall-lang/tests/parser/success/forallA.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → forall (b : Type) -> a
+ dhall-lang/tests/parser/success/forallB.dhallb view
@@ -0,0 +1,1 @@+„aadType„abdTypeaa
+ dhall-lang/tests/parser/success/functionTypeA.dhall view
@@ -0,0 +1,1 @@+Bool → Bool -> Bool
+ dhall-lang/tests/parser/success/functionTypeB.dhallb view
@@ -0,0 +1,1 @@+ƒdBoolƒdBooldBool
+ dhall-lang/tests/parser/success/identifierA.dhall view
@@ -0,0 +1,1 @@+λ(a : Type) → λ(a : Type) → a@1
+ dhall-lang/tests/parser/success/identifierB.dhallb view
@@ -0,0 +1,1 @@+„aadType„aadType‚aa
+ dhall-lang/tests/parser/success/ifThenElseA.dhall view
@@ -0,0 +1,1 @@+if True then 1 else 2
+ dhall-lang/tests/parser/success/ifThenElseB.dhallb view
@@ -0,0 +1,1 @@+„õ‚‚
+ dhall-lang/tests/parser/success/importAltA.dhall view
@@ -0,0 +1,1 @@+env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2
+ dhall-lang/tests/parser/success/importAltB.dhallb view

binary file changed (absent → 60 bytes)

+ dhall-lang/tests/parser/success/interpolatedDoubleQuotedStringA.dhall view
@@ -0,0 +1,1 @@+"ABC${Natural/show 123}"
+ dhall-lang/tests/parser/success/interpolatedDoubleQuotedStringB.dhallb view

binary file changed (absent → 26 bytes)

+ dhall-lang/tests/parser/success/interpolatedSingleQuotedStringA.dhall view
@@ -0,0 +1,4 @@+''+ABC+${Natural/show 123}+''
+ dhall-lang/tests/parser/success/interpolatedSingleQuotedStringB.dhallb view

binary file changed (absent → 28 bytes)

+ dhall-lang/tests/parser/success/labelA.dhall view
@@ -0,0 +1,2 @@+let _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ = 1+in  _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/
+ dhall-lang/tests/parser/success/labelB.dhallb view
@@ -0,0 +1,1 @@+…xA_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ö‚xA_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/
+ dhall-lang/tests/parser/success/lambdaA.dhall view
@@ -0,0 +1,1 @@+λ(a : Type) → \(b : Type) -> a
+ dhall-lang/tests/parser/success/lambdaB.dhallb view
@@ -0,0 +1,1 @@+„aadType„abdTypeaa
+ dhall-lang/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+  )+  ""
+ dhall-lang/tests/parser/success/largeExpressionB.dhallb view

binary file changed (absent → 3678 bytes)

+ dhall-lang/tests/parser/success/letA.dhall view
@@ -0,0 +1,3 @@+    let x = 1+in  let y : Natural = 2+in  x
+ dhall-lang/tests/parser/success/letB.dhallb view
@@ -0,0 +1,1 @@+…axö‚…aygNatural‚ax
+ dhall-lang/tests/parser/success/lineCommentA.dhall view
@@ -0,0 +1,3 @@+-- foo++1
+ dhall-lang/tests/parser/success/lineCommentB.dhallb view
@@ -0,0 +1,1 @@+‚
+ dhall-lang/tests/parser/success/listA.dhall view
@@ -0,0 +1,4 @@+[ [+1, +2, +3]+, [+1, +2, +3] : List Integer+, [] : List Integer+]
+ dhall-lang/tests/parser/success/listB.dhallb view

binary file changed (absent → 55 bytes)

+ dhall-lang/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 >+  }
+ dhall-lang/tests/parser/success/mergeB.dhallb view
@@ -0,0 +1,1 @@+„ax‚ ‚¢cbar„‚ axgIntegercfooƒ‚¢dLeft„abdBoolabeRightlNatural/even„dLeftõ¡eRightgNatural
+ dhall-lang/tests/parser/success/multiletA.dhall view
@@ -0,0 +1,3 @@+let a = 1+let b = 2+in  a + b
+ dhall-lang/tests/parser/success/multiletB.dhallb view
@@ -0,0 +1,1 @@+ˆaaö‚abö‚„aaab
+ dhall-lang/tests/parser/success/naturalA.dhall view
@@ -0,0 +1,1 @@+[ 0, 1, 01, 10 ]
+ dhall-lang/tests/parser/success/naturalB.dhallb view

binary file changed (absent → 15 bytes)

+ dhall-lang/tests/parser/success/nestedBlockCommentA.dhall view
@@ -0,0 +1,3 @@+{- foo {- bar -} baz -}++1
+ dhall-lang/tests/parser/success/nestedBlockCommentB.dhallb view
@@ -0,0 +1,1 @@+‚
+ dhall-lang/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 }
+ dhall-lang/tests/parser/success/operatorsB.dhallb view

binary file changed (absent → 104 bytes)

+ dhall-lang/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
+ dhall-lang/tests/parser/success/parenthesizeUsingB.dhallb view

binary file changed (absent → 271 bytes)

+ dhall-lang/tests/parser/success/pathTerminationA.dhall view
@@ -0,0 +1,3 @@+-- Verify that certain punctuation marks terminate paths correctly+  λ(x : ./example)+→ [./example, {bar = <baz = ./example>, qux = ./example}, ./example]
+ dhall-lang/tests/parser/success/pathTerminationB.dhallb view

binary file changed (absent → 95 bytes)

+ dhall-lang/tests/parser/success/pathsA.dhall view
@@ -0,0 +1,5 @@+[ /absolute/path+, ./relative/path+, ~/home/anchored/path+, /ipfs/QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx/Prelude+]
+ dhall-lang/tests/parser/success/pathsB.dhallb view

binary file changed (absent → 135 bytes)

+ dhall-lang/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`+}
+ dhall-lang/tests/parser/success/quotedLabelB.dhallb view
@@ -0,0 +1,1 @@+‚£hexample1…cletö‚clethexample2…b:.ö‚b:.hexample3…d$refö‚d$ref
+ dhall-lang/tests/parser/success/quotedPathsA.dhall view
@@ -0,0 +1,3 @@+{ example0 = /"foo"/bar/"baz qux"+, example1 = https://example.com/foo/"bar?baz"?qux+}
+ dhall-lang/tests/parser/success/quotedPathsB.dhallb view

binary file changed (absent → 79 bytes)

+ dhall-lang/tests/parser/success/recordA.dhall view
@@ -0,0 +1,4 @@+{ foo = +1+, bar = 2+, baz = True+} : { foo : Integer, bar : Natural, baz : Bool }
+ dhall-lang/tests/parser/success/recordB.dhallb view
@@ -0,0 +1,1 @@+ƒ‚£cbar‚cbazõcfoo‚‚£cbargNaturalcbazdBoolcfoogInteger
+ dhall-lang/tests/parser/success/reservedPrefixA.dhall view
@@ -0,0 +1,1 @@+let TypeSynonym = Integer in +1 : TypeSynonym
+ dhall-lang/tests/parser/success/reservedPrefixB.dhallb view
@@ -0,0 +1,1 @@+…kTypeSynonymögIntegerƒ‚kTypeSynonym
+ dhall-lang/tests/parser/success/singleQuotedStringA.dhall view
@@ -0,0 +1,4 @@+''+ABC+DEF+''
+ dhall-lang/tests/parser/success/singleQuotedStringB.dhallb view
@@ -0,0 +1,2 @@+‚hABC+DEF
+ dhall-lang/tests/parser/success/sortA.dhall view
@@ -0,0 +1,1 @@+Sort
+ dhall-lang/tests/parser/success/sortB.dhallb view
@@ -0,0 +1,1 @@+dSort
+ dhall-lang/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 ""+ }+''
+ dhall-lang/tests/parser/success/templateB.dhallb view

binary file changed (absent → 236 bytes)

+ dhall-lang/tests/parser/success/unicodeCommentA.dhall view
@@ -0,0 +1,3 @@+{- ∀(a : Type) → a -}++1
+ dhall-lang/tests/parser/success/unicodeCommentB.dhallb view
@@ -0,0 +1,1 @@+‚
+ dhall-lang/tests/parser/success/unicodeDoubleQuotedStringA.dhall view
@@ -0,0 +1,1 @@+"∀(a : Type) → a"
+ dhall-lang/tests/parser/success/unicodeDoubleQuotedStringB.dhallb view
@@ -0,0 +1,1 @@+‚s∀(a : Type) → a
+ dhall-lang/tests/parser/success/unicodePathsA.dhall view
@@ -0,0 +1,1 @@+./families/"禺.dhall"
+ dhall-lang/tests/parser/success/unicodePathsB.dhallb view

binary file changed (absent → 25 bytes)

+ dhall-lang/tests/parser/success/unionA.dhall view
@@ -0,0 +1,4 @@+< A : {   }+| B = { = }+| C : {}+> : < A : {} | B : {} | C : {} >
+ dhall-lang/tests/parser/success/unionB.dhallb view
@@ -0,0 +1,1 @@+ƒ„aB‚ ¢aA‚ aC‚ ‚£aA‚ aB‚ aC‚ 
+ dhall-lang/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!$&'()*+,;=:@/?+]
+ dhall-lang/tests/parser/success/urlsB.dhallb view

binary file changed (absent → 558 bytes)

+ dhall-lang/tests/parser/success/whitespaceA.dhall view
@@ -0,0 +1,3 @@++1+
+ dhall-lang/tests/parser/success/whitespaceB.dhallb view
@@ -0,0 +1,1 @@+‚
+ dhall-lang/tests/parser/success/whitespaceBuffetA.dhall view
@@ -0,0 +1,9 @@+    -- This+
+     Natural/even {-+
+{- file+-}
+  has+
+ -}  2 -- mixed {- line endings -}
+ dhall-lang/tests/parser/success/whitespaceBuffetB.dhallb view

binary file changed (absent → 18 bytes)

+ dhall-lang/tests/typecheck/failure/combineMixedRecords.dhall view
@@ -0,0 +1,1 @@+{ foo = 1 } ∧ { bar = Text }
+ dhall-lang/tests/typecheck/failure/duplicateFields.dhall view
@@ -0,0 +1,1 @@+{ a = 1, a = 2 }
+ dhall-lang/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
+ dhall-lang/tests/typecheck/failure/mixedUnions.dhall view
@@ -0,0 +1,1 @@+< Left : Natural | Right : Type >
+ dhall-lang/tests/typecheck/failure/preferMixedRecords.dhall view
@@ -0,0 +1,1 @@+{ foo = 1 } ⫽ { bar = Text }
+ dhall-lang/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)
+ dhall-lang/tests/typecheck/success/accessEncodedTypeB.dhall view
@@ -0,0 +1,4 @@+  ∀ ( record+    : ∀(k : Kind) → ∀(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k) → k+    )+→ Type
+ dhall-lang/tests/typecheck/success/accessTypeA.dhall view
@@ -0,0 +1,1 @@+λ(record : { x : Type, y : Type → Type }) → record.x
+ dhall-lang/tests/typecheck/success/accessTypeB.dhall view
@@ -0,0 +1,1 @@+∀(record : { x : Type, y : Type → Type }) → Type
+ dhall-lang/tests/typecheck/success/prelude/Bool/and/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/and [ True, False, True ]
+ dhall-lang/tests/typecheck/success/prelude/Bool/and/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/and/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/and ([] : List Bool)
+ dhall-lang/tests/typecheck/success/prelude/Bool/and/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/build/0A.dhall view
@@ -0,0 +1,2 @@+../../../../../../Prelude/Bool/build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → true)
+ dhall-lang/tests/typecheck/success/prelude/Bool/build/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/build/1A.dhall view
@@ -0,0 +1,2 @@+../../../../../../Prelude/Bool/build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → false)
+ dhall-lang/tests/typecheck/success/prelude/Bool/build/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/even/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even [ False, True, False ]
+ dhall-lang/tests/typecheck/success/prelude/Bool/even/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/even/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even [ False, True ]
+ dhall-lang/tests/typecheck/success/prelude/Bool/even/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/even/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even [ False ]
+ dhall-lang/tests/typecheck/success/prelude/Bool/even/2B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/even/3A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even ([] : List Bool)
+ dhall-lang/tests/typecheck/success/prelude/Bool/even/3B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/fold/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/fold True Natural 0 1
+ dhall-lang/tests/typecheck/success/prelude/Bool/fold/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Bool/fold/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/fold False Natural 0 1
+ dhall-lang/tests/typecheck/success/prelude/Bool/fold/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Bool/not/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/not True
+ dhall-lang/tests/typecheck/success/prelude/Bool/not/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/not/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/not False
+ dhall-lang/tests/typecheck/success/prelude/Bool/not/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/odd/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd [ True, False, True ]
+ dhall-lang/tests/typecheck/success/prelude/Bool/odd/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/odd/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd [ True, False ]
+ dhall-lang/tests/typecheck/success/prelude/Bool/odd/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/odd/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd [ True ]
+ dhall-lang/tests/typecheck/success/prelude/Bool/odd/2B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/odd/3A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd ([] : List Bool)
+ dhall-lang/tests/typecheck/success/prelude/Bool/odd/3B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/or/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/or [ True, False, True ]
+ dhall-lang/tests/typecheck/success/prelude/Bool/or/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/or/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/or ([] : List Bool)
+ dhall-lang/tests/typecheck/success/prelude/Bool/or/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Bool/show/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/show True
+ dhall-lang/tests/typecheck/success/prelude/Bool/show/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Bool/show/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/show False
+ dhall-lang/tests/typecheck/success/prelude/Bool/show/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Double/show/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Double/show -3.1
+ dhall-lang/tests/typecheck/success/prelude/Double/show/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Double/show/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Double/show 0.4
+ dhall-lang/tests/typecheck/success/prelude/Double/show/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Integer/show/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/show -3
+ dhall-lang/tests/typecheck/success/prelude/Integer/show/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Integer/show/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/show +0
+ dhall-lang/tests/typecheck/success/prelude/Integer/show/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/toDouble -3
+ dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/0B.dhall view
@@ -0,0 +1,1 @@+Double
+ dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/toDouble +2
+ dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/1B.dhall view
@@ -0,0 +1,1 @@+Double
+ dhall-lang/tests/typecheck/success/prelude/List/all/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/all Natural Natural/even [ 2, 3, 5 ]
+ dhall-lang/tests/typecheck/success/prelude/List/all/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/List/all/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/all Natural Natural/even ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/List/all/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/List/any/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/any Natural Natural/even [ 2, 3, 5 ]
+ dhall-lang/tests/typecheck/success/prelude/List/any/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/List/any/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/any Natural Natural/even ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/List/any/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/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)+)
+ dhall-lang/tests/typecheck/success/prelude/List/build/0B.dhall view
@@ -0,0 +1,1 @@+List Text
+ dhall-lang/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+)
+ dhall-lang/tests/typecheck/success/prelude/List/build/1B.dhall view
@@ -0,0 +1,1 @@+List Text
+ dhall-lang/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 ]+]
+ dhall-lang/tests/typecheck/success/prelude/List/concat/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/List/concat/1A.dhall view
@@ -0,0 +1,5 @@+../../../../../../Prelude/List/concat Natural+[ [] : List Natural+, [] : List Natural+, [] : List Natural+]
+ dhall-lang/tests/typecheck/success/prelude/List/concat/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/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 ]
+ dhall-lang/tests/typecheck/success/prelude/List/concatMap/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/List/concatMap/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/concatMap Natural Natural (λ(n : Natural) → [ n, n ]) ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/List/concatMap/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/List/filter/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/filter Natural Natural/even [ 2, 3, 5 ]
+ dhall-lang/tests/typecheck/success/prelude/List/filter/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/List/filter/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/filter Natural Natural/odd [ 2, 3, 5 ]
+ dhall-lang/tests/typecheck/success/prelude/List/filter/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/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
+ dhall-lang/tests/typecheck/success/prelude/List/fold/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/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
+ dhall-lang/tests/typecheck/success/prelude/List/fold/1B.dhall view
@@ -0,0 +1,1 @@+∀(nil : Natural) → Natural
+ dhall-lang/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
+ dhall-lang/tests/typecheck/success/prelude/List/fold/2B.dhall view
@@ -0,0 +1,1 @@+∀(list : Type) → ∀(cons : Natural → list → list) → ∀(nil : list) → list
+ dhall-lang/tests/typecheck/success/prelude/List/generate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/generate 5 Bool Natural/even
+ dhall-lang/tests/typecheck/success/prelude/List/generate/0B.dhall view
@@ -0,0 +1,1 @@+List Bool
+ dhall-lang/tests/typecheck/success/prelude/List/generate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/generate 0 Bool Natural/even
+ dhall-lang/tests/typecheck/success/prelude/List/generate/1B.dhall view
@@ -0,0 +1,1 @@+List Bool
+ dhall-lang/tests/typecheck/success/prelude/List/head/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/head Natural [ 0, 1, 2 ]
+ dhall-lang/tests/typecheck/success/prelude/List/head/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/List/head/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/head Natural ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/List/head/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/List/indexed/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/indexed Bool [ True, False, True ]
+ dhall-lang/tests/typecheck/success/prelude/List/indexed/0B.dhall view
@@ -0,0 +1,1 @@+List { index : Natural, value : Bool }
+ dhall-lang/tests/typecheck/success/prelude/List/indexed/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/indexed Bool ([] : List Bool)
+ dhall-lang/tests/typecheck/success/prelude/List/indexed/1B.dhall view
@@ -0,0 +1,1 @@+List { index : Natural, value : Bool }
+ dhall-lang/tests/typecheck/success/prelude/List/iterate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/iterate 10 Natural (λ(x : Natural) → x * 2) 1
+ dhall-lang/tests/typecheck/success/prelude/List/iterate/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/List/iterate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/iterate 0 Natural (λ(x : Natural) → x * 2) 1
+ dhall-lang/tests/typecheck/success/prelude/List/iterate/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/List/last/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/last Natural [ 0, 1, 2 ]
+ dhall-lang/tests/typecheck/success/prelude/List/last/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/List/last/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/last Natural ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/List/last/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/List/length/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/length Natural [ 0, 1, 2 ]
+ dhall-lang/tests/typecheck/success/prelude/List/length/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/List/length/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/length Natural ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/List/length/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/List/map/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/map Natural Bool Natural/even [ 2, 3, 5 ]
+ dhall-lang/tests/typecheck/success/prelude/List/map/0B.dhall view
@@ -0,0 +1,1 @@+List Bool
+ dhall-lang/tests/typecheck/success/prelude/List/map/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/map Natural Bool Natural/even ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/List/map/1B.dhall view
@@ -0,0 +1,1 @@+List Bool
+ dhall-lang/tests/typecheck/success/prelude/List/null/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/null Natural [ 0, 1, 2 ]
+ dhall-lang/tests/typecheck/success/prelude/List/null/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/List/null/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/null Natural ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/List/null/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/List/replicate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/replicate 9 Natural 1
+ dhall-lang/tests/typecheck/success/prelude/List/replicate/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/List/replicate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/replicate 0 Natural 1
+ dhall-lang/tests/typecheck/success/prelude/List/replicate/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/List/reverse/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/reverse Natural [ 0, 1, 2 ]
+ dhall-lang/tests/typecheck/success/prelude/List/reverse/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/List/reverse/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/reverse Natural ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/List/reverse/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/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 }+  ]+]
+ dhall-lang/tests/typecheck/success/prelude/List/shifted/0B.dhall view
@@ -0,0 +1,1 @@+List { index : Natural, value : Bool }
+ dhall-lang/tests/typecheck/success/prelude/List/shifted/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/shifted Bool ([] : List (List { index : Natural, value : Bool }))
+ dhall-lang/tests/typecheck/success/prelude/List/shifted/1B.dhall view
@@ -0,0 +1,1 @@+List { index : Natural, value : Bool }
+ dhall-lang/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 }+]
+ dhall-lang/tests/typecheck/success/prelude/List/unzip/0B.dhall view
@@ -0,0 +1,1 @@+{ _1 : List Text, _2 : List Bool }
+ dhall-lang/tests/typecheck/success/prelude/List/unzip/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/unzip Text Bool ([] : List { _1 : Text, _2 : Bool })
+ dhall-lang/tests/typecheck/success/prelude/List/unzip/1B.dhall view
@@ -0,0 +1,1 @@+{ _1 : List Text, _2 : List Bool }
+ dhall-lang/tests/typecheck/success/prelude/Monoid/00A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Bool`.and
+ dhall-lang/tests/typecheck/success/prelude/Monoid/00B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Bool
+ dhall-lang/tests/typecheck/success/prelude/Monoid/01A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Bool`.or
+ dhall-lang/tests/typecheck/success/prelude/Monoid/01B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Bool
+ dhall-lang/tests/typecheck/success/prelude/Monoid/02A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Bool`.even
+ dhall-lang/tests/typecheck/success/prelude/Monoid/02B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Bool
+ dhall-lang/tests/typecheck/success/prelude/Monoid/03A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Bool`.odd
+ dhall-lang/tests/typecheck/success/prelude/Monoid/03B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Bool
+ dhall-lang/tests/typecheck/success/prelude/Monoid/04A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`List`.concat
+ dhall-lang/tests/typecheck/success/prelude/Monoid/04B.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → ../../../../../Prelude/Monoid (List a)
+ dhall-lang/tests/typecheck/success/prelude/Monoid/05A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`List`.shifted
+ dhall-lang/tests/typecheck/success/prelude/Monoid/05B.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → ../../../../../Prelude/Monoid (List { index : Natural, value : a })
+ dhall-lang/tests/typecheck/success/prelude/Monoid/06A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Natural`.sum
+ dhall-lang/tests/typecheck/success/prelude/Monoid/06B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Natural
+ dhall-lang/tests/typecheck/success/prelude/Monoid/07A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Natural`.product
+ dhall-lang/tests/typecheck/success/prelude/Monoid/07B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Natural
+ dhall-lang/tests/typecheck/success/prelude/Monoid/08A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Optional`.head
+ dhall-lang/tests/typecheck/success/prelude/Monoid/08B.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → ../../../../../Prelude/Monoid (Optional a)
+ dhall-lang/tests/typecheck/success/prelude/Monoid/09A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Optional`.last
+ dhall-lang/tests/typecheck/success/prelude/Monoid/09B.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → ../../../../../Prelude/Monoid (Optional a)
+ dhall-lang/tests/typecheck/success/prelude/Monoid/10A.dhall view
@@ -0,0 +1,1 @@+(../../../../../Prelude/package.dhall).`Text`.concat
+ dhall-lang/tests/typecheck/success/prelude/Monoid/10B.dhall view
@@ -0,0 +1,1 @@+../../../../../Prelude/Monoid Text
+ dhall-lang/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))+)
+ dhall-lang/tests/typecheck/success/prelude/Natural/build/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Natural/build/1A.dhall view
@@ -0,0 +1,6 @@+../../../../../../Prelude/Natural/build+( λ(natural : Type)+→ λ(succ : natural → natural)+→ λ(zero : natural)+→ zero+)
+ dhall-lang/tests/typecheck/success/prelude/Natural/build/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/enumerate 10
+ dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/enumerate 0
+ dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/Natural/even/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/even 3
+ dhall-lang/tests/typecheck/success/prelude/Natural/even/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Natural/even/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/even 0
+ dhall-lang/tests/typecheck/success/prelude/Natural/even/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Natural/fold/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/fold 3 Natural (λ(x : Natural) → 5 * x) 1
+ dhall-lang/tests/typecheck/success/prelude/Natural/fold/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/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
+ dhall-lang/tests/typecheck/success/prelude/Natural/fold/1B.dhall view
@@ -0,0 +1,1 @@+∀(zero : Natural) → Natural
+ dhall-lang/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
+ dhall-lang/tests/typecheck/success/prelude/Natural/fold/2B.dhall view
@@ -0,0 +1,1 @@+∀(natural : Type) → ∀(succ : natural → natural) → ∀(zero : natural) → natural
+ dhall-lang/tests/typecheck/success/prelude/Natural/isZero/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/isZero 2
+ dhall-lang/tests/typecheck/success/prelude/Natural/isZero/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Natural/isZero/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/isZero 0
+ dhall-lang/tests/typecheck/success/prelude/Natural/isZero/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Natural/odd/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/odd 3
+ dhall-lang/tests/typecheck/success/prelude/Natural/odd/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Natural/odd/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/odd 0
+ dhall-lang/tests/typecheck/success/prelude/Natural/odd/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Natural/product/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/product [ 2, 3, 5 ]
+ dhall-lang/tests/typecheck/success/prelude/Natural/product/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Natural/product/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/product ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/Natural/product/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Natural/show/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/show 3
+ dhall-lang/tests/typecheck/success/prelude/Natural/show/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Natural/show/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/show 0
+ dhall-lang/tests/typecheck/success/prelude/Natural/show/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Natural/sum/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/sum [ 2, 3, 5 ]
+ dhall-lang/tests/typecheck/success/prelude/Natural/sum/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Natural/sum/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/sum ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/Natural/sum/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/toDouble 3
+ dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/0B.dhall view
@@ -0,0 +1,1 @@+Double
+ dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/toDouble 0
+ dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/1B.dhall view
@@ -0,0 +1,1 @@+Double
+ dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/toInteger 3
+ dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/0B.dhall view
@@ -0,0 +1,1 @@+Integer
+ dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/toInteger 0
+ dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/1B.dhall view
@@ -0,0 +1,1 @@+Integer
+ dhall-lang/tests/typecheck/success/prelude/Optional/all/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/all Natural Natural/even (Some 3)
+ dhall-lang/tests/typecheck/success/prelude/Optional/all/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Optional/all/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/all Natural Natural/even (None Natural)
+ dhall-lang/tests/typecheck/success/prelude/Optional/all/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Optional/any/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/any Natural Natural/even (Some 2)
+ dhall-lang/tests/typecheck/success/prelude/Optional/any/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Optional/any/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/any Natural Natural/even (None Natural)
+ dhall-lang/tests/typecheck/success/prelude/Optional/any/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/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+)
+ dhall-lang/tests/typecheck/success/prelude/Optional/build/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/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+)
+ dhall-lang/tests/typecheck/success/prelude/Optional/build/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/concat/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/concat Natural (Some (Some 1))
+ dhall-lang/tests/typecheck/success/prelude/Optional/concat/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/concat/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/concat Natural (Some (None Natural))
+ dhall-lang/tests/typecheck/success/prelude/Optional/concat/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/concat/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/concat Natural (None (Optional Natural))
+ dhall-lang/tests/typecheck/success/prelude/Optional/concat/2B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/filter/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/filter Natural Natural/even (Some 2)
+ dhall-lang/tests/typecheck/success/prelude/Optional/filter/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/filter/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/filter Natural Natural/odd (Some 2)
+ dhall-lang/tests/typecheck/success/prelude/Optional/filter/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/fold/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/fold Natural (Some 2) Natural (λ(x : Natural) → x) 0
+ dhall-lang/tests/typecheck/success/prelude/Optional/fold/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/fold/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/fold Natural (None Natural) Natural (λ(x : Natural) → x) 0
+ dhall-lang/tests/typecheck/success/prelude/Optional/fold/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/head/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/head Natural [ None Natural, Some 1, Some 2 ]
+ dhall-lang/tests/typecheck/success/prelude/Optional/head/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/head/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/head Natural [ None Natural, None Natural ]
+ dhall-lang/tests/typecheck/success/prelude/Optional/head/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/head/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/head Natural ([] : List (Optional Natural))
+ dhall-lang/tests/typecheck/success/prelude/Optional/head/2B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/last/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/last Natural [ None Natural, Some 1, Some 2 ]
+ dhall-lang/tests/typecheck/success/prelude/Optional/last/0B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/last/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/last Natural [ None Natural, None Natural ]
+ dhall-lang/tests/typecheck/success/prelude/Optional/last/1B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/last/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/last Natural ([] : List (Optional Natural))
+ dhall-lang/tests/typecheck/success/prelude/Optional/last/2B.dhall view
@@ -0,0 +1,1 @@+Optional Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/length/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/length Natural (Some 2)
+ dhall-lang/tests/typecheck/success/prelude/Optional/length/0B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/length/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/length Natural (None Natural)
+ dhall-lang/tests/typecheck/success/prelude/Optional/length/1B.dhall view
@@ -0,0 +1,1 @@+Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/map/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/map Natural Bool Natural/even (Some 3)
+ dhall-lang/tests/typecheck/success/prelude/Optional/map/0B.dhall view
@@ -0,0 +1,1 @@+Optional Bool
+ dhall-lang/tests/typecheck/success/prelude/Optional/map/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/map Natural Bool Natural/even (None Natural)
+ dhall-lang/tests/typecheck/success/prelude/Optional/map/1B.dhall view
@@ -0,0 +1,1 @@+Optional Bool
+ dhall-lang/tests/typecheck/success/prelude/Optional/null/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/null Natural (Some 2)
+ dhall-lang/tests/typecheck/success/prelude/Optional/null/0B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Optional/null/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/null Natural (None Natural)
+ dhall-lang/tests/typecheck/success/prelude/Optional/null/1B.dhall view
@@ -0,0 +1,1 @@+Bool
+ dhall-lang/tests/typecheck/success/prelude/Optional/toList/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/toList Natural (Some 1)
+ dhall-lang/tests/typecheck/success/prelude/Optional/toList/0B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/toList/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/toList Natural (None Natural)
+ dhall-lang/tests/typecheck/success/prelude/Optional/toList/1B.dhall view
@@ -0,0 +1,1 @@+List Natural
+ dhall-lang/tests/typecheck/success/prelude/Optional/unzip/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/unzip Text Bool (Some { _1 = "ABC", _2 = True })
+ dhall-lang/tests/typecheck/success/prelude/Optional/unzip/0B.dhall view
@@ -0,0 +1,1 @@+{ _1 : Optional Text, _2 : Optional Bool }
+ dhall-lang/tests/typecheck/success/prelude/Optional/unzip/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Optional/unzip Text Bool (None { _1 : Text, _2 : Bool })
+ dhall-lang/tests/typecheck/success/prelude/Optional/unzip/1B.dhall view
@@ -0,0 +1,1 @@+{ _1 : Optional Text, _2 : Optional Bool }
+ dhall-lang/tests/typecheck/success/prelude/Text/concat/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concat [ "ABC", "DEF", "GHI" ]
+ dhall-lang/tests/typecheck/success/prelude/Text/concat/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Text/concat/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concat ([] : List Text)
+ dhall-lang/tests/typecheck/success/prelude/Text/concat/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/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 ]
+ dhall-lang/tests/typecheck/success/prelude/Text/concatMap/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Text/concatMap/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concatMap Natural (λ(n : Natural) → "${Natural/show n} ") ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/Text/concatMap/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concatMapSep ", " Natural Natural/show [ 0, 1, 2 ]
+ dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concatMapSep ", " Natural Natural/show ([] : List Natural)
+ dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Text/concatSep/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concatSep ", " [ "ABC", "DEF", "GHI" ]
+ dhall-lang/tests/typecheck/success/prelude/Text/concatSep/0B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/prelude/Text/concatSep/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Text/concatSep ", " ([] : List Text)
+ dhall-lang/tests/typecheck/success/prelude/Text/concatSep/1B.dhall view
@@ -0,0 +1,1 @@+Text
+ dhall-lang/tests/typecheck/success/recordOfRecordOfTypesA.dhall view
@@ -0,0 +1,3 @@+let types = { Scopes = < Public : {} | Private : {} >}+let prelude = { types = types }+in  prelude.types.Scopes.Public {=}
+ dhall-lang/tests/typecheck/success/recordOfRecordOfTypesB.dhall view
@@ -0,0 +1,1 @@+< Public : {} | Private : {} >
+ dhall-lang/tests/typecheck/success/recordOfTypesA.dhall view
@@ -0,0 +1,1 @@+{ x = Text, y = List }
+ dhall-lang/tests/typecheck/success/recordOfTypesB.dhall view
@@ -0,0 +1,1 @@+{ x : Type, y : Type → Type }
+ dhall-lang/tests/typecheck/success/simple/access/0A.dhall view
@@ -0,0 +1,1 @@+{ x = Text }.x
+ dhall-lang/tests/typecheck/success/simple/access/0B.dhall view
@@ -0,0 +1,1 @@+Type
+ dhall-lang/tests/typecheck/success/simple/access/1A.dhall view
@@ -0,0 +1,1 @@+< Foo : Text | Bar : Natural >.Foo
+ dhall-lang/tests/typecheck/success/simple/access/1B.dhall view
@@ -0,0 +1,1 @@+∀(Foo : Text) → < Bar : Natural | Foo : Text >
+ dhall-lang/tests/typecheck/success/simple/alternativesAreTypesA.dhall view
@@ -0,0 +1,1 @@+< Left = List | Right : Type >
+ dhall-lang/tests/typecheck/success/simple/alternativesAreTypesB.dhall view
@@ -0,0 +1,1 @@+< Left : Type → Type | Right : Type >
+ dhall-lang/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)
+ dhall-lang/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)+
+ dhall-lang/tests/typecheck/success/simple/fieldsAreTypesA.dhall view
@@ -0,0 +1,1 @@+{ x = Bool, y = Text, z = List }
+ dhall-lang/tests/typecheck/success/simple/fieldsAreTypesB.dhall view
@@ -0,0 +1,1 @@+{ x : Type, y : Type, z : Type → Type }
+ dhall-lang/tests/typecheck/success/simple/kindParameterA.dhall view
@@ -0,0 +1,1 @@+λ(k : Kind) → λ(a : k → k → Type) → λ(x : k) → a x
+ dhall-lang/tests/typecheck/success/simple/kindParameterB.dhall view
@@ -0,0 +1,1 @@+∀(k : Kind) → (k → k → Type) → k → k → Type
+ dhall-lang/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
+ dhall-lang/tests/typecheck/success/simple/mergeEquivalenceB.dhall view
@@ -0,0 +1,1 @@+∀(a : Type) → ∀(f : {} → a) → ∀(ts : < Bar : {} | Baz : {} >) → a
+ dhall-lang/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 {=}
+ dhall-lang/tests/typecheck/success/simple/mixedFieldAccessB.dhall view
@@ -0,0 +1,1 @@+< Private : {} | Public : {} >
+ dhall-lang/tests/typecheck/success/simple/unionsOfTypesA.dhall view
@@ -0,0 +1,1 @@+< Left = List | Right : Type >
+ dhall-lang/tests/typecheck/success/simple/unionsOfTypesB.dhall view
@@ -0,0 +1,1 @@+< Left : Type → Type | Right : Type >
dhall.cabal view
@@ -1,8 +1,8 @@ Name: dhall-Version: 1.20.1+Version: 1.21.0 Cabal-Version: >=1.10 Build-Type: Simple-Tested-With: GHC == 8.0.1+Tested-With: GHC == 7.10.3, GHC == 8.4.3, GHC == 8.6.1 License: BSD3 License-File: LICENSE Copyright: 2017 Gabriel Gonzalez@@ -26,263 +26,338 @@     benchmark/deep-nested-large-record/*.dhall     benchmark/examples/*.dhall     CHANGELOG.md-    Prelude/Monoid-    Prelude/package.dhall+    dhall-lang/Prelude/Bool/and+    dhall-lang/Prelude/Bool/build+    dhall-lang/Prelude/Bool/even+    dhall-lang/Prelude/Bool/fold+    dhall-lang/Prelude/Bool/not+    dhall-lang/Prelude/Bool/odd+    dhall-lang/Prelude/Bool/or+    dhall-lang/Prelude/Bool/package.dhall+    dhall-lang/Prelude/Bool/show+    dhall-lang/Prelude/Double/package.dhall+    dhall-lang/Prelude/Double/show+    dhall-lang/Prelude/Function/compose+    dhall-lang/Prelude/Function/package.dhall+    dhall-lang/Prelude/Integer/package.dhall+    dhall-lang/Prelude/Integer/show+    dhall-lang/Prelude/Integer/toDouble+    dhall-lang/Prelude/JSON/keyText+    dhall-lang/Prelude/JSON/keyValue+    dhall-lang/Prelude/JSON/Nesting+    dhall-lang/Prelude/JSON/package.dhall+    dhall-lang/Prelude/JSON/Tagged+    dhall-lang/Prelude/List/all+    dhall-lang/Prelude/List/any+    dhall-lang/Prelude/List/build+    dhall-lang/Prelude/List/concat+    dhall-lang/Prelude/List/concatMap+    dhall-lang/Prelude/List/filter+    dhall-lang/Prelude/List/fold+    dhall-lang/Prelude/List/generate+    dhall-lang/Prelude/List/head+    dhall-lang/Prelude/List/indexed+    dhall-lang/Prelude/List/iterate+    dhall-lang/Prelude/List/last+    dhall-lang/Prelude/List/length+    dhall-lang/Prelude/List/map+    dhall-lang/Prelude/List/null+    dhall-lang/Prelude/List/package.dhall+    dhall-lang/Prelude/List/replicate+    dhall-lang/Prelude/List/reverse+    dhall-lang/Prelude/List/shifted+    dhall-lang/Prelude/List/unzip+    dhall-lang/Prelude/Monoid+    dhall-lang/Prelude/Natural/build+    dhall-lang/Prelude/Natural/enumerate+    dhall-lang/Prelude/Natural/even+    dhall-lang/Prelude/Natural/fold+    dhall-lang/Prelude/Natural/isZero+    dhall-lang/Prelude/Natural/odd+    dhall-lang/Prelude/Natural/package.dhall+    dhall-lang/Prelude/Natural/product+    dhall-lang/Prelude/Natural/show+    dhall-lang/Prelude/Natural/sum+    dhall-lang/Prelude/Natural/toDouble+    dhall-lang/Prelude/Natural/toInteger+    dhall-lang/Prelude/Optional/all+    dhall-lang/Prelude/Optional/any+    dhall-lang/Prelude/Optional/build+    dhall-lang/Prelude/Optional/concat+    dhall-lang/Prelude/Optional/filter+    dhall-lang/Prelude/Optional/fold+    dhall-lang/Prelude/Optional/head+    dhall-lang/Prelude/Optional/last+    dhall-lang/Prelude/Optional/length+    dhall-lang/Prelude/Optional/map+    dhall-lang/Prelude/Optional/null+    dhall-lang/Prelude/Optional/package.dhall+    dhall-lang/Prelude/Optional/toList+    dhall-lang/Prelude/Optional/unzip+    dhall-lang/Prelude/package.dhall+    dhall-lang/Prelude/Text/concat+    dhall-lang/Prelude/Text/concatMap+    dhall-lang/Prelude/Text/concatMapSep+    dhall-lang/Prelude/Text/concatSep+    dhall-lang/Prelude/Text/package.dhall+    dhall-lang/Prelude/Text/show+    dhall-lang/tests/import/data/fieldOrder/*.dhall+    dhall-lang/tests/import/failure/*.dhall+    dhall-lang/tests/import/success/*.dhall+    dhall-lang/tests/normalization/success/*.dhall+    dhall-lang/tests/normalization/success/haskell-tutorial/access/*.dhall+    dhall-lang/tests/normalization/success/haskell-tutorial/combineTypes/*.dhall+    dhall-lang/tests/normalization/success/haskell-tutorial/prefer/*.dhall+    dhall-lang/tests/normalization/success/haskell-tutorial/projection/*.dhall+    dhall-lang/tests/normalization/success/multiline/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/and/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/and/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/build/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/build/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/even/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/even/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/fold/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/fold/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/not/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/not/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/odd/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/odd/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/or/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/or/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/show/*.dhall+    dhall-lang/tests/normalization/success/prelude/Bool/show/*.dhall+    dhall-lang/tests/normalization/success/prelude/Double/show/*.dhall+    dhall-lang/tests/normalization/success/prelude/Double/show/*.dhall+    dhall-lang/tests/normalization/success/prelude/Integer/show/*.dhall+    dhall-lang/tests/normalization/success/prelude/Integer/show/*.dhall+    dhall-lang/tests/normalization/success/prelude/Integer/toDouble/*.dhall+    dhall-lang/tests/normalization/success/prelude/Integer/toDouble/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/all/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/all/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/any/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/any/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/build/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/build/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/concat/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/concat/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/concatMap/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/concatMap/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/filter/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/filter/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/fold/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/fold/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/generate/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/generate/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/head/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/head/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/indexed/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/indexed/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/iterate/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/iterate/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/last/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/last/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/length/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/length/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/map/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/map/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/null/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/null/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/replicate/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/replicate/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/reverse/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/reverse/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/shifted/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/shifted/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/unzip/*.dhall+    dhall-lang/tests/normalization/success/prelude/List/unzip/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/build/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/build/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/enumerate/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/enumerate/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/even/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/even/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/fold/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/fold/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/isZero/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/isZero/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/odd/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/odd/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/product/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/product/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/show/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/show/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/sum/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/sum/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/toDouble/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/toDouble/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/toInteger/*.dhall+    dhall-lang/tests/normalization/success/prelude/Natural/toInteger/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/all/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/all/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/any/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/any/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/build/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/build/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/concat/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/concat/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/filter/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/filter/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/fold/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/fold/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/head/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/head/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/last/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/last/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/length/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/length/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/map/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/map/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/null/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/null/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/toList/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/toList/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/unzip/*.dhall+    dhall-lang/tests/normalization/success/prelude/Optional/unzip/*.dhall+    dhall-lang/tests/normalization/success/prelude/Text/concat/*.dhall+    dhall-lang/tests/normalization/success/prelude/Text/concat/*.dhall+    dhall-lang/tests/normalization/success/prelude/Text/concatMap/*.dhall+    dhall-lang/tests/normalization/success/prelude/Text/concatMap/*.dhall+    dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/*.dhall+    dhall-lang/tests/normalization/success/prelude/Text/concatMapSep/*.dhall+    dhall-lang/tests/normalization/success/prelude/Text/concatSep/*.dhall+    dhall-lang/tests/normalization/success/prelude/Text/concatSep/*.dhall+    dhall-lang/tests/normalization/success/prelude/Text/show/*.dhall+    dhall-lang/tests/normalization/success/prelude/Text/show/*.dhall+    dhall-lang/tests/normalization/success/simple/*.dhall+    dhall-lang/tests/normalization/success/simplifications/*.dhall+    dhall-lang/tests/parser/failure/*.dhall+    dhall-lang/tests/parser/success/*.dhall+    dhall-lang/tests/parser/success/*.dhallb+    dhall-lang/tests/typecheck/failure/*.dhall+    dhall-lang/tests/typecheck/success/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/and/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/and/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/build/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/build/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/even/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/even/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/fold/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/fold/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/not/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/not/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/odd/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/odd/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/or/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/or/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/show/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Bool/show/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Double/show/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Double/show/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Integer/show/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Integer/show/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Integer/toDouble/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/all/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/all/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/any/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/any/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/build/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/build/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/concat/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/concat/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/concatMap/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/concatMap/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/filter/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/filter/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/fold/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/fold/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/generate/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/generate/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/head/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/head/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/indexed/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/indexed/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/iterate/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/iterate/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/last/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/last/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/length/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/length/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/map/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/map/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/null/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/null/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/replicate/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/replicate/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/reverse/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/reverse/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/shifted/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/shifted/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/unzip/*.dhall+    dhall-lang/tests/typecheck/success/prelude/List/unzip/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Monoid/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/build/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/build/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/enumerate/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/even/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/even/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/fold/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/fold/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/isZero/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/isZero/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/odd/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/odd/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/product/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/product/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/show/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/show/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/sum/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/sum/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/toDouble/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Natural/toInteger/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/all/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/all/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/any/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/any/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/build/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/build/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/concat/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/concat/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/filter/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/filter/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/fold/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/fold/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/head/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/head/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/last/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/last/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/length/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/length/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/map/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/map/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/null/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/null/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/toList/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/toList/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/unzip/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Optional/unzip/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Text/concat/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Text/concat/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Text/concatMap/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Text/concatMap/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Text/concatMapSep/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Text/concatSep/*.dhall+    dhall-lang/tests/typecheck/success/prelude/Text/concatSep/*.dhall+    dhall-lang/tests/typecheck/success/simple/access/*.dhall+    dhall-lang/tests/typecheck/success/simple/*.dhall     tests/format/*.dhall-    tests/import/data/fieldOrder/*.dhall-    tests/import/data/foo/bar/*.dhall-    tests/import/failure/*.dhall-    tests/import/success/*.dhall     tests/lint/success/*.dhall-    tests/normalization/success/*.dhall-    tests/normalization/success/haskell-tutorial/access/*.dhall-    tests/normalization/success/haskell-tutorial/combineTypes/*.dhall-    tests/normalization/success/haskell-tutorial/prefer/*.dhall-    tests/normalization/success/haskell-tutorial/projection/*.dhall-    tests/normalization/success/multiline/*.dhall-    tests/normalization/success/prelude/Bool/and/*.dhall-    tests/normalization/success/prelude/Bool/and/*.dhall-    tests/normalization/success/prelude/Bool/build/*.dhall-    tests/normalization/success/prelude/Bool/build/*.dhall-    tests/normalization/success/prelude/Bool/even/*.dhall-    tests/normalization/success/prelude/Bool/even/*.dhall-    tests/normalization/success/prelude/Bool/fold/*.dhall-    tests/normalization/success/prelude/Bool/fold/*.dhall-    tests/normalization/success/prelude/Bool/not/*.dhall-    tests/normalization/success/prelude/Bool/not/*.dhall-    tests/normalization/success/prelude/Bool/odd/*.dhall-    tests/normalization/success/prelude/Bool/odd/*.dhall-    tests/normalization/success/prelude/Bool/or/*.dhall-    tests/normalization/success/prelude/Bool/or/*.dhall-    tests/normalization/success/prelude/Bool/show/*.dhall-    tests/normalization/success/prelude/Bool/show/*.dhall-    tests/normalization/success/prelude/Double/show/*.dhall-    tests/normalization/success/prelude/Double/show/*.dhall-    tests/normalization/success/prelude/Integer/show/*.dhall-    tests/normalization/success/prelude/Integer/show/*.dhall-    tests/normalization/success/prelude/Integer/toDouble/*.dhall-    tests/normalization/success/prelude/Integer/toDouble/*.dhall-    tests/normalization/success/prelude/List/all/*.dhall-    tests/normalization/success/prelude/List/all/*.dhall-    tests/normalization/success/prelude/List/any/*.dhall-    tests/normalization/success/prelude/List/any/*.dhall-    tests/normalization/success/prelude/List/build/*.dhall-    tests/normalization/success/prelude/List/build/*.dhall-    tests/normalization/success/prelude/List/concat/*.dhall-    tests/normalization/success/prelude/List/concat/*.dhall-    tests/normalization/success/prelude/List/concatMap/*.dhall-    tests/normalization/success/prelude/List/concatMap/*.dhall-    tests/normalization/success/prelude/List/filter/*.dhall-    tests/normalization/success/prelude/List/filter/*.dhall-    tests/normalization/success/prelude/List/fold/*.dhall-    tests/normalization/success/prelude/List/fold/*.dhall-    tests/normalization/success/prelude/List/generate/*.dhall-    tests/normalization/success/prelude/List/generate/*.dhall-    tests/normalization/success/prelude/List/head/*.dhall-    tests/normalization/success/prelude/List/head/*.dhall-    tests/normalization/success/prelude/List/indexed/*.dhall-    tests/normalization/success/prelude/List/indexed/*.dhall-    tests/normalization/success/prelude/List/iterate/*.dhall-    tests/normalization/success/prelude/List/iterate/*.dhall-    tests/normalization/success/prelude/List/last/*.dhall-    tests/normalization/success/prelude/List/last/*.dhall-    tests/normalization/success/prelude/List/length/*.dhall-    tests/normalization/success/prelude/List/length/*.dhall-    tests/normalization/success/prelude/List/map/*.dhall-    tests/normalization/success/prelude/List/map/*.dhall-    tests/normalization/success/prelude/List/null/*.dhall-    tests/normalization/success/prelude/List/null/*.dhall-    tests/normalization/success/prelude/List/replicate/*.dhall-    tests/normalization/success/prelude/List/replicate/*.dhall-    tests/normalization/success/prelude/List/reverse/*.dhall-    tests/normalization/success/prelude/List/reverse/*.dhall-    tests/normalization/success/prelude/List/shifted/*.dhall-    tests/normalization/success/prelude/List/shifted/*.dhall-    tests/normalization/success/prelude/List/unzip/*.dhall-    tests/normalization/success/prelude/List/unzip/*.dhall-    tests/normalization/success/prelude/Natural/build/*.dhall-    tests/normalization/success/prelude/Natural/build/*.dhall-    tests/normalization/success/prelude/Natural/enumerate/*.dhall-    tests/normalization/success/prelude/Natural/enumerate/*.dhall-    tests/normalization/success/prelude/Natural/even/*.dhall-    tests/normalization/success/prelude/Natural/even/*.dhall-    tests/normalization/success/prelude/Natural/fold/*.dhall-    tests/normalization/success/prelude/Natural/fold/*.dhall-    tests/normalization/success/prelude/Natural/isZero/*.dhall-    tests/normalization/success/prelude/Natural/isZero/*.dhall-    tests/normalization/success/prelude/Natural/odd/*.dhall-    tests/normalization/success/prelude/Natural/odd/*.dhall-    tests/normalization/success/prelude/Natural/product/*.dhall-    tests/normalization/success/prelude/Natural/product/*.dhall-    tests/normalization/success/prelude/Natural/show/*.dhall-    tests/normalization/success/prelude/Natural/show/*.dhall-    tests/normalization/success/prelude/Natural/sum/*.dhall-    tests/normalization/success/prelude/Natural/sum/*.dhall-    tests/normalization/success/prelude/Natural/toDouble/*.dhall-    tests/normalization/success/prelude/Natural/toDouble/*.dhall-    tests/normalization/success/prelude/Natural/toInteger/*.dhall-    tests/normalization/success/prelude/Natural/toInteger/*.dhall-    tests/normalization/success/prelude/Optional/all/*.dhall-    tests/normalization/success/prelude/Optional/all/*.dhall-    tests/normalization/success/prelude/Optional/any/*.dhall-    tests/normalization/success/prelude/Optional/any/*.dhall-    tests/normalization/success/prelude/Optional/build/*.dhall-    tests/normalization/success/prelude/Optional/build/*.dhall-    tests/normalization/success/prelude/Optional/concat/*.dhall-    tests/normalization/success/prelude/Optional/concat/*.dhall-    tests/normalization/success/prelude/Optional/filter/*.dhall-    tests/normalization/success/prelude/Optional/filter/*.dhall-    tests/normalization/success/prelude/Optional/fold/*.dhall-    tests/normalization/success/prelude/Optional/fold/*.dhall-    tests/normalization/success/prelude/Optional/head/*.dhall-    tests/normalization/success/prelude/Optional/head/*.dhall-    tests/normalization/success/prelude/Optional/last/*.dhall-    tests/normalization/success/prelude/Optional/last/*.dhall-    tests/normalization/success/prelude/Optional/length/*.dhall-    tests/normalization/success/prelude/Optional/length/*.dhall-    tests/normalization/success/prelude/Optional/map/*.dhall-    tests/normalization/success/prelude/Optional/map/*.dhall-    tests/normalization/success/prelude/Optional/null/*.dhall-    tests/normalization/success/prelude/Optional/null/*.dhall-    tests/normalization/success/prelude/Optional/toList/*.dhall-    tests/normalization/success/prelude/Optional/toList/*.dhall-    tests/normalization/success/prelude/Optional/unzip/*.dhall-    tests/normalization/success/prelude/Optional/unzip/*.dhall-    tests/normalization/success/prelude/Text/concat/*.dhall-    tests/normalization/success/prelude/Text/concat/*.dhall-    tests/normalization/success/prelude/Text/concatMap/*.dhall-    tests/normalization/success/prelude/Text/concatMap/*.dhall-    tests/normalization/success/prelude/Text/concatMapSep/*.dhall-    tests/normalization/success/prelude/Text/concatMapSep/*.dhall-    tests/normalization/success/prelude/Text/concatSep/*.dhall-    tests/normalization/success/prelude/Text/concatSep/*.dhall-    tests/normalization/success/simple/*.dhall-    tests/normalization/success/simplifications/*.dhall-    tests/parser/failure/*.dhall-    tests/parser/success/*.dhall     tests/regression/*.dhall     tests/tutorial/*.dhall-    tests/typecheck/failure/*.dhall-    tests/typecheck/success/*.dhall-    tests/typecheck/success/prelude/Bool/and/*.dhall-    tests/typecheck/success/prelude/Bool/and/*.dhall-    tests/typecheck/success/prelude/Bool/build/*.dhall-    tests/typecheck/success/prelude/Bool/build/*.dhall-    tests/typecheck/success/prelude/Bool/even/*.dhall-    tests/typecheck/success/prelude/Bool/even/*.dhall-    tests/typecheck/success/prelude/Bool/fold/*.dhall-    tests/typecheck/success/prelude/Bool/fold/*.dhall-    tests/typecheck/success/prelude/Bool/not/*.dhall-    tests/typecheck/success/prelude/Bool/not/*.dhall-    tests/typecheck/success/prelude/Bool/odd/*.dhall-    tests/typecheck/success/prelude/Bool/odd/*.dhall-    tests/typecheck/success/prelude/Bool/or/*.dhall-    tests/typecheck/success/prelude/Bool/or/*.dhall-    tests/typecheck/success/prelude/Bool/show/*.dhall-    tests/typecheck/success/prelude/Bool/show/*.dhall-    tests/typecheck/success/prelude/Double/show/*.dhall-    tests/typecheck/success/prelude/Double/show/*.dhall-    tests/typecheck/success/prelude/Integer/show/*.dhall-    tests/typecheck/success/prelude/Integer/show/*.dhall-    tests/typecheck/success/prelude/Integer/toDouble/*.dhall-    tests/typecheck/success/prelude/Integer/toDouble/*.dhall-    tests/typecheck/success/prelude/List/all/*.dhall-    tests/typecheck/success/prelude/List/all/*.dhall-    tests/typecheck/success/prelude/List/any/*.dhall-    tests/typecheck/success/prelude/List/any/*.dhall-    tests/typecheck/success/prelude/List/build/*.dhall-    tests/typecheck/success/prelude/List/build/*.dhall-    tests/typecheck/success/prelude/List/concat/*.dhall-    tests/typecheck/success/prelude/List/concat/*.dhall-    tests/typecheck/success/prelude/List/concatMap/*.dhall-    tests/typecheck/success/prelude/List/concatMap/*.dhall-    tests/typecheck/success/prelude/List/filter/*.dhall-    tests/typecheck/success/prelude/List/filter/*.dhall-    tests/typecheck/success/prelude/List/fold/*.dhall-    tests/typecheck/success/prelude/List/fold/*.dhall-    tests/typecheck/success/prelude/List/generate/*.dhall-    tests/typecheck/success/prelude/List/generate/*.dhall-    tests/typecheck/success/prelude/List/head/*.dhall-    tests/typecheck/success/prelude/List/head/*.dhall-    tests/typecheck/success/prelude/List/indexed/*.dhall-    tests/typecheck/success/prelude/List/indexed/*.dhall-    tests/typecheck/success/prelude/List/iterate/*.dhall-    tests/typecheck/success/prelude/List/iterate/*.dhall-    tests/typecheck/success/prelude/List/last/*.dhall-    tests/typecheck/success/prelude/List/last/*.dhall-    tests/typecheck/success/prelude/List/length/*.dhall-    tests/typecheck/success/prelude/List/length/*.dhall-    tests/typecheck/success/prelude/List/map/*.dhall-    tests/typecheck/success/prelude/List/map/*.dhall-    tests/typecheck/success/prelude/List/null/*.dhall-    tests/typecheck/success/prelude/List/null/*.dhall-    tests/typecheck/success/prelude/List/replicate/*.dhall-    tests/typecheck/success/prelude/List/replicate/*.dhall-    tests/typecheck/success/prelude/List/reverse/*.dhall-    tests/typecheck/success/prelude/List/reverse/*.dhall-    tests/typecheck/success/prelude/List/shifted/*.dhall-    tests/typecheck/success/prelude/List/shifted/*.dhall-    tests/typecheck/success/prelude/List/unzip/*.dhall-    tests/typecheck/success/prelude/List/unzip/*.dhall-    tests/typecheck/success/prelude/Monoid/*.dhall-    tests/typecheck/success/prelude/Natural/build/*.dhall-    tests/typecheck/success/prelude/Natural/build/*.dhall-    tests/typecheck/success/prelude/Natural/enumerate/*.dhall-    tests/typecheck/success/prelude/Natural/enumerate/*.dhall-    tests/typecheck/success/prelude/Natural/even/*.dhall-    tests/typecheck/success/prelude/Natural/even/*.dhall-    tests/typecheck/success/prelude/Natural/fold/*.dhall-    tests/typecheck/success/prelude/Natural/fold/*.dhall-    tests/typecheck/success/prelude/Natural/isZero/*.dhall-    tests/typecheck/success/prelude/Natural/isZero/*.dhall-    tests/typecheck/success/prelude/Natural/odd/*.dhall-    tests/typecheck/success/prelude/Natural/odd/*.dhall-    tests/typecheck/success/prelude/Natural/product/*.dhall-    tests/typecheck/success/prelude/Natural/product/*.dhall-    tests/typecheck/success/prelude/Natural/show/*.dhall-    tests/typecheck/success/prelude/Natural/show/*.dhall-    tests/typecheck/success/prelude/Natural/sum/*.dhall-    tests/typecheck/success/prelude/Natural/sum/*.dhall-    tests/typecheck/success/prelude/Natural/toDouble/*.dhall-    tests/typecheck/success/prelude/Natural/toDouble/*.dhall-    tests/typecheck/success/prelude/Natural/toInteger/*.dhall-    tests/typecheck/success/prelude/Natural/toInteger/*.dhall-    tests/typecheck/success/prelude/Optional/all/*.dhall-    tests/typecheck/success/prelude/Optional/all/*.dhall-    tests/typecheck/success/prelude/Optional/any/*.dhall-    tests/typecheck/success/prelude/Optional/any/*.dhall-    tests/typecheck/success/prelude/Optional/build/*.dhall-    tests/typecheck/success/prelude/Optional/build/*.dhall-    tests/typecheck/success/prelude/Optional/concat/*.dhall-    tests/typecheck/success/prelude/Optional/concat/*.dhall-    tests/typecheck/success/prelude/Optional/filter/*.dhall-    tests/typecheck/success/prelude/Optional/filter/*.dhall-    tests/typecheck/success/prelude/Optional/fold/*.dhall-    tests/typecheck/success/prelude/Optional/fold/*.dhall-    tests/typecheck/success/prelude/Optional/head/*.dhall-    tests/typecheck/success/prelude/Optional/head/*.dhall-    tests/typecheck/success/prelude/Optional/last/*.dhall-    tests/typecheck/success/prelude/Optional/last/*.dhall-    tests/typecheck/success/prelude/Optional/length/*.dhall-    tests/typecheck/success/prelude/Optional/length/*.dhall-    tests/typecheck/success/prelude/Optional/map/*.dhall-    tests/typecheck/success/prelude/Optional/map/*.dhall-    tests/typecheck/success/prelude/Optional/null/*.dhall-    tests/typecheck/success/prelude/Optional/null/*.dhall-    tests/typecheck/success/prelude/Optional/toList/*.dhall-    tests/typecheck/success/prelude/Optional/toList/*.dhall-    tests/typecheck/success/prelude/Optional/unzip/*.dhall-    tests/typecheck/success/prelude/Optional/unzip/*.dhall-    tests/typecheck/success/prelude/Text/concat/*.dhall-    tests/typecheck/success/prelude/Text/concat/*.dhall-    tests/typecheck/success/prelude/Text/concatMap/*.dhall-    tests/typecheck/success/prelude/Text/concatMap/*.dhall-    tests/typecheck/success/prelude/Text/concatMapSep/*.dhall-    tests/typecheck/success/prelude/Text/concatMapSep/*.dhall-    tests/typecheck/success/prelude/Text/concatSep/*.dhall-    tests/typecheck/success/prelude/Text/concatSep/*.dhall-    tests/typecheck/success/simple/access/*.dhall-    tests/typecheck/success/simple/*.dhall  Source-Repository head     Type: git@@ -299,7 +374,7 @@         base                        >= 4.8.2.0  && < 5   ,         aeson                       >= 1.0.0.0  && < 1.5 ,         aeson-pretty                               < 0.9 ,-        ansi-terminal               >= 0.6.3.1  && < 0.9 ,+        ansi-terminal               >= 0.6.3.1  && < 0.10,         bytestring                                 < 0.11,         case-insensitive                           < 1.3 ,         cborg                       >= 0.2.0.0  && < 0.3 ,@@ -333,9 +408,9 @@     if flag(with-http)       Build-Depends:         http-types                  >= 0.7.0    && < 0.13,-        http-client                 >= 0.4.30   && < 0.6 ,+        http-client                 >= 0.4.30   && < 0.7 ,         http-client-tls             >= 0.2.0    && < 0.4-    if !impl(ghc >= 8.0)+    if !impl(ghc >= 8.0) && !impl(eta >= 0.8.4)       Build-Depends: semigroups == 0.18.*       Build-Depends: transformers == 0.4.2.*       Build-Depends: fail == 4.9.*@@ -374,7 +449,7 @@       Other-Modules:         Dhall.Import.HTTP -    GHC-Options: -Wall+    GHC-Options: -Wall -fwarn-incomplete-uni-patterns     Default-Language: Haskell2010  Executable dhall@@ -390,6 +465,7 @@     Main-Is: Dhall/Test/Main.hs     GHC-Options: -Wall     Other-Modules:+        Dhall.Test.Dhall         Dhall.Test.Format         Dhall.Test.Import         Dhall.Test.Lint@@ -402,6 +478,8 @@         Dhall.Test.Util     Build-Depends:         base                      >= 4        && < 5   ,+        bytestring                               < 0.11,+        cborg                     >= 0.2.0.0  && < 0.3 ,         containers                                     ,         deepseq                   >= 1.2.0.1  && < 1.5 ,         dhall                                          ,
doctest/Main.hs view
@@ -3,12 +3,16 @@ import Data.Monoid ((<>)) import System.FilePath ((</>)) +import qualified GHC.IO.Encoding import qualified System.Directory+import qualified System.IO import qualified Test.Mockery.Directory import qualified Test.DocTest  main :: IO () main = do+   +    GHC.IO.Encoding.setLocaleEncoding System.IO.utf8      pwd    <- System.Directory.getCurrentDirectory     prefix <- System.Directory.makeAbsolute pwd
src/Dhall.hs view
@@ -10,6 +10,7 @@ {-# LANGUAGE ScopedTypeVariables        #-} {-# LANGUAGE StandaloneDeriving         #-} {-# LANGUAGE TypeOperators              #-}+{-# LANGUAGE TupleSections              #-}  {-| Please read the "Dhall.Tutorial" module, which contains a tutorial explaining     how to use the language, the compiler, and this library@@ -39,6 +40,7 @@     -- * Types     , Type(..)     , RecordType(..)+    , UnionType(..)     , InputType(..)     , Interpret(..)     , InvalidType(..)@@ -62,6 +64,8 @@     , pair     , record     , field+    , union+    , constructor     , GenericInterpret(..)     , GenericInject(..) @@ -71,6 +75,11 @@     , inputFieldWith     , inputField     , inputRecord+    , UnionInputType(..)+    , inputConstructorWith+    , inputConstructor+    , inputUnion+    , (>|<)      -- * Miscellaneous     , rawInput@@ -88,12 +97,15 @@ import Control.Applicative (empty, liftA2, (<|>), Alternative) import Control.Exception (Exception) import Control.Monad.Trans.State.Strict-import Data.Functor.Contravariant (Contravariant(..), (>$<))+import Control.Monad (guard)+import Data.Coerce (coerce)+import Data.Functor.Contravariant (Contravariant(..), (>$<), Op(..)) import Data.Functor.Contravariant.Divisible (Divisible(..), divided) import Data.Monoid ((<>)) import Data.Scientific (Scientific) import Data.Sequence (Seq) import Data.Text (Text)+import Data.Text.Prettyprint.Doc (Pretty) import Data.Typeable (Typeable) import Data.Vector (Vector) import Data.Word (Word8, Word16, Word32, Word64)@@ -114,6 +126,7 @@ import qualified Data.Foldable import qualified Data.Functor.Compose import qualified Data.Functor.Product+import qualified Data.Semigroup import qualified Data.Scientific import qualified Data.Sequence import qualified Data.Set@@ -129,6 +142,7 @@ import qualified Dhall.Parser import qualified Dhall.Pretty.Internal import qualified Dhall.TypeCheck+import qualified Dhall.Util  -- $setup -- >>> :set -XOverloadedStrings@@ -144,19 +158,36 @@     This exception indicates that an invalid `Type` was provided to the `input`     function -}-data InvalidType = InvalidType deriving (Typeable)+data InvalidType s a = InvalidType+  { invalidTypeExpected :: Expr s a+  , invalidTypeExpression :: Expr s a+  }+  deriving (Typeable)  _ERROR :: String _ERROR = "\ESC[1;31mError\ESC[0m" -instance Show InvalidType where-    show InvalidType =+instance (Pretty s, Pretty a, Typeable s, Typeable a) => Show (InvalidType s a) where+    show InvalidType { .. } =         _ERROR <> ": Invalid Dhall.Type                                                  \n\         \                                                                                \n\         \Every Type must provide an extract function that succeeds if an expression      \n\-        \matches the expected type.  You provided a Type that disobeys this contract     \n"+        \matches the expected type.  You provided a Type that disobeys this contract     \n\+        \                                                                                \n\+        \The Type provided has the expected dhall type:                                  \n\+        \                                                                                \n\+        \" <> show txt0 <> "\n\+        \                                                                                \n\+        \and it couldn't extract a value from the well-typed expression:                 \n\+        \                                                                                \n\+        \" <> show txt1 <> "\n\+        \                                                                                \n"+        where+          txt0 = Dhall.Util.insert invalidTypeExpected+          txt1 = Dhall.Util.insert invalidTypeExpression+             -instance Exception InvalidType+instance (Pretty s, Pretty a, Typeable s, Typeable a) => Exception (InvalidType s a)  -- | @since 1.16 data InputSettings = InputSettings@@ -329,9 +360,14 @@             _ ->                 Annot expr' expected     _ <- throws (Dhall.TypeCheck.typeWith (view startingContext settings) annot)-    case extract (Dhall.Core.normalizeWith (Dhall.Core.getReifiedNormalizer (view normalizer settings)) expr') of+    let normExpr = Dhall.Core.normalizeWith+                     (Dhall.Core.getReifiedNormalizer+                       (view normalizer settings))+                     expr'+    case extract normExpr  of         Just x  -> return x-        Nothing -> Control.Exception.throwIO InvalidType+        Nothing -> Control.Exception.throwIO+                     (InvalidType expected expr')  {-| Type-check and evaluate a Dhall program that is read from the     file-system.@@ -798,7 +834,9 @@ instance (Inject a, Interpret b) => Interpret (a -> b) where     autoWith opts = Type extractOut expectedOut       where-        extractOut e = Just (\i -> case extractIn (Dhall.Core.normalize (App e (embed i))) of+        normalizer_ = Dhall.Core.getReifiedNormalizer (inputNormalizer opts)++        extractOut e = Just (\i -> case extractIn (Dhall.Core.normalizeWith normalizer_ (App e (embed i))) of             Just o  -> o             Nothing -> error "Interpret: You cannot decode a function if it does not have the correct type" ) @@ -835,6 +873,10 @@     , constructorModifier :: Text -> Text     -- ^ Function used to transform Haskell constructor names into their     --   corresponding Dhall alternative names+    , inputNormalizer     :: Dhall.Core.ReifiedNormalizer X+    -- ^ This is only used by the `Interpret` instance for functions in order+    --   to normalize the function input before marshaling the input into a+    --   Dhall expression     }  {-| Default interpret options, which you can tweak or override, like this:@@ -846,6 +888,7 @@ defaultInterpretOptions = InterpretOptions     { fieldModifier       = id     , constructorModifier = id+    , inputNormalizer     = Dhall.Core.ReifiedNormalizer (const (pure Nothing))     }  {-| This is the underlying class that powers the `Interpret` class's support@@ -866,6 +909,35 @@          expected = Union mempty +unsafeExpectUnion :: Text -> Expr Src X -> Dhall.Map.Map Text (Expr Src X)+unsafeExpectUnion _ (Union kts) =+    kts+unsafeExpectUnion name expression =+    Dhall.Core.internalError+        (name <> ": Unexpected constructor: " <> Dhall.Core.pretty expression)++unsafeExpectRecord :: Text -> Expr Src X -> Dhall.Map.Map Text (Expr Src X)+unsafeExpectRecord _ (Record kts) =+    kts+unsafeExpectRecord name expression =+    Dhall.Core.internalError+        (name <> ": Unexpected constructor: " <> Dhall.Core.pretty expression)++unsafeExpectUnionLit+    :: Text -> Expr Src X -> (Text, Expr Src X, Dhall.Map.Map Text (Expr Src X))+unsafeExpectUnionLit _ (UnionLit k v kts) =+    (k, v, kts)+unsafeExpectUnionLit name expression =+    Dhall.Core.internalError+        (name <> ": Unexpected constructor: " <> Dhall.Core.pretty expression)++unsafeExpectRecordLit :: Text -> Expr Src X -> Dhall.Map.Map Text (Expr Src X)+unsafeExpectRecordLit _ (RecordLit kvs) =+    kvs+unsafeExpectRecordLit name expression =+    Dhall.Core.internalError+        (name <> ": Unexpected constructor: " <> Dhall.Core.pretty expression)+ instance (Constructor c1, Constructor c2, GenericInterpret f1, GenericInterpret f2) => GenericInterpret (M1 C c1 f1 :+: M1 C c2 f2) where     genericAutoWith options@(InterpretOptions {..}) = pure (Type {..})       where@@ -904,11 +976,13 @@         extract _ = Nothing          expected =-            Union (Dhall.Map.insert name expectedR expectedL)+            Union (Dhall.Map.insert name expectedR ktsL) -        Type extractL (Union expectedL) = evalState (genericAutoWith options) 1-        Type extractR        expectedR  = evalState (genericAutoWith options) 1+        Type extractL expectedL = evalState (genericAutoWith options) 1+        Type extractR expectedR = evalState (genericAutoWith options) 1 +        ktsL = unsafeExpectUnion "genericAutoWith (:+:)" expectedL+ instance (Constructor c, GenericInterpret f, GenericInterpret (g :+: h)) => GenericInterpret (M1 C c f :+: (g :+: h)) where     genericAutoWith options@(InterpretOptions {..}) = pure (Type {..})       where@@ -923,21 +997,26 @@         extract _ = Nothing          expected =-            Union (Dhall.Map.insert name expectedL expectedR)+            Union (Dhall.Map.insert name expectedL ktsR) -        Type extractL        expectedL  = evalState (genericAutoWith options) 1-        Type extractR (Union expectedR) = evalState (genericAutoWith options) 1+        Type extractL expectedL = evalState (genericAutoWith options) 1+        Type extractR expectedR = evalState (genericAutoWith options) 1 +        ktsR = unsafeExpectUnion "genericAutoWith (:+:)" expectedR+ instance (GenericInterpret (f :+: g), GenericInterpret (h :+: i)) => GenericInterpret ((f :+: g) :+: (h :+: i)) where     genericAutoWith options = pure (Type {..})       where         extract e = fmap L1 (extractL e) <|> fmap R1 (extractR e) -        expected = Union (Dhall.Map.union expectedL expectedR)+        expected = Union (Dhall.Map.union ktsL ktsR) -        Type extractL (Union expectedL) = evalState (genericAutoWith options) 1-        Type extractR (Union expectedR) = evalState (genericAutoWith options) 1+        Type extractL expectedL = evalState (genericAutoWith options) 1+        Type extractR expectedR = evalState (genericAutoWith options) 1 +        ktsL = unsafeExpectUnion "genericAutoWith (:+:)" expectedL+        ktsR = unsafeExpectUnion "genericAutoWith (:+:)" expectedR+ instance GenericInterpret f => GenericInterpret (M1 C c f) where     genericAutoWith options = do         res <- genericAutoWith options@@ -954,8 +1033,8 @@     genericAutoWith options = do         Type extractL expectedL <- genericAutoWith options         Type extractR expectedR <- genericAutoWith options-        let Record ktsL = expectedL-        let Record ktsR = expectedR+        let ktsL = unsafeExpectRecord "genericAutoWith (:*:)"expectedL+        let ktsR = unsafeExpectRecord "genericAutoWith (:*:)"expectedR         pure             (Type                 { extract = liftA2 (liftA2 (:*:)) extractL extractR@@ -1195,7 +1274,8 @@         embed (L1 l) =             UnionLit keyL valL (Dhall.Map.insert keyR declaredR ktsL')           where-            UnionLit keyL valL ktsL' = embedL l+            (keyL, valL, ktsL') =+              unsafeExpectUnionLit "genericInjectWith (:+:)" (embedL l)         embed (R1 (M1 r)) = UnionLit keyR (embedR r) ktsL          nR :: M1 i c h a@@ -1205,9 +1285,11 @@          declared = Union (Dhall.Map.insert keyR declaredR ktsL) -        InputType embedL (Union ktsL) = evalState (genericInjectWith options) 1-        InputType embedR  declaredR   = evalState (genericInjectWith options) 1+        InputType embedL  declaredL = evalState (genericInjectWith options) 1+        InputType embedR  declaredR = evalState (genericInjectWith options) 1 +        ktsL = unsafeExpectUnion "genericInjectWith (:+:)" declaredL+ instance (Constructor c, GenericInject f, GenericInject (g :+: h)) => GenericInject (M1 C c f :+: (g :+: h)) where     genericInjectWith options@(InterpretOptions {..}) = pure (InputType {..})       where@@ -1215,7 +1297,8 @@         embed (R1 r) =             UnionLit keyR valR (Dhall.Map.insert keyL declaredL ktsR')           where-            UnionLit keyR valR ktsR' = embedR r+            (keyR, valR, ktsR') =+                unsafeExpectUnionLit "genericInjectWith (:+:)" (embedR r)          nL :: M1 i c f a         nL = undefined@@ -1224,26 +1307,33 @@          declared = Union (Dhall.Map.insert keyL declaredL ktsR) -        InputType embedL  declaredL   = evalState (genericInjectWith options) 1-        InputType embedR (Union ktsR) = evalState (genericInjectWith options) 1+        InputType embedL declaredL = evalState (genericInjectWith options) 1+        InputType embedR declaredR = evalState (genericInjectWith options) 1 +        ktsR = unsafeExpectUnion "genericInjectWith (:+:)" declaredR+ instance (GenericInject (f :+: g), GenericInject (h :+: i)) => GenericInject ((f :+: g) :+: (h :+: i)) where     genericInjectWith options = pure (InputType {..})       where         embed (L1 l) =-            UnionLit keyL valR (Dhall.Map.union ktsL' ktsR)+            UnionLit keyL valL (Dhall.Map.union ktsL' ktsR)           where-            UnionLit keyL valR ktsL' = embedL l+            (keyL, valL, ktsL') =+                unsafeExpectUnionLit "genericInjectWith (:+:)" (embedL l)         embed (R1 r) =             UnionLit keyR valR (Dhall.Map.union ktsL ktsR')           where-            UnionLit keyR valR ktsR' = embedR r+            (keyR, valR, ktsR') =+                unsafeExpectUnionLit "genericInjectWith (:+:)" (embedR r)          declared = Union (Dhall.Map.union ktsL ktsR) -        InputType embedL (Union ktsL) = evalState (genericInjectWith options) 1-        InputType embedR (Union ktsR) = evalState (genericInjectWith options) 1+        InputType embedL declaredL = evalState (genericInjectWith options) 1+        InputType embedR declaredR = evalState (genericInjectWith options) 1 +        ktsL = unsafeExpectUnion "genericInjectWith (:+:)" declaredL+        ktsR = unsafeExpectUnion "genericInjectWith (:+:)" declaredR+ instance (GenericInject f, GenericInject g) => GenericInject (f :*: g) where     genericInjectWith options = do         InputType embedInL declaredInL <- genericInjectWith options@@ -1252,13 +1342,16 @@         let embed (l :*: r) =                 RecordLit (Dhall.Map.union mapL mapR)               where-                RecordLit mapL = embedInL l-                RecordLit mapR = embedInR r+                mapL =+                    unsafeExpectRecordLit "genericInjectWith (:*:)" (embedInL l) +                mapR =+                    unsafeExpectRecordLit "genericInjectWith (:*:)" (embedInR r)+         let declared = Record (Dhall.Map.union mapL mapR)               where-                Record mapL = declaredInL-                Record mapR = declaredInR+                mapL = unsafeExpectRecord "genericInjectWith (:*:)" declaredInL+                mapR = unsafeExpectRecord "genericInjectWith (:*:)" declaredInR          pure (InputType {..}) @@ -1371,6 +1464,67 @@           ( Data.Functor.Compose.Compose extractBody )       ) +{-| The 'UnionType' monoid allows you to build a 'Type' parser+    from a Dhall union++    For example, let's take the following Haskell data type:++> data Status = Queued Natural+>             | Result Text+>             | Errored Text++    And assume that we have the following Dhall union that we would like to+    parse as a @Status@:++> < Result = "Finish succesfully"+> | Queued : Natural+> | Errored : Text+> >++    Our parser has type 'Type' @Status@, but we can't build that out of any+    smaller parsers, as 'Type's cannot be combined (they are only 'Functor's).+    However, we can use a 'UnionType' to build a 'Type' for @Status@:++> status :: Type Status+> status =+>   union+>     ( Queued  <$> constructor "Queued"  natural+>    <> Result  <$> constructor "Result"  string+>    <> Errored <$> constructor "Errored" string+>     )++-}+newtype UnionType a =+    UnionType+      ( Data.Functor.Compose.Compose (Dhall.Map.Map Text) Type a )+  deriving (Functor)++instance Data.Semigroup.Semigroup (UnionType a) where+    (<>) = coerce ((<>) :: Dhall.Map.Map Text (Type a) -> Dhall.Map.Map Text (Type a) -> Dhall.Map.Map Text (Type a))++instance Monoid (UnionType a) where+    mempty = coerce (mempty :: Dhall.Map.Map Text (Type a))+    mappend = (Data.Semigroup.<>)++-- | Run a 'UnionType' parser to build a 'Type' parser.+union :: UnionType a -> Type a+union (UnionType (Data.Functor.Compose.Compose mp)) = Type+    { extract  = extractF+    , expected = Union expect+    }+  where+    expect = Dhall.expected <$> mp+    extractF e0 = do+      UnionLit fld e1 rest <- Just e0+      t <- Dhall.Map.lookup fld mp+      guard $ rest == Dhall.Map.delete fld expect+      Dhall.extract t e1++-- | Parse a single constructor of a union+constructor :: Text -> Type a -> UnionType a+constructor key valueType = UnionType+    ( Data.Functor.Compose.Compose (Dhall.Map.singleton key valueType) )+ {-| The 'RecordInputType' divisible (contravariant) functor allows you to build     an 'InputType' injector for a Dhall record. @@ -1453,4 +1607,109 @@     recordType = Record $ declared <$> inputTypeRecord     makeRecordLit x = RecordLit $ (($ x) . embed) <$> inputTypeRecord +{-| The 'UnionInputType' monoid allows you to build+    an 'InputType' injector for a Dhall record. +    For example, let's take the following Haskell data type:++> data Status = Queued Natural+>             | Result Text+>             | Errored Text++    And assume that we have the following Dhall union that we would like to+    parse as a @Status@:++> < Result = "Finish succesfully"+> | Queued : Natural+> | Errored : Text+> >++    Our injector has type 'InputType' @Status@, but we can't build that out of any+    smaller injectors, as 'InputType's cannot be combined.+    However, we can use an 'InputUnionType' to build an 'InputType' for @Status@:++> injectStatus :: InputType Status+> injectStatus =+>           adapt+>     >$< inputConstructorWith "Queued"  inject+>     >|< inputConstructorWith "Result"  inject+>     >|< inputConstructorWith "Errored" inject+>   where+>     adapt (Queued  n) = Left (Left  n)+>     adapt (Result  t) = Left (Right t)+>     adapt (Errored e) = Right e++    Or, since we are simply using the `Inject` instance to inject each branch, we could write++> injectStatus :: InputType Status+> injectStatus =+>           adapt+>     >$< inputConstructor "Queued"+>     >|< inputConstructor "Result"+>     >|< inputConstructor "Errored"+>   where+>     adapt (Queued  n) = Left (Left  n)+>     adapt (Result  t) = Left (Right t)+>     adapt (Errored e) = Right e+-}+newtype UnionInputType a =+  UnionInputType+    ( Data.Functor.Product.Product+        ( Control.Applicative.Const+            ( Dhall.Map.Map+                Text+                ( Expr Src X )+            )+        )+        ( Op (Text, Expr Src X) )+        a+    )+  deriving (Contravariant)++-- | Combines two 'UnionInputType' values.  See 'UnionInputType' for usage+-- notes.+--+-- Ideally, this matches 'Data.Functor.Contravariant.Divisible.chosen';+-- however, this allows 'UnionInputType' to not need a 'Divisible' instance+-- itself (since no instance is possible).+(>|<) :: UnionInputType a -> UnionInputType b -> UnionInputType (Either a b)+UnionInputType (Data.Functor.Product.Pair (Control.Applicative.Const mx) (Op fx))+    >|< UnionInputType (Data.Functor.Product.Pair (Control.Applicative.Const my) (Op fy)) =+    UnionInputType+      ( Data.Functor.Product.Pair+          ( Control.Applicative.Const (mx <> my) )+          ( Op (either fx fy) )+      )++infixr 5 >|<++inputUnion :: UnionInputType a -> InputType a+inputUnion ( UnionInputType ( Data.Functor.Product.Pair ( Control.Applicative.Const fields ) ( Op embedF ) ) ) =+    InputType+      { embed = \x ->+          let (name, y) = embedF x+          in  UnionLit name y (Dhall.Map.delete name fields)+      , declared =+          Union fields+      }++inputConstructorWith+    :: Text+    -> InputType a+    -> UnionInputType a+inputConstructorWith name inputType = UnionInputType $+    Data.Functor.Product.Pair+      ( Control.Applicative.Const+          ( Dhall.Map.singleton+              name+              ( declared inputType )+          )+      )+      ( Op ( (name,) . embed inputType )+      )++inputConstructor+    :: Inject a+    => Text+    -> UnionInputType a+inputConstructor name = inputConstructorWith name inject
src/Dhall/Binary.hs view
@@ -11,17 +11,18 @@       StandardVersion(..)     , defaultStandardVersion     , parseStandardVersion+    , renderStandardVersion      -- * Encoding and decoding-    , encodeWithVersion-    , decodeWithVersion+    , encode+    , decode      -- * Exceptions     , DecodingFailure(..)     ) where  import Codec.CBOR.Term (Term(..))-import Control.Applicative (empty)+import Control.Applicative (empty, (<|>)) import Control.Exception (Exception) import Dhall.Core     ( Binding(..)@@ -48,7 +49,6 @@ import Options.Applicative (Parser) import Prelude hiding (exponent) import GHC.Float (double2Float, float2Double)-import Codec.CBOR.Magic (floatToWord16, wordToFloat16)  import qualified Crypto.Hash import qualified Data.ByteArray.Encoding@@ -62,11 +62,22 @@  -- | Supported version strings data StandardVersion-    = V_5_0_0+    = NoVersion+    -- ^ No version string+    | V_5_0_0     -- ^ Version "5.0.0"+    | V_4_0_0+    -- ^ Version "4.0.0"+    | V_3_0_0+    -- ^ Version "3.0.0"+    | V_2_0_0+    -- ^ Version "2.0.0"+    | V_1_0_0+    -- ^ Version "1.0.0"+    deriving (Enum, Bounded)  defaultStandardVersion :: StandardVersion-defaultStandardVersion = V_5_0_0+defaultStandardVersion = NoVersion  parseStandardVersion :: Parser StandardVersion parseStandardVersion =@@ -80,9 +91,22 @@     readVersion = do         string <- Options.Applicative.str         case string :: Text of+            "none"  -> return NoVersion+            "1.0.0" -> return V_1_0_0+            "2.0.0" -> return V_2_0_0+            "3.0.0" -> return V_3_0_0+            "4.0.0" -> return V_4_0_0             "5.0.0" -> return V_5_0_0             _       -> fail "Unsupported version" +renderStandardVersion :: StandardVersion -> Text+renderStandardVersion NoVersion = "none"+renderStandardVersion V_1_0_0   = "1.0.0"+renderStandardVersion V_2_0_0   = "2.0.0"+renderStandardVersion V_3_0_0   = "3.0.0"+renderStandardVersion V_4_0_0   = "4.0.0"+renderStandardVersion V_5_0_0   = "5.0.0"+ {-| Convert a function applied to multiple arguments to the base function and     the list of arguments -}@@ -96,6 +120,7 @@         ~(baseFunction, diffArguments) = go f     go baseFunction = (baseFunction, id) +-- | Encode a Dhall expression to a CBOR `Term` encode :: Expr s Import -> Term encode (Var (V "_" n)) =     TInteger n@@ -155,6 +180,8 @@     TString "Double" encode Text =     TString "Text"+encode TextShow =+    TString "Text/show" encode List =     TString "List" encode (Const Type) =@@ -286,7 +313,7 @@     TList [ TInt 7, TMap xTs₁ ]   where     xTs₁ = do-        (x₀, _T₀) <- Dhall.Map.toList xTs₀+        (x₀, _T₀) <- Dhall.Map.toList (Dhall.Map.sort xTs₀)         let x₁  = TString x₀         let _T₁ = encode _T₀         return (x₁, _T₁)@@ -294,7 +321,7 @@     TList [ TInt 8, TMap xts₁ ]   where     xts₁ = do-        (x₀, t₀) <- Dhall.Map.toList xts₀+        (x₀, t₀) <- Dhall.Map.toList (Dhall.Map.sort xts₀)         let x₁ = TString x₀         let t₁ = encode t₀         return (x₁, t₁)@@ -311,7 +338,7 @@     TList [ TInt 11, TMap xTs₁ ]   where     xTs₁ = do-        (x₀, _T₀) <- Dhall.Map.toList xTs₀+        (x₀, _T₀) <- Dhall.Map.toList (Dhall.Map.sort xTs₀)         let x₁  = TString x₀         let _T₁ = encode _T₀         return (x₁, _T₁)@@ -321,14 +348,10 @@     t₁ = encode t₀      yTs₁ = do-        (y₀, _T₀) <- Dhall.Map.toList yTs₀+        (y₀, _T₀) <- Dhall.Map.toList (Dhall.Map.sort yTs₀)         let y₁  = TString y₀         let _T₁ = encode _T₀         return (y₁, _T₁)-encode (Constructors u₀) =-    TList [ TInt 13, u₁ ]-  where-    u₁ = encode u₀ encode (BoolLit b) =     TBool b encode (BoolIf t₀ l₀ r₀) =@@ -349,9 +372,10 @@     | otherwise = TDouble n64   where     n32      = double2Float n64-    n16      = floatToWord16 n32     useFloat = n64 == float2Double n32-    useHalf  = n64 == (float2Double . wordToFloat16 . fromIntegral) n16+    -- the other three cases for Half-floats are 0.0 and the infinities+    useHalf  = or $ fmap (n64 ==) [0.0, infinity, -infinity]+    infinity = 1/0 :: Double encode (TextLit (Chunks xys₀ z₀)) =     TList ([ TInt 18 ] ++ xys₁ ++ [ z₁ ])   where@@ -455,100 +479,102 @@      ImportHashed {..} = importHashed -decode :: Term -> Maybe (Expr s Import)-decode (TInt n) =+decodeMaybe :: Term -> Maybe (Expr s Import)+decodeMaybe (TInt n) =     return (Var (V "_" (fromIntegral n)))-decode (TInteger n) =+decodeMaybe (TInteger n) =     return (Var (V "_" n))-decode (TString "Natural/build") =+decodeMaybe (TString "Natural/build") =     return NaturalBuild-decode (TString "Natural/fold") =+decodeMaybe (TString "Natural/fold") =     return NaturalFold-decode (TString "Natural/isZero") =+decodeMaybe (TString "Natural/isZero") =     return NaturalIsZero-decode (TString "Natural/even") =+decodeMaybe (TString "Natural/even") =     return NaturalEven-decode (TString "Natural/odd") =+decodeMaybe (TString "Natural/odd") =     return NaturalOdd-decode (TString "Natural/toInteger") =+decodeMaybe (TString "Natural/toInteger") =     return NaturalToInteger-decode (TString "Natural/show") =+decodeMaybe (TString "Natural/show") =     return NaturalShow-decode (TString "Integer/toDouble") =+decodeMaybe (TString "Integer/toDouble") =     return IntegerToDouble-decode (TString "Integer/show") =+decodeMaybe (TString "Integer/show") =     return IntegerShow-decode (TString "Double/show") =+decodeMaybe (TString "Double/show") =     return DoubleShow-decode (TString "List/build") =+decodeMaybe (TString "List/build") =     return ListBuild-decode (TString "List/fold") =+decodeMaybe (TString "List/fold") =     return ListFold-decode (TString "List/length") =+decodeMaybe (TString "List/length") =     return ListLength-decode (TString "List/head") =+decodeMaybe (TString "List/head") =     return ListHead-decode (TString "List/last") =+decodeMaybe (TString "List/last") =     return ListLast-decode (TString "List/indexed") =+decodeMaybe (TString "List/indexed") =     return ListIndexed-decode (TString "List/reverse") =+decodeMaybe (TString "List/reverse") =     return ListReverse-decode (TString "Optional/fold") =+decodeMaybe (TString "Optional/fold") =     return OptionalFold-decode (TString "Optional/build") =+decodeMaybe (TString "Optional/build") =     return OptionalBuild-decode (TString "Bool") =+decodeMaybe (TString "Bool") =     return Bool-decode (TString "Optional") =+decodeMaybe (TString "Optional") =     return Optional-decode (TString "None") =+decodeMaybe (TString "None") =     return None-decode (TString "Natural") =+decodeMaybe (TString "Natural") =     return Natural-decode (TString "Integer") =+decodeMaybe (TString "Integer") =     return Integer-decode (TString "Double") =+decodeMaybe (TString "Double") =     return Double-decode (TString "Text") =+decodeMaybe (TString "Text") =     return Text-decode (TString "List") =+decodeMaybe (TString "Text/show") =+    return TextShow+decodeMaybe (TString "List") =     return List-decode (TString "Type") =+decodeMaybe (TString "Type") =     return (Const Type)-decode (TString "Kind") =+decodeMaybe (TString "Kind") =     return (Const Kind)-decode (TString "Sort") =+decodeMaybe (TString "Sort") =     return (Const Sort)-decode (TString x) =+decodeMaybe (TString x) =     return (Var (V x 0))-decode (TList [ TString x, TInt n ]) =+decodeMaybe (TList [ TString x, TInt n ]) =     return (Var (V x (fromIntegral n)))-decode (TList [ TString x, TInteger n ]) =+decodeMaybe (TList [ TString x, TInteger n ]) =     return (Var (V x n))-decode (TList (TInt 0 : f₁ : xs₁)) = do-    f₀  <- decode f₁-    xs₀ <- traverse decode xs₁+decodeMaybe (TList (TInt 0 : f₁ : xs₁)) = do+    f₀  <- decodeMaybe f₁+    xs₀ <- traverse decodeMaybe xs₁     return (foldl App f₀ xs₀)-decode (TList [ TInt 1, _A₁, b₁ ]) = do-    _A₀ <- decode _A₁-    b₀  <- decode b₁+decodeMaybe (TList [ TInt 1, _A₁, b₁ ]) = do+    _A₀ <- decodeMaybe _A₁+    b₀  <- decodeMaybe b₁     return (Lam "_" _A₀ b₀)-decode (TList [ TInt 1, TString x, _A₁, b₁ ]) = do-    _A₀ <- decode _A₁-    b₀  <- decode b₁+decodeMaybe (TList [ TInt 1, TString x, _A₁, b₁ ]) = do+    _A₀ <- decodeMaybe _A₁+    b₀  <- decodeMaybe b₁     return (Lam x _A₀ b₀)-decode (TList [ TInt 2, _A₁, _B₁ ]) = do-    _A₀ <- decode _A₁-    _B₀ <- decode _B₁+decodeMaybe (TList [ TInt 2, _A₁, _B₁ ]) = do+    _A₀ <- decodeMaybe _A₁+    _B₀ <- decodeMaybe _B₁     return (Pi "_" _A₀ _B₀)-decode (TList [ TInt 2, TString x, _A₁, _B₁ ]) = do-    _A₀ <- decode _A₁-    _B₀ <- decode _B₁+decodeMaybe (TList [ TInt 2, TString x, _A₁, _B₁ ]) = do+    _A₀ <- decodeMaybe _A₁+    _B₀ <- decodeMaybe _B₁     return (Pi x _A₀ _B₀)-decode (TList [ TInt 3, TInt n, l₁, r₁ ]) = do-    l₀ <- decode l₁-    r₀ <- decode r₁+decodeMaybe (TList [ TInt 3, TInt n, l₁, r₁ ]) = do+    l₀ <- decodeMaybe l₁+    r₀ <- decodeMaybe r₁     op <- case n of             0  -> return BoolOr             1  -> return BoolAnd@@ -564,34 +590,34 @@             11 -> return ImportAlt             _  -> empty     return (op l₀ r₀)-decode (TList [ TInt 4, _T₁ ]) = do-    _T₀ <- decode _T₁+decodeMaybe (TList [ TInt 4, _T₁ ]) = do+    _T₀ <- decodeMaybe _T₁     return (ListLit (Just _T₀) empty)-decode (TList (TInt 4 : TNull : xs₁ )) = do-    xs₀ <- traverse decode xs₁+decodeMaybe (TList (TInt 4 : TNull : xs₁ )) = do+    xs₀ <- traverse decodeMaybe xs₁     return (ListLit Nothing (Data.Sequence.fromList xs₀))-decode (TList [ TInt 5, _T₁ ]) = do-    _T₀ <- decode _T₁+decodeMaybe (TList [ TInt 5, _T₁ ]) = do+    _T₀ <- decodeMaybe _T₁     return (OptionalLit _T₀ Nothing)-decode (TList [ TInt 5, TNull, t₁ ]) = do-    t₀ <- decode t₁+decodeMaybe (TList [ TInt 5, TNull, t₁ ]) = do+    t₀ <- decodeMaybe t₁     return (Some t₀)-decode (TList [ TInt 5, _T₁, t₁ ]) = do-    _T₀ <- decode _T₁-    t₀  <- decode t₁+decodeMaybe (TList [ TInt 5, _T₁, t₁ ]) = do+    _T₀ <- decodeMaybe _T₁+    t₀  <- decodeMaybe t₁     return (OptionalLit _T₀ (Just t₀))-decode (TList [ TInt 6, t₁, u₁ ]) = do-    t₀ <- decode t₁-    u₀ <- decode u₁+decodeMaybe (TList [ TInt 6, t₁, u₁ ]) = do+    t₀ <- decodeMaybe t₁+    u₀ <- decodeMaybe u₁     return (Merge t₀ u₀ Nothing)-decode (TList [ TInt 6, t₁, u₁, _T₁ ]) = do-    t₀  <- decode t₁-    u₀  <- decode u₁-    _T₀ <- decode _T₁+decodeMaybe (TList [ TInt 6, t₁, u₁, _T₁ ]) = do+    t₀  <- decodeMaybe t₁+    u₀  <- decodeMaybe u₁+    _T₀ <- decodeMaybe _T₁     return (Merge t₀ u₀ (Just _T₀))-decode (TList [ TInt 7, TMap xTs₁ ]) = do+decodeMaybe (TList [ TInt 7, TMap xTs₁ ]) = do     let process (TString x, _T₁) = do-            _T₀ <- decode _T₁+            _T₀ <- decodeMaybe _T₁              return (x, _T₀)         process _ =@@ -600,9 +626,9 @@     xTs₀ <- traverse process xTs₁      return (Record (Dhall.Map.fromList xTs₀))-decode (TList [ TInt 8, TMap xts₁ ]) = do+decodeMaybe (TList [ TInt 8, TMap xts₁ ]) = do     let process (TString x, t₁) = do-           t₀ <- decode t₁+           t₀ <- decodeMaybe t₁             return (x, t₀)         process _ =@@ -611,12 +637,12 @@     xts₀ <- traverse process xts₁      return (RecordLit (Dhall.Map.fromList xts₀))-decode (TList [ TInt 9, t₁, TString x ]) = do-    t₀ <- decode t₁+decodeMaybe (TList [ TInt 9, t₁, TString x ]) = do+    t₀ <- decodeMaybe t₁      return (Field t₀ x)-decode (TList (TInt 10 : t₁ : xs₁)) = do-    t₀ <- decode t₁+decodeMaybe (TList (TInt 10 : t₁ : xs₁)) = do+    t₀ <- decodeMaybe t₁      let process (TString x) = return x         process  _          = empty@@ -624,9 +650,9 @@     xs₀ <- traverse process xs₁      return (Project t₀ (Dhall.Set.fromList xs₀))-decode (TList [ TInt 11, TMap xTs₁ ]) = do+decodeMaybe (TList [ TInt 11, TMap xTs₁ ]) = do     let process (TString x, _T₁) = do-            _T₀ <- decode _T₁+            _T₀ <- decodeMaybe _T₁              return (x, _T₀)         process _ =@@ -635,11 +661,11 @@     xTs₀ <- traverse process xTs₁      return (Union (Dhall.Map.fromList xTs₀))-decode (TList [ TInt 12, TString x, t₁, TMap yTs₁ ]) = do-    t₀ <- decode t₁+decodeMaybe (TList [ TInt 12, TString x, t₁, TMap yTs₁ ]) = do+    t₀ <- decodeMaybe t₁      let process (TString y, _T₁) = do-            _T₀ <- decode _T₁+            _T₀ <- decodeMaybe _T₁              return (y, _T₀)         process _ =@@ -648,35 +674,31 @@     yTs₀ <- traverse process yTs₁      return (UnionLit x t₀ (Dhall.Map.fromList yTs₀))-decode (TList [ TInt 13, u₁ ]) = do-    u₀ <- decode u₁--    return (Constructors u₀)-decode (TBool b) = do+decodeMaybe (TBool b) = do     return (BoolLit b)-decode (TList [ TInt 14, t₁, l₁, r₁ ]) = do-    t₀ <- decode t₁-    l₀ <- decode l₁-    r₀ <- decode r₁+decodeMaybe (TList [ TInt 14, t₁, l₁, r₁ ]) = do+    t₀ <- decodeMaybe t₁+    l₀ <- decodeMaybe l₁+    r₀ <- decodeMaybe r₁      return (BoolIf t₀ l₀ r₀)-decode (TList [ TInt 15, TInt n ]) = do+decodeMaybe (TList [ TInt 15, TInt n ]) = do     return (NaturalLit (fromIntegral n))-decode (TList [ TInt 15, TInteger n ]) = do+decodeMaybe (TList [ TInt 15, TInteger n ]) = do     return (NaturalLit (fromInteger n))-decode (TList [ TInt 16, TInt n ]) = do+decodeMaybe (TList [ TInt 16, TInt n ]) = do     return (IntegerLit (fromIntegral n))-decode (TList [ TInt 16, TInteger n ]) = do+decodeMaybe (TList [ TInt 16, TInteger n ]) = do     return (IntegerLit n)-decode (THalf n) = do+decodeMaybe (THalf n) = do     return (DoubleLit (float2Double n))-decode (TFloat n) = do+decodeMaybe (TFloat n) = do     return (DoubleLit (float2Double n))-decode (TDouble n) = do+decodeMaybe (TDouble n) = do     return (DoubleLit n)-decode (TList (TInt 18 : xs)) = do+decodeMaybe (TList (TInt 18 : xs)) = do     let process (TString x : y₁ : zs) = do-            y₀ <- decode y₁+            y₀ <- decodeMaybe y₁              ~(xys, z) <- process zs @@ -689,7 +711,7 @@     (xys, z) <- process xs      return (TextLit (Chunks xys z))-decode (TList (TInt 24 : h : TInt mode : TInt n : xs)) = do+decodeMaybe (TList (TInt 24 : h : TInt mode : TInt n : xs)) = do     hash <- case h of         TNull -> do             return Nothing@@ -733,7 +755,7 @@                     headers₁ <- case headers₀ of                         TNull -> return Nothing                         _     -> do-                            Embed (Import { importHashed = headers }) <- decode headers₀+                            Embed (Import { importHashed = headers }) <- decodeMaybe headers₀                             return (Just headers)                     (paths, file, query, fragment) <- process ys                     return (headers₁, authority, paths, file, query, fragment)@@ -783,19 +805,19 @@     let importHashed = ImportHashed {..}      return (Embed (Import {..}))-decode (TList (TInt 25 : xs)) = do+decodeMaybe (TList (TInt 25 : xs)) = do     let process (TString x : _A₁ : a₁ : ls₁) = do             mA₀ <- case _A₁ of                 TNull -> return Nothing-                _     -> fmap Just (decode _A₁)+                _     -> fmap Just (decodeMaybe _A₁) -            a₀  <- decode a₁+            a₀  <- decodeMaybe a₁              let binding = Binding x mA₀ a₀              case ls₁ of                 [ b₁ ] -> do-                    b₀ <- decode b₁+                    b₀ <- decodeMaybe b₁                      return (Let (binding :| []) b₀)                 _ -> do@@ -806,47 +828,30 @@             empty      process xs-decode (TList [ TInt 26, t₁, _T₁ ]) = do-    t₀  <- decode t₁-    _T₀ <- decode _T₁+decodeMaybe (TList [ TInt 26, t₁, _T₁ ]) = do+    t₀  <- decodeMaybe t₁+    _T₀ <- decodeMaybe _T₁     return (Annot t₀ _T₀)-decode _ =+decodeMaybe _ =     empty -{-| Decode a Dhall expression--    This auto-detects which standard version to decode based on the included-    standard version string in the decoded expression--}-decodeWithVersion :: Term -> Either DecodingFailure (Expr s Import)-decodeWithVersion term = do-    (version, subTerm) <- case term of-        TList [ TString version, subTerm ] ->-            return (version, subTerm)-        _ ->-            fail ("Cannot decode the version from this decoded CBOR expression: " <> show term)--    case version of-        "5.0.0" -> do-            return ()-        _ -> do-            fail ("This decoded version is not supported: " <> Data.Text.unpack version)--    case decode subTerm of-        Nothing ->-            fail ("This decoded CBOR expression does not represent a valid Dhall expression: " <> show subTerm)-        Just expression ->-            return expression+-- | Decode a Dhall expression from a CBOR `Term`+decode :: Term -> Either DecodingFailure (Expr s Import)+decode term =+    case decodeWithoutVersion <|> decodeWithVersion of+        Just expression -> Right expression+        Nothing         -> Left (CBORIsNotDhall term)+  where+    -- This is the behavior specified by the standard+    decodeWithoutVersion = decodeMaybe term --- | Encode a Dhall expression using the specified `Version`-encodeWithVersion :: StandardVersion -> Expr s Import -> Term-encodeWithVersion V_5_0_0 expression =-    TList [ TString "5.0.0", encode expression ]+    -- For backwards compatibility with older expressions that have a version+    -- tag to ease the migration+    decodeWithVersion = do+        TList [ TString _, taggedTerm ] <- return term+        decodeMaybe taggedTerm -data DecodingFailure-    = CannotDecodeVersionString Term-    | UnsupportedVersionString Text-    | CBORIsNotDhall Term+data DecodingFailure = CBORIsNotDhall Term     deriving (Eq)  instance Exception DecodingFailure@@ -855,25 +860,6 @@ _ERROR = "\ESC[1;31mError\ESC[0m"  instance Show DecodingFailure where-    show (CannotDecodeVersionString term) =-            _ERROR <> ": Cannot decode version string\n"-        <>  "\n"-        <>  "This CBOR expression does not contain a version string in any\n"-        <>  "recognizable format\n"-        <>  "\n"-        <>  "↳ " <> show term <> "\n"-    show (UnsupportedVersionString version) =-            _ERROR <> ": Unsupported version string\n"-        <>  "\n"-        <>  "The encoded Dhall expression was tagged with a version string of:\n"-        <>  "\n"-        <>  "↳ " <> show version <> "\n"-        <>  "\n"-        <>  "... but this implementation cannot decode that version\n"-        <>  "\n"-        <>  "Some common reasons why you might get this error:\n"-        <>  "\n"-        <>  "● You are using an old version of the interpreter and need to upgrade\n"     show (CBORIsNotDhall term) =             _ERROR <> ": Cannot decode CBOR to Dhall\n"         <>  "\n"
src/Dhall/Core.hs view
@@ -87,12 +87,14 @@  import qualified Control.Monad import qualified Crypto.Hash+import qualified Data.Char import qualified Data.HashSet import qualified Data.Sequence import qualified Data.Text import qualified Data.Text.Prettyprint.Doc  as Pretty import qualified Dhall.Map import qualified Dhall.Set+import qualified Text.Printf  {-| Constants for a pure type system @@ -405,6 +407,8 @@     | TextLit (Chunks s a)     -- | > TextAppend x y                           ~  x ++ y     | TextAppend (Expr s a) (Expr s a)+    -- | > TextShow                                 ~  Text/show+    | TextShow     -- | > List                                     ~  List     | List     -- | > ListLit (Just t ) [x, y, z]              ~  [x, y, z] : List t@@ -456,8 +460,6 @@     -- | > Merge x y (Just t )                      ~  merge x y : t     --   > Merge x y  Nothing                       ~  merge x y     | Merge (Expr s a) (Expr s a) (Maybe (Expr s a))-    -- | > Constructors e                           ~  constructors e-    | Constructors (Expr s a)     -- | > Field e x                                ~  e.x     | Field (Expr s a) Text     -- | > Project e xs                             ~  e.{ xs }@@ -510,6 +512,7 @@   fmap _ Text = Text   fmap f (TextLit cs) = TextLit (fmap f cs)   fmap f (TextAppend e1 e2) = TextAppend (fmap f e1) (fmap f e2)+  fmap _ TextShow = TextShow   fmap _ List = List   fmap f (ListLit maybeE seqE) = ListLit (fmap (fmap f) maybeE) (fmap (fmap f) seqE)   fmap f (ListAppend e1 e2) = ListAppend (fmap f e1) (fmap f e2)@@ -534,7 +537,6 @@   fmap f (CombineTypes e1 e2) = CombineTypes (fmap f e1) (fmap f e2)   fmap f (Prefer e1 e2) = Prefer (fmap f e1) (fmap f e2)   fmap f (Merge e1 e2 maybeE) = Merge (fmap f e1) (fmap f e2) (fmap (fmap f) maybeE)-  fmap f (Constructors e1) = Constructors (fmap f e1)   fmap f (Field e1 v) = Field (fmap f e1) v   fmap f (Project e1 vs) = Project (fmap f e1) vs   fmap f (Note s e1) = Note s (fmap f e1)@@ -587,6 +589,7 @@     Text                 >>= _ = Text     TextLit (Chunks a b) >>= k = TextLit (Chunks (fmap (fmap (>>= k)) a) b)     TextAppend a b       >>= k = TextAppend (a >>= k) (b >>= k)+    TextShow             >>= _ = TextShow     List                 >>= _ = List     ListLit a b          >>= k = ListLit (fmap (>>= k) a) (fmap (>>= k) b)     ListAppend a b       >>= k = ListAppend (a >>= k) (b >>= k)@@ -611,7 +614,6 @@     CombineTypes a b     >>= k = CombineTypes (a >>= k) (b >>= k)     Prefer a b           >>= k = Prefer (a >>= k) (b >>= k)     Merge a b c          >>= k = Merge (a >>= k) (b >>= k) (fmap (>>= k) c)-    Constructors a       >>= k = Constructors (a >>= k)     Field a b            >>= k = Field (a >>= k) b     Project a b          >>= k = Project (a >>= k) b     Note a b             >>= k = Note a (b >>= k)@@ -654,6 +656,7 @@     first _  Text                  = Text     first k (TextLit (Chunks a b)) = TextLit (Chunks (fmap (fmap (first k)) a) b)     first k (TextAppend a b      ) = TextAppend (first k a) (first k b)+    first _  TextShow              = TextShow     first _  List                  = List     first k (ListLit a b         ) = ListLit (fmap (first k) a) (fmap (first k) b)     first k (ListAppend a b      ) = ListAppend (first k a) (first k b)@@ -678,7 +681,6 @@     first k (CombineTypes a b    ) = CombineTypes (first k a) (first k b)     first k (Prefer a b          ) = Prefer (first k a) (first k b)     first k (Merge a b c         ) = Merge (first k a) (first k b) (fmap (first k) c)-    first k (Constructors a      ) = Constructors (first k a)     first k (Field a b           ) = Field (first k a) b     first k (Project a b         ) = Project (first k a) b     first k (Note a b            ) = Note (k a) (first k b)@@ -828,14 +830,15 @@      b₁  =       shift d (V x₀ n₁)   b₀ shift d (V x₀ n₀) (Let (Binding x₁ mA₀ a₀ :| (l₀ : ls₀)) b₀) =-    Let (Binding x₁ mA₁ a₁ :| (l₁ : ls₁)) b₁+    case shift d (V x₀ n₁) (Let (l₀ :| ls₀) b₀) of+        Let (l₁ :| ls₁) b₁ -> Let (Binding x₁ mA₁ a₁ :| (l₁ : ls₁)) b₁+        e                  -> Let (Binding x₁ mA₁ a₁ :|       []  ) e   where     n₁ = if x₀ == x₁ then n₀ + 1 else n₀      mA₁ = fmap (shift d (V x₀ n₀)) mA₀     a₁  =       shift d (V x₀ n₀)   a₀ -    Let (l₁ :| ls₁) b₁ = shift d (V x₀ n₁) (Let (l₀ :| ls₀) b₀) shift d v (Annot a b) = Annot a' b'   where     a' = shift d v a@@ -895,6 +898,7 @@   where     a' = shift d v a     b' = shift d v b+shift _ _ TextShow = TextShow shift _ _ List = List shift d v (ListLit a b) = ListLit a' b'   where@@ -952,9 +956,6 @@     a' =       shift d v  a     b' =       shift d v  b     c' = fmap (shift d v) c-shift d v (Constructors a) = Constructors a'-  where-    a' = shift d v  a shift d v (Field a b) = Field a' b   where     a' = shift d v a@@ -1005,7 +1006,9 @@      b₁  =       subst (V x₀ n₁) e₁   b₀ subst (V x₀ n₀) e₀ (Let (Binding x₁ mA₀ a₀ :| (l₀ : ls₀)) b₀) =-    Let (Binding x₁ mA₁ a₁ :| (l₁ : ls₁)) b₁+    case subst (V x₀ n₁) e₁ (Let (l₀ :| ls₀) b₀) of+        Let (l₁ :| ls₁) b₁ -> Let (Binding x₁ mA₁ a₁ :| (l₁ : ls₁)) b₁+        e                  -> Let (Binding x₁ mA₁ a₁ :|       []  ) e   where     n₁ = if x₀ == x₁ then n₀ + 1 else n₀ @@ -1014,7 +1017,6 @@     mA₁ = fmap (subst (V x₀ n₀) e₀) mA₀     a₁  =       subst (V x₀ n₀) e₀   a₀ -    Let (l₁ :| ls₁) b₁ = subst (V x₀ n₁) e₁ (Let (l₀ :| ls₀) b₀) subst x e (Annot a b) = Annot a' b'   where     a' = subst x e a@@ -1074,6 +1076,7 @@   where     a' = subst x e a     b' = subst x e b+subst _ _ TextShow = TextShow subst _ _ List = List subst x e (ListLit a b) = ListLit a' b'   where@@ -1122,9 +1125,6 @@     a' =       subst x e  a     b' =       subst x e  b     c' = fmap (subst x e) c-subst x e (Constructors a) = Constructors a'-  where-    a' = subst x e  a subst x e (Field a b) = Field a' b   where     a' = subst x e a@@ -1201,12 +1201,12 @@      b₁  =      alphaNormalize b₀ alphaNormalize (Let (Binding "_" mA₀ a₀ :| (l₀ : ls₀)) b₀) =-    Let (Binding "_" mA₁ a₁ :| (l₁ : ls₁)) b₁+    case alphaNormalize (Let (l₀ :| ls₀) b₀) of+        Let (l₁ :| ls₁) b₁ -> Let (Binding "_" mA₁ a₁ :| (l₁ : ls₁)) b₁+        e                  -> Let (Binding "_" mA₁ a₁ :|       []  ) e   where     mA₁ = fmap alphaNormalize mA₀     a₁  =      alphaNormalize  a₀--    Let (l₁ :| ls₁) b₁ = alphaNormalize (Let (l₀ :| ls₀) b₀) alphaNormalize (Let (Binding x mA₀ a₀ :| []) b₀) =     Let (Binding "_" mA₁ a₁ :| []) b₄   where@@ -1218,7 +1218,9 @@     b₃ = shift (-1) (V x 0) b₂     b₄ = alphaNormalize b₃ alphaNormalize (Let (Binding x mA₀ a₀ :| (l₀ : ls₀)) b₀) =-    Let (Binding "_" mA₁ a₁ :| (l₁ : ls₁)) b₄+    case alphaNormalize (Let (l₀ :| ls₀) b₃) of+        Let (l₁ :| ls₁) b₄ -> Let (Binding "_" mA₁ a₁ :| (l₁ : ls₁)) b₄+        e                  -> Let (Binding "_" mA₁ a₁ :|       []  ) e   where     mA₁ = fmap alphaNormalize mA₀     a₁  =      alphaNormalize a₀@@ -1226,8 +1228,6 @@     b₁ = shift 1 (V "_" 0) b₀     b₂ = subst (V x 0) (Var (V "_" 0)) b₁     b₃ = shift (-1) (V x 0) b₂--    Let (l₁ :| ls₁) b₄ = alphaNormalize (Let (l₀ :| ls₀) b₃) alphaNormalize (Annot t₀ _T₀) =     Annot t₁ _T₁   where@@ -1329,6 +1329,8 @@     l₁ = alphaNormalize l₀      r₁ = alphaNormalize r₀+alphaNormalize TextShow =+    TextShow alphaNormalize List =     List alphaNormalize (ListLit (Just _T₀) ts₀) =@@ -1421,10 +1423,6 @@     u₁ = alphaNormalize u₀      _T₁ = fmap alphaNormalize _T₀-alphaNormalize (Constructors u₀) =-    Constructors u₁-  where-    u₁ = alphaNormalize u₀ alphaNormalize (Field e₀ a) =     Field e₁ a   where@@ -1519,6 +1517,7 @@ denote  Text                  = Text denote (TextLit (Chunks a b)) = TextLit (Chunks (fmap (fmap denote) a) b) denote (TextAppend a b      ) = TextAppend (denote a) (denote b)+denote  TextShow              = TextShow denote  List                  = List denote (ListLit a b         ) = ListLit (fmap denote a) (fmap denote b) denote (ListAppend a b      ) = ListAppend (denote a) (denote b)@@ -1543,7 +1542,6 @@ denote (CombineTypes a b    ) = CombineTypes (denote a) (denote b) denote (Prefer a b          ) = Prefer (denote a) (denote b) denote (Merge a b c         ) = Merge (denote a) (denote b) (fmap denote c)-denote (Constructors a      ) = Constructors (denote a) denote (Field a b           ) = Field (denote a) b denote (Project a b         ) = Project (denote a) b denote (ImportAlt a b       ) = ImportAlt (denote a) (denote b)@@ -1711,6 +1709,10 @@                         loop nothing                     App (App (App (App (App OptionalFold _) (Some x)) _) just) _ ->                         loop (App just x)+                    App TextShow (TextLit (Chunks [] oldText)) ->+                        loop (TextLit (Chunks [] newText))+                      where+                        newText = textShow oldText                     _ -> do                         res2 <- ctx (App f' a')                         case res2 of@@ -1825,6 +1827,7 @@         decide  l          (TextLit n) | isEmpty n = l         decide (TextLit m) (TextLit n)             = TextLit (m <> n)         decide  l           r                      = TextAppend l r+    TextShow -> pure TextShow     List -> pure List     ListLit t es         | Data.Sequence.null es -> ListLit <$> t' <*> es'@@ -1911,11 +1914,6 @@             _ -> Merge x' y' <$> t'       where         t' = traverse loop t-    Constructors t   -> do-        t' <- loop t-        case t' of-            u@(Union _) -> pure u-            _           -> pure $ Constructors t'     Field r x        -> do         r' <- loop r         case r' of@@ -1951,6 +1949,19 @@     ImportAlt l _r -> loop l     Embed a -> pure (Embed a) +textShow :: Text -> Text+textShow text = "\"" <> Data.Text.concatMap f text <> "\""+  where+    f '"'  = "\\\""+    f '$'  = "\\u0024"+    f '\\' = "\\\\"+    f '\b' = "\\b"+    f '\n' = "\\n"+    f '\r' = "\\r"+    f '\t' = "\\t"+    f c | c <= '\x1F' = Data.Text.pack (Text.Printf.printf "\\u%04d" (Data.Char.ord c))+        | otherwise   = Data.Text.singleton c+ {-| Returns `True` if two expressions are α-equivalent and β-equivalent and     `False` otherwise -}@@ -2022,6 +2033,8 @@               False           App (App (App (App (App OptionalFold _) (App None _)) _) _) _ ->               False+          App TextShow (TextLit (Chunks [] _)) ->+              False           _ -> True       Let _ _ -> False       Annot _ _ -> False@@ -2099,6 +2112,7 @@           decide  _          (TextLit n) | isEmpty n = False           decide (TextLit _) (TextLit _)             = False           decide  _           _                      = True+      TextShow -> True       List -> True       ListLit t es -> all loop t && all loop es       ListAppend x y -> loop x && loop y && decide x y@@ -2152,11 +2166,6 @@                               Nothing -> True                       _ -> True               _ -> True-      Constructors t -> loop t &&-          case t of-              Union _ -> False-              _       -> True-       Field r x -> loop r &&           case r of               RecordLit kvs ->@@ -2254,6 +2263,7 @@         , "Double"         , "Double/show"         , "Text"+        , "Text/show"         , "List"         , "List/build"         , "List/fold"@@ -2312,6 +2322,7 @@ subExpressions f (TextLit (Chunks a b)) =     TextLit <$> (Chunks <$> traverse (traverse f) a <*> pure b) subExpressions f (TextAppend a b) = TextAppend <$> f a <*> f b+subExpressions _ TextShow = pure TextShow subExpressions _ List = pure List subExpressions f (ListLit a b) = ListLit <$> traverse f a <*> traverse f b subExpressions f (ListAppend a b) = ListAppend <$> f a <*> f b@@ -2336,7 +2347,6 @@ subExpressions f (CombineTypes a b) = CombineTypes <$> f a <*> f b subExpressions f (Prefer a b) = Prefer <$> f a <*> f b subExpressions f (Merge a b t) = Merge <$> f a <*> f b <*> traverse f t-subExpressions f (Constructors a) = Constructors <$> f a subExpressions f (Field a b) = Field <$> f a <*> pure b subExpressions f (Project a b) = Project <$> f a <*> pure b subExpressions f (Note a b) = Note a <$> f b
src/Dhall/Diff.hs view
@@ -642,10 +642,6 @@     <>  ignore     <>  " "     <>  ignore-skeleton (Constructors {}) =-        keyword "constructors"-    <>  " "-    <>  ignore skeleton (Field {}) =         ignore     <>  dot@@ -974,12 +970,6 @@   where     docs (App aL bL) (App aR bR) =         Data.List.NonEmpty.cons (diffImportExpression bL bR) (docs aL aR)-    docs (Constructors aL) (Constructors aR) =-        diffImportExpression aL aR :| [ keyword "constructors" ]-    docs aL aR@(Constructors {}) =-        pure (mismatch aL aR)-    docs aL@(Constructors {}) aR =-        pure (mismatch aL aR)     docs (Some aL) (Some aR) =         diffImportExpression aL aR :| [ builtin "Some" ]     docs aL aR@(Some {}) =@@ -992,12 +982,6 @@     mismatch l r diffApplicationExpression l r@(App {}) =     mismatch l r-diffApplicationExpression (Constructors l) (Constructors r) =-    enclosed' mempty mempty (keyword "constructors" :| [ diffImportExpression l r ])-diffApplicationExpression l@(Constructors {}) r =-    mismatch l r-diffApplicationExpression l r@(Constructors {}) =-    mismatch l r diffApplicationExpression (Some l) (Some r) =     enclosed' mempty mempty (builtin "Some" :| [ diffImportExpression l r ]) diffApplicationExpression l@(Some {}) r =@@ -1149,6 +1133,12 @@ diffPrimitiveExpression l@Text r =     mismatch l r diffPrimitiveExpression l r@Text =+    mismatch l r+diffPrimitiveExpression TextShow TextShow =+    "…"+diffPrimitiveExpression l@TextShow r =+    mismatch l r+diffPrimitiveExpression l r@TextShow =     mismatch l r diffPrimitiveExpression List List =     "…"
src/Dhall/Format.hs view
@@ -1,63 +1,114 @@+{-# LANGUAGE DeriveAnyClass    #-} {-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE RecordWildCards   #-}  -- | This module contains the implementation of the @dhall format@ subcommand  module Dhall.Format     ( -- * Format-      format+      Format(..)+    , FormatMode(..)+    , format     ) where +import Control.Exception (Exception)+import Control.Monad.IO.Class (MonadIO(..)) import Dhall.Parser (exprAndHeaderFromText) import Dhall.Pretty (CharacterSet(..), annToAnsiStyle, layoutOpts)  import Data.Monoid ((<>))  import qualified Data.Text.Prettyprint.Doc                 as Pretty-import qualified Data.Text.Prettyprint.Doc.Render.Terminal as Pretty+import qualified Data.Text.Prettyprint.Doc.Render.Terminal as Pretty.Terminal+import qualified Data.Text.Prettyprint.Doc.Render.Text     as Pretty.Text import qualified Control.Exception import qualified Data.Text.IO import qualified Dhall.Pretty import qualified System.Console.ANSI import qualified System.IO +data NotFormatted = NotFormatted+    deriving (Exception)++instance Show NotFormatted where+    show _ = ""++-- | Arguments to the `format` subcommand+data Format = Format+    { characterSet :: CharacterSet+    , formatMode   :: FormatMode+    }++{-| The `format` subcommand can either `Modify` its input or simply `Check`+    that the input is already formatted+-}+data FormatMode+    = Modify+        { inplace :: Maybe FilePath+          -- ^ Modify file in-place if present, otherwise read from @stdin@ and+          --   write to @stdout@+        }+    | Check+        { path :: Maybe FilePath+          -- ^ Read from the given file if present, otherwise read from @stdin@+        }+ -- | Implementation of the @dhall format@ subcommand format-    :: CharacterSet-    -> Maybe FilePath-    -- ^ Modify file in-place if present, otherwise read from @stdin@ and write-    --   to @stdout@+    :: Format     -> IO ()-format characterSet inplace = do-        case inplace of-            Just file -> do-                text <- Data.Text.IO.readFile file-                (header, expr) <- case exprAndHeaderFromText "(stdin)" text of-                    Left  err -> Control.Exception.throwIO err-                    Right x   -> return x+format (Format {..}) =+    case formatMode of+        Modify {..} ->+            case inplace of+                Just file -> do+                    text <- Data.Text.IO.readFile file -                let doc =   Pretty.pretty header-                        <>  Pretty.unAnnotate (Dhall.Pretty.prettyCharacterSet characterSet expr)-                System.IO.withFile file System.IO.WriteMode (\handle -> do-                    Pretty.renderIO handle (Pretty.layoutSmart layoutOpts doc)-                    Data.Text.IO.hPutStrLn handle "" )-            Nothing -> do-                inText <- Data.Text.IO.getContents+                    (header, expr) <- throws (exprAndHeaderFromText "(stdin)" text) -                (header, expr) <- case exprAndHeaderFromText "(stdin)" inText of-                    Left  err -> Control.Exception.throwIO err-                    Right x   -> return x+                    let doc =   Pretty.pretty header+                            <>  Pretty.unAnnotate (Dhall.Pretty.prettyCharacterSet characterSet expr)+                            <>  "\n"+                    System.IO.withFile file System.IO.WriteMode (\handle -> do+                        Pretty.Terminal.renderIO handle (Pretty.layoutSmart layoutOpts doc))+                Nothing -> do+                    inText <- Data.Text.IO.getContents -                let doc =   Pretty.pretty header-                        <>  Dhall.Pretty.prettyCharacterSet characterSet expr+                    (header, expr) <- throws (exprAndHeaderFromText "(stdin)" inText) -                supportsANSI <- System.Console.ANSI.hSupportsANSI System.IO.stdout+                    let doc =   Pretty.pretty header+                            <>  Dhall.Pretty.prettyCharacterSet characterSet expr+                            <>  "\n" -                if supportsANSI-                  then-                    Pretty.renderIO-                      System.IO.stdout-                      (fmap annToAnsiStyle (Pretty.layoutSmart layoutOpts doc))-                  else-                    Pretty.renderIO-                      System.IO.stdout-                      (Pretty.layoutSmart layoutOpts (Pretty.unAnnotate doc))+                    supportsANSI <- System.Console.ANSI.hSupportsANSI System.IO.stdout++                    if supportsANSI+                      then+                        Pretty.Terminal.renderIO+                          System.IO.stdout+                          (fmap annToAnsiStyle (Pretty.layoutSmart layoutOpts doc))+                      else+                        Pretty.Terminal.renderIO+                          System.IO.stdout+                          (Pretty.layoutSmart layoutOpts (Pretty.unAnnotate doc))+        Check {..} -> do+            originalText <- case path of+                Just file -> Data.Text.IO.readFile file+                Nothing   -> Data.Text.IO.getContents++            (header, expr) <- throws (exprAndHeaderFromText "(stdin)" originalText)++            let doc =   Pretty.pretty header+                    <>  Pretty.unAnnotate (Dhall.Pretty.prettyCharacterSet characterSet expr)+                    <>  "\n"++            let formattedText =+                    Pretty.Text.renderStrict (Pretty.layoutSmart layoutOpts doc)++            if originalText == formattedText+                then return ()+                else Control.Exception.throwIO NotFormatted++throws :: (Exception e, MonadIO io) => Either e a -> io a+throws (Left  e) = liftIO (Control.Exception.throwIO e)+throws (Right a) = return a
src/Dhall/Freeze.hs view
@@ -5,7 +5,8 @@ module Dhall.Freeze     ( -- * Freeze       freeze-    , hashImport+    , freezeImport+    , freezeRemoteImport     ) where  import Control.Exception (SomeException)@@ -13,7 +14,7 @@ import Data.Maybe (fromMaybe) import Data.Text import Dhall.Binary (StandardVersion(..))-import Dhall.Core (Expr(..), Import(..), ImportHashed(..))+import Dhall.Core (Expr(..), Import(..), ImportHashed(..), ImportType(..)) import Dhall.Import (standardVersion) import Dhall.Parser (exprAndHeaderFromText, Src) import Dhall.Pretty (annToAnsiStyle, layoutOpts)@@ -33,13 +34,13 @@ import qualified System.IO  -- | Retrieve an `Import` and update the hash to match the latest contents-hashImport+freezeImport     :: FilePath     -- ^ Current working directory     -> StandardVersion     -> Import     -> IO Import-hashImport directory _standardVersion import_ = do+freezeImport directory _standardVersion import_ = do     let unprotectedImport =             import_                 { importHashed =@@ -47,8 +48,12 @@                         { hash = Nothing                         }                 }-    let status = set standardVersion _standardVersion (Dhall.Import.emptyStatus directory) +    let status =+            set standardVersion+                _standardVersion+                (Dhall.Import.emptyStatus directory)+     let download =             State.evalStateT (Dhall.Import.loadWith (Embed import_)) status @@ -77,6 +82,18 @@      return newImport +-- | Freeze an import only if the import is a `Remote` import+freezeRemoteImport+    :: FilePath+    -- ^ Current working directory+    -> StandardVersion+    -> Import+    -> IO Import+freezeRemoteImport directory _standardVersion import_ = do+    case importType (importHashed import_) of+        Remote {} -> freezeImport directory _standardVersion import_+        _         -> return import_+ parseExpr :: String -> Text -> IO (Text, Expr Src Import) parseExpr src txt =     case exprAndHeaderFromText src txt of@@ -107,9 +124,11 @@     :: Maybe FilePath     -- ^ Modify file in-place if present, otherwise read from @stdin@ and write     --   to @stdout@+    -> Bool+    -- ^ If `True` then freeze all imports, otherwise freeze only remote imports     -> StandardVersion     -> IO ()-freeze inplace _standardVersion = do+freeze inplace everything _standardVersion = do     (text, directory) <- case inplace of         Nothing -> do             text <- Data.Text.IO.getContents@@ -122,7 +141,10 @@             return (text, System.FilePath.takeDirectory file)      (header, parsedExpression) <- parseExpr srcInfo text-    frozenExpression <- traverse (hashImport directory _standardVersion) parsedExpression++    let freezeFunction = if everything then freezeImport else freezeRemoteImport++    frozenExpression <- traverse (freezeFunction directory _standardVersion) parsedExpression     writeExpr inplace (header, frozenExpression)         where             srcInfo = fromMaybe "(stdin)" inplace
src/Dhall/Import.hs view
@@ -128,7 +128,7 @@     ) where  import Control.Applicative (Alternative(..))-import Codec.CBOR.Term (Term)+import Codec.CBOR.Term (Term(..)) import Control.Exception (Exception, SomeException, throwIO, toException) import Control.Monad (guard) import Control.Monad.Catch (throwM, MonadCatch(catch), catches, Handler(..))@@ -137,7 +137,7 @@ import Crypto.Hash (SHA256) import Data.CaseInsensitive (CI) import Data.List.NonEmpty (NonEmpty(..))-import Data.Semigroup (sconcat, (<>))+import Data.Semigroup (Semigroup(..)) import Data.Text (Text) #if MIN_VERSION_base(4,8,0) #else@@ -167,7 +167,7 @@ import Dhall.Import.Types import Text.Dot ((.->.), userNodeId) -import Dhall.Parser (Parser(..), ParseError(..), Src(..))+import Dhall.Parser (Parser(..), ParseError(..), Src(..), SourcedException(..)) import Dhall.TypeCheck (X(..)) import Lens.Family.State.Strict (zoom) @@ -255,14 +255,16 @@ instance Exception e => Exception (Imported e)  instance Show e => Show (Imported e) where-    show (Imported imports e) =+    show (Imported canonicalizedImports e) =            concat (zipWith indent [0..] toDisplay)         ++ "\n"         ++ show e       where         indent n import_ =             "\n" ++ replicate (2 * n) ' ' ++ "↳ " ++ Dhall.Pretty.Internal.prettyToString import_-        canonical = NonEmpty.toList (canonicalizeAll imports)++        canonical = NonEmpty.toList canonicalizedImports+         -- Tthe final (outermost) import is fake to establish the base         -- directory. Also, we need outermost-first.         toDisplay = drop 1 (reverse canonical)@@ -278,7 +280,6 @@             "\n"         <>  "\ESC[1;31mError\ESC[0m: Missing file "         <>  path-        <>  "\n"  -- | Exception thrown when an environment variable is missing newtype MissingEnvironmentVariable = MissingEnvironmentVariable { name :: Text }@@ -302,19 +303,16 @@     show (MissingImports []) =             "\n"         <>  "\ESC[1;31mError\ESC[0m: No valid imports"-        <>  "\n"     show (MissingImports [e]) = show e     show (MissingImports es) =             "\n"         <>  "\ESC[1;31mError\ESC[0m: Failed to resolve imports. Error list:"         <>  "\n"         <>  concatMap (\e -> "\n" <> show e <> "\n") es-        <>  "\n"  throwMissingImport :: (MonadCatch m, Exception e) => e -> m a throwMissingImport e = throwM (MissingImports [(toException e)]) - -- | Exception thrown when a HTTP url is imported but dhall was built without -- the @with-http@ Cabal flag. data CannotImportHTTPURL =@@ -336,15 +334,12 @@         <>  url         <>  "\n" -canonicalizeAll :: NonEmpty Import -> NonEmpty Import-canonicalizeAll = NonEmpty.scanr1 step-  where-    step a parent = canonicalizeImport (a :| [parent])- {-|-> canonicalize (canonicalize x) = canonicalize x+> canonicalize . canonicalize = canonicalize++> canonicalize (a <> b) = canonicalize a <> canonicalize b -}-class Canonicalize path where+class Semigroup path => Canonicalize path where     canonicalize :: path -> path  -- |@@ -395,10 +390,6 @@     canonicalize (Import importHashed importMode) =         Import (canonicalize importHashed) importMode -canonicalizeImport :: NonEmpty Import -> Import-canonicalizeImport imports =-    canonicalize (sconcat (NonEmpty.reverse imports))- toHeaders   :: Expr s a   -> Maybe [(CI Data.ByteString.ByteString, Data.ByteString.ByteString)]@@ -490,7 +481,7 @@          term <- throws (Codec.Serialise.deserialiseOrFail bytesLazy) -        throws (Dhall.Binary.decodeWithVersion term)+        throws (Dhall.Binary.decode term)      case result of         Just expression -> return expression@@ -527,16 +518,22 @@                         expression                     ) -        let bytes = encodeExpression _standardVersion normalizedExpression+        let check version = do+                let bytes = encodeExpression version normalizedExpression -        let actualHash = Crypto.Hash.hash bytes+                let actualHash = Crypto.Hash.hash bytes -        if expectedHash == actualHash-            then return ()-            else liftIO (Control.Exception.throwIO (HashMismatch {..}))+                guard (expectedHash == actualHash) -        liftIO (Data.ByteString.writeFile cacheFile bytes)+                liftIO (Data.ByteString.writeFile cacheFile bytes) +        let fallback = do+                let actualHash = hashExpression NoVersion normalizedExpression++                liftIO (Control.Exception.throwIO (HashMismatch {..}))++        Data.Foldable.asum (map check [ minBound .. maxBound ]) <|> fallback+     return ()  getCacheFile@@ -572,8 +569,6 @@      cacheDirectory <- getCacheDirectory -    assertDirectory cacheDirectory-     let dhallDirectory = cacheDirectory </> "dhall"      assertDirectory dhallDirectory@@ -582,22 +577,23 @@      return cacheFile -getCacheDirectory :: MonadIO io => io FilePath-#if MIN_VERSION_directory(1,2,3)-getCacheDirectory = liftIO (Directory.getXdgDirectory Directory.XdgCache "")-#else-getCacheDirectory = liftIO $ do-    maybeXDGCacheHome <- System.Environment.lookupEnv "XDG_CACHE_HOME"+getCacheDirectory :: (Alternative m, MonadIO m) => m FilePath+getCacheDirectory = alternative₀ <|> alternative₁+  where+    alternative₀ = do+        maybeXDGCacheHome <- do+          liftIO (System.Environment.lookupEnv "XDG_CACHE_HOME") -    case maybeXDGCacheHome of-        Nothing -> do-            homeDirectory <- Directory.getHomeDirectory+        case maybeXDGCacheHome of+            Just xdgCacheHome -> return xdgCacheHome+            Nothing           -> empty -            return (homeDirectory </> ".cache")+    alternative₁ = do+        maybeHomeDirectory <- liftIO (System.Environment.lookupEnv "HOME") -        Just xdgCacheHome -> do-            return xdgCacheHome-#endif+        case maybeHomeDirectory of+            Just homeDirectory -> return (homeDirectory </> ".cache")+            Nothing            -> empty  exprFromUncachedImport :: Import -> StateT (Status IO) IO (Expr Src Import) exprFromUncachedImport (Import {..}) = do@@ -715,34 +711,38 @@ -} loadWith :: MonadCatch m => Expr Src Import -> StateT (Status m) m (Expr Src X) loadWith expr₀ = case expr₀ of-  Embed import_ -> do+  Embed import₀ -> do     Status {..} <- State.get -    let imports = _stack+    let parent = NonEmpty.head _stack +    let import₁ = parent <> import₀++    let child = canonicalize import₁+     let local (Import (ImportHashed _ (Remote  {})) _) = False         local (Import (ImportHashed _ (Local   {})) _) = True         local (Import (ImportHashed _ (Env     {})) _) = True         local (Import (ImportHashed _ (Missing {})) _) = True -    let parent   = canonicalizeImport imports-    let imports' = NonEmpty.cons import_ imports-    let here     = canonicalizeImport imports'+    let referentiallySane = not (local child) || local parent -    if local here && not (local parent)-        then throwMissingImport (Imported imports (ReferentiallyOpaque import_))-        else return ()+    if referentiallySane+        then return ()+        else throwMissingImport (Imported _stack (ReferentiallyOpaque import₀)) -    expr <- if here `elem` canonicalizeAll imports-        then throwMissingImport (Imported imports (Cycle import_))+    let _stack' = NonEmpty.cons child _stack++    expr <- if child `elem` _stack+        then throwMissingImport (Imported _stack (Cycle import₀))         else do-            case Map.lookup here _cache of-                Just (hereNode, expr) -> do+            case Map.lookup child _cache of+                Just (childNode, expr) -> do                     zoom dot . State.modify $ \getDot -> do                         parentNode <- getDot -                        -- Add edge between parent and here-                        parentNode .->. hereNode+                        -- Add edge between parent and child+                        parentNode .->. childNode                          -- Return parent NodeId                         pure parentNode@@ -764,7 +764,7 @@                           throwM                             (MissingImports                                (map-                                 (\e -> toException (Imported imports' e))+                                 (\e -> toException (Imported _stack' e))                                  es                                )                              )@@ -774,39 +774,39 @@                             => SomeException                             -> StateT (Status m) m (Expr Src Import)                         handler₁ e =-                          throwMissingImport (Imported imports' e)+                          throwMissingImport (Imported _stack' e)                      -- This loads a \"dynamic\" expression (i.e. an expression                     -- that might still contain imports)-                    let loadDynamic = _resolver here+                    let loadDynamic = _resolver child                      expr' <- loadDynamic `catches` [ Handler handler₀, Handler handler₁ ] -                    let hereNodeId = userNodeId _nextNodeId+                    let childNodeId = userNodeId _nextNodeId                      -- Increment the next node id                     zoom nextNodeId $ State.modify succ                      -- Make current node the dot graph-                    zoom dot . State.put $ importNode hereNodeId here+                    zoom dot . State.put $ importNode childNodeId child -                    zoom stack (State.put imports')+                    zoom stack (State.put _stack')                     expr'' <- loadWith expr'-                    zoom stack (State.put imports)+                    zoom stack (State.put _stack)                      zoom dot . State.modify $ \getSubDot -> do                         parentNode <- _dot                          -- Get current node back from sub-graph-                        hereNode <- getSubDot+                        childNode <- getSubDot -                        -- Add edge between parent and here-                        parentNode .->. hereNode+                        -- Add edge between parent and child+                        parentNode .->. childNode                          -- Return parent NodeId                         pure parentNode -                    _cacher here expr''+                    _cacher child expr''                      -- Type-check expressions here for three separate reasons:                     --@@ -819,30 +819,40 @@                     -- There is no need to check expressions that have been                     -- cached, since they have already been checked                     expr''' <- case Dhall.TypeCheck.typeWith _startingContext expr'' of-                        Left  err -> throwM (Imported imports' err)+                        Left  err -> throwM (Imported _stack' err)                         Right _   -> return (Dhall.Core.normalizeWith (getReifiedNormalizer _normalizer) expr'')-                    zoom cache (State.modify' (Map.insert here (hereNodeId, expr''')))+                    zoom cache (State.modify' (Map.insert child (childNodeId, expr''')))                     return expr''' -    case hash (importHashed import_) of+    case hash (importHashed import₀) of         Nothing -> do             return ()         Just expectedHash -> do-            let actualHash =-                    hashExpression _standardVersion (Dhall.Core.alphaNormalize expr)+            let matches version =+                    let actualHash =+                            hashExpression version (Dhall.Core.alphaNormalize expr) -            if expectedHash == actualHash+                    in  expectedHash == actualHash++            if any matches [ minBound .. maxBound ]                 then return ()-                else throwMissingImport (Imported imports' (HashMismatch {..}))+                else do+                    let actualHash =+                            hashExpression NoVersion (Dhall.Core.alphaNormalize expr) +                    throwMissingImport (Imported _stack' (HashMismatch {..}))+     return expr   ImportAlt a b -> loadWith a `catch` handler₀     where-      handler₀ (MissingImports es₀) =-        loadWith b `catch` handler₁+      handler₀ (SourcedException (Src begin _ text₀) (MissingImports es₀)) =+          loadWith b `catch` handler₁         where-          handler₁ (MissingImports es₁) =-            throwM (MissingImports (es₀ ++ es₁))+          handler₁ (SourcedException (Src _ end text₁) (MissingImports es₁)) =+              throwM (SourcedException (Src begin end text₂) (MissingImports (es₀ ++ es₁)))+            where+              text₂ = text₀ <> " ? " <> text₁+    Const a              -> pure (Const a)   Var a                -> pure (Var a)   Lam a b c            -> Lam <$> pure a <*> loadWith b <*> loadWith c@@ -880,6 +890,7 @@   Text                 -> pure Text   TextLit (Chunks a b) -> fmap TextLit (Chunks <$> mapM (mapM loadWith) a <*> pure b)   TextAppend a b       -> TextAppend <$> loadWith a <*> loadWith b+  TextShow             -> pure TextShow   List                 -> pure List   ListLit a b          -> ListLit <$> mapM loadWith a <*> mapM loadWith b   ListAppend a b       -> ListAppend <$> loadWith a <*> loadWith b@@ -904,34 +915,46 @@   CombineTypes a b     -> CombineTypes <$> loadWith a <*> loadWith b   Prefer a b           -> Prefer <$> loadWith a <*> loadWith b   Merge a b c          -> Merge <$> loadWith a <*> loadWith b <*> mapM loadWith c-  Constructors a       -> Constructors <$> loadWith a   Field a b            -> Field <$> loadWith a <*> pure b   Project a b          -> Project <$> loadWith a <*> pure b-  Note a b             -> Note <$> pure a <*> loadWith b+  Note a b             -> do+      let handler e = throwM (SourcedException a (e :: MissingImports)) +      (Note <$> pure a <*> loadWith b) `catch` handler+ -- | Resolve all imports within an expression load :: Expr Src Import -> IO (Expr Src X) load expression = State.evalStateT (loadWith expression) (emptyStatus ".")  encodeExpression-    :: forall s . StandardVersion -> Expr s X -> Data.ByteString.ByteString+    :: forall s+    .  StandardVersion+    -- ^ `Nothing` means to encode without the version tag+    -> Expr s X+    -> Data.ByteString.ByteString encodeExpression _standardVersion expression = bytesStrict   where     intermediateExpression :: Expr s Import     intermediateExpression = fmap absurd expression      term :: Term-    term =-        Dhall.Binary.encodeWithVersion-            _standardVersion-            intermediateExpression+    term = Dhall.Binary.encode intermediateExpression -    bytesLazy = Codec.Serialise.serialise term+    taggedTerm :: Term+    taggedTerm =+        case _standardVersion of+            NoVersion -> term+            s         -> TList [ TString v, term ]+              where+                v = Dhall.Binary.renderStandardVersion s +    bytesLazy = Codec.Serialise.serialise taggedTerm+     bytesStrict = Data.ByteString.Lazy.toStrict bytesLazy  -- | Hash a fully resolved expression-hashExpression :: StandardVersion -> Expr s X -> (Crypto.Hash.Digest SHA256)+hashExpression+    :: StandardVersion -> Expr s X -> (Crypto.Hash.Digest SHA256) hashExpression _standardVersion expression =     Crypto.Hash.hash (encodeExpression _standardVersion expression)
src/Dhall/Import/HTTP.hs view
@@ -57,19 +57,19 @@       "\n"       <>  "\ESC[1;31mError\ESC[0m: Invalid remote host name\n"       <>  "\n"-      <>  "↳ " <> show host <> "\n"+      <>  "↳ " <> show host     ResponseTimeout ->       "\n"-      <>  "\ESC[1;31mError\ESC[0m: The remote host took too long to respond\n"+      <>  "\ESC[1;31mError\ESC[0m: The remote host took too long to respond"     StatusCodeException response _         | statusCode == 404 ->             "\n"-            <>  "\ESC[1;31mError\ESC[0m: Remote file not found\n"+            <>  "\ESC[1;31mError\ESC[0m: Remote file not found"         | otherwise ->             "\n"             <>  "\ESC[1;31mError\ESC[0m: Unexpected HTTP status code:\n"             <>  "\n"-            <>  "↳ " <> show statusCode <> "\n"+            <>  "↳ " <> show statusCode       where         statusCode =             Network.HTTP.Types.Status.statusCode
src/Dhall/Lint.hs view
@@ -3,12 +3,16 @@ module Dhall.Lint     ( -- * Lint       lint+    , removeLetInLet+    , removeUnusedBindings+    , optionalLitToSomeNone     ) where -import Dhall.Core (Binding(..), Chunks(..), Expr(..), Import, Var(..))-import Data.Semigroup ((<>))+import Control.Monad (mplus) import Data.List.NonEmpty (NonEmpty(..))-import Dhall.TypeCheck (X(..))+import Data.Semigroup ((<>))+import Dhall.Core (Binding(..), Expr(..), Import, Var(..), subExpressions)+import Lens.Family (ASetter, over)  import qualified Dhall.Core @@ -16,240 +20,49 @@      Currently this: -    * removes unused @let@ bindings-    * consolidates nested @let@ bindings to use a multiple-@let@ binding-    * switches legacy @List@-like @Optional@ literals to use @Some@ / @None@ instead-    * removes the `constructors` keyword+    * removes unused @let@ bindings with 'removeLetInLet'.+    * consolidates nested @let@ bindings to use a multiple-@let@ binding with 'removeUnusedBindings'.+    * switches legacy @List@-like @Optional@ literals to use @Some@ / @None@ instead with 'optionalLitToSomeNone' -} lint :: Expr s Import -> Expr t Import-lint expression = loop (Dhall.Core.denote expression)+lint =+  rewriteOf+    subExpressions+    ( \e ->+                removeLetInLet e+        `mplus` removeUnusedBindings e+        `mplus` optionalLitToSomeNone e+    )+    . Dhall.Core.denote++removeLetInLet :: Eq a => Expr s a -> Maybe (Expr s a)+removeLetInLet (Let a (Let b c)) = Just (Let (a <> b) c)+removeLetInLet _ = Nothing++removeUnusedBindings :: Eq a => Expr s a -> Maybe (Expr s a)+removeUnusedBindings (Let (Binding a _ _ :| []) d)+    | not (V a 0 `Dhall.Core.freeIn` d) =+        Just d+    | otherwise =+        Nothing+removeUnusedBindings (Let (Binding a _ _ :| (l : ls)) d)+    | not (V a 0 `Dhall.Core.freeIn` e) =+        Just e+    | otherwise =+        Nothing   where-    loop (Const a) =-        Const a-    loop (Var a) =-        Var a-    loop (Lam a b c) = Lam a b' c'-      where-        b' = loop b-        c' = loop c-    loop (Pi a b c) = Pi a b' c'-      where-        b' = loop b-        c' = loop c-    loop (App a b) = App a' b'-      where-        a' = loop a-        b' = loop b+    e = Let (l :| ls) d+removeUnusedBindings _ = Nothing -    -- Consolidate nested `let` expresssions-    loop (Let a (Let b c)) = loop (Let (a <> b) c) -    -- Remove unused bindings-    loop (Let (Binding a b c :| []) d)-        | not (V a 0 `Dhall.Core.freeIn` d') =-            d'-        | otherwise =-            Let (Binding a b' c' :| [])  d'-      where-        b' = fmap loop b-        c' =      loop c+optionalLitToSomeNone :: Expr s a -> Maybe (Expr s a)+optionalLitToSomeNone (OptionalLit _ (Just b)) = Just (Some b)+optionalLitToSomeNone (OptionalLit a Nothing) = Just (App None a)+optionalLitToSomeNone _ = Nothing -        d' = loop d-    loop (Let (Binding a b c :| (l : ls)) d)-        | not (V a 0 `Dhall.Core.freeIn` Let (l' :| ls') d') =-            Let (l' :| ls') d'-        | otherwise =-            Let (Binding a b' c' :| (l' : ls'))  d'-      where-        b' = fmap loop b-        c' =      loop c -        Let (l' :| ls') d' = loop (Let (l :| ls) d)+rewriteOf :: ASetter a b a b -> (b -> Maybe a) -> a -> b+rewriteOf l f = go where go = transformOf l (\x -> maybe x go (f x)) -    loop (Annot a b) =-        Annot a' b'-      where-        a' = loop a-        b' = loop b-    loop Bool =-        Bool-    loop (BoolLit a) =-        BoolLit a-    loop (BoolAnd a b) =-        BoolAnd a' b'-      where-        a' = loop a-        b' = loop b-    loop (BoolOr a b) =-        BoolOr a' b'-      where-        a' = loop a-        b' = loop b-    loop (BoolEQ a b) =-        BoolEQ a' b'-      where-        a' = loop a-        b' = loop b-    loop (BoolNE a b) =-        BoolNE a' b'-      where-        a' = loop a-        b' = loop b-    loop (BoolIf a b c) =-        BoolIf a' b' c'-      where-        a' = loop a-        b' = loop b-        c' = loop c-    loop Natural =-        Natural-    loop (NaturalLit a) =-        NaturalLit a-    loop NaturalFold =-        NaturalFold-    loop NaturalBuild =-        NaturalBuild-    loop NaturalIsZero =-        NaturalIsZero-    loop NaturalEven =-        NaturalEven-    loop NaturalOdd =-        NaturalOdd-    loop NaturalToInteger =-        NaturalToInteger-    loop NaturalShow =-        NaturalShow-    loop (NaturalPlus a b) =-        NaturalPlus a' b'-      where-        a' = loop a-        b' = loop b-    loop (NaturalTimes a b) =-        NaturalTimes a' b'-      where-        a' = loop a-        b' = loop b-    loop Integer =-        Integer-    loop (IntegerLit a) =-        IntegerLit a-    loop IntegerShow =-        IntegerShow-    loop IntegerToDouble =-        IntegerToDouble-    loop Double =-        Double-    loop (DoubleLit a) =-        DoubleLit a-    loop DoubleShow =-        DoubleShow-    loop Text =-        Text-    loop (TextLit (Chunks a b)) =-        TextLit (Chunks a' b)-      where-        a' = fmap (fmap loop) a-    loop (TextAppend a b) =-        TextAppend a' b'-      where-        a' = loop a-        b' = loop b-    loop List =-        List-    loop (ListLit a b) =-        ListLit a' b'-      where-        a' = fmap loop a-        b' = fmap loop b-    loop (ListAppend a b) =-        ListAppend a' b'-      where-        a' = loop a-        b' = loop b-    loop ListBuild =-        ListBuild-    loop ListFold =-        ListFold-    loop ListLength =-        ListLength-    loop ListHead =-        ListHead-    loop ListLast =-        ListLast-    loop ListIndexed =-        ListIndexed-    loop ListReverse =-        ListReverse-    loop Optional =-        Optional-    loop (Some a) =-        Some a'-      where-        a' = loop a-    loop None =-        None-    loop (OptionalLit _ (Just b)) =-        loop (Some b)-    loop (OptionalLit a Nothing) =-        loop (App None a)-    loop OptionalFold =-        OptionalFold-    loop OptionalBuild =-        OptionalBuild-    loop (Record a) =-        Record a'-      where-        a' = fmap loop a-    loop (RecordLit a) =-        RecordLit a'-      where-        a' = fmap loop a-    loop (Union a) =-        Union a'-      where-        a' = fmap loop a-    loop (UnionLit a b c) =-        UnionLit a b' c'-      where-        b' =      loop b-        c' = fmap loop c-    loop (Combine a b) =-        Combine a' b'-      where-        a' = loop a-        b' = loop b-    loop (CombineTypes a b) =-        CombineTypes a' b'-      where-        a' = loop a-        b' = loop b-    loop (Prefer a b) =-        Prefer a' b'-      where-        a' = loop a-        b' = loop b-    loop (Merge a b c) =-        Merge a' b' c'-      where-        a' =      loop a-        b' =      loop b-        c' = fmap loop c-    loop (Constructors a) =-        loop a-    loop (Field a b) =-        Field a' b-      where-        a' = loop a-    loop (Project a b) =-        Project a' b-      where-        a' = loop a-    loop (Note a _) =-        absurd a-    loop (ImportAlt a b) =-        ImportAlt a' b'-      where-        a' = loop a-        b' = loop b-    loop (Embed a) =-        Embed a+transformOf :: ASetter a b a b -> (b -> b) -> a -> b+transformOf l f = go where go = f . over l go
src/Dhall/Main.hs view
@@ -70,6 +70,7 @@ import qualified System.Console.ANSI import qualified System.IO import qualified Text.Dot+import qualified Data.Map  -- | Top-level program options data Options = Options@@ -84,18 +85,24 @@ data Mode     = Default { annotate :: Bool }     | Version-    | Resolve { dot :: Bool }+    | Resolve { resolveMode :: Maybe ResolveMode }     | Type     | Normalize     | Repl-    | Format { inplace :: Maybe FilePath }-    | Freeze { inplace :: Maybe FilePath }+    | Format { formatMode :: Dhall.Format.FormatMode }+    | Freeze { inplace :: Maybe FilePath, all_ :: Bool }     | Hash     | Diff { expr1 :: Text, expr2 :: Text }     | Lint { inplace :: Maybe FilePath }     | Encode { json :: Bool }     | Decode { json :: Bool } +data ResolveMode+    = Dot+    | ListTransitiveDependencies+    | ListImmediateDependencies++ -- | `Parser` for the `Options` type parseOptions :: Parser Options parseOptions =@@ -134,7 +141,7 @@     <|> subcommand             "resolve"             "Resolve an expression's imports"-            (Resolve <$> parseDot)+            (Resolve <$> parseResolveMode)     <|> subcommand             "type"             "Infer an expression's type"@@ -162,11 +169,11 @@     <|> subcommand             "format"             "Formatter for the Dhall language"-            (Format <$> optional parseInplace)+            (Format <$> parseFormatMode)     <|> subcommand             "freeze"-            "Add hashes to all import statements of an expression"-            (Freeze <$> optional parseInplace)+            "Add integrity checks to remote import statements of an expression"+            (Freeze <$> optional parseInplace <*> parseAllFlag)     <|> subcommand             "encode"             "Encode a Dhall expression to binary"@@ -186,12 +193,25 @@         Options.Applicative.switch             (Options.Applicative.long "annotate") -    parseDot =-        Options.Applicative.switch-        (   Options.Applicative.long "dot"-        <>  Options.Applicative.help-              "Output import dependency graph in dot format"-        )+    parseResolveMode =+          Options.Applicative.flag' (Just Dot)+              (   Options.Applicative.long "dot"+              <>  Options.Applicative.help+                    "Output import dependency graph in dot format"+              )+        <|>+          Options.Applicative.flag' (Just ListImmediateDependencies)+              (   Options.Applicative.long "immediate-dependencies"+              <>  Options.Applicative.help+                    "List immediate import dependencies"+              )+        <|>+          Options.Applicative.flag' (Just ListTransitiveDependencies)+              (   Options.Applicative.long "transitive-dependencies"+              <>  Options.Applicative.help+                    "List transitive import dependencies"+              )+        <|> pure Nothing      parseInplace =         Options.Applicative.strOption@@ -206,6 +226,23 @@         <>  Options.Applicative.help "Use JSON representation of CBOR"         ) +    parseAllFlag =+        Options.Applicative.switch+        (   Options.Applicative.long "all"+        <>  Options.Applicative.help "Add integrity checks to all imports (not just remote imports)"+        )++    parseCheck =+        Options.Applicative.switch+        (   Options.Applicative.long "check"+        <>  Options.Applicative.help "Only check if the input is formatted"+        )++    parseFormatMode = adapt <$> parseCheck <*> optional parseInplace+      where+        adapt True  path    = Dhall.Format.Check {..}+        adapt False inplace = Dhall.Format.Modify {..}+ throws :: Exception e => Either e a -> IO a throws (Left  e) = Control.Exception.throwIO e throws (Right a) = return a@@ -262,8 +299,12 @@                         Control.Exception.throwIO (Imported ps e)              handler2 e = do-                let _ = e :: SomeException-                System.IO.hPrint System.IO.stderr e+                let string = show (e :: SomeException)++                if not (null string)+                    then System.IO.hPutStrLn System.IO.stderr string+                    else return ()+                 System.Exit.exitFailure      let renderDoc :: Handle -> Doc Ann -> IO ()@@ -287,8 +328,15 @@      handle $ case mode of         Version -> do-            putStrLn (showVersion Meta.version)+            let line₀ = "Haskell package version: "+                    <>  Data.Text.pack (showVersion Meta.version) +            let line₁ = "Standard version: "+                    <>  Dhall.Binary.renderStandardVersion Dhall.Binary.defaultStandardVersion++            Data.Text.IO.putStrLn line₀+            Data.Text.IO.putStrLn line₁+         Default {..} -> do             expression <- getExpression @@ -305,17 +353,43 @@              render System.IO.stdout annotatedExpression -        Resolve dot -> do+        Resolve (Just Dot) -> do             expression <- getExpression -            (resolvedExpression, Dhall.Import.Types.Status { _dot }) <--                State.runStateT (Dhall.Import.loadWith expression) status+            (Dhall.Import.Types.Status { _dot}) <-+                State.execStateT (Dhall.Import.loadWith expression) status -            if   dot-            then putStr . ("strict " <>) . Text.Dot.showDot $-                 Text.Dot.attribute ("rankdir", "LR") >> _dot-            else render System.IO.stdout resolvedExpression+            putStr . ("strict " <>) . Text.Dot.showDot $+                   Text.Dot.attribute ("rankdir", "LR") >>+                   _dot +        Resolve (Just ListImmediateDependencies) -> do+            expression <- getExpression++            mapM_ (print+                        . Pretty.pretty+                        . Dhall.Core.importHashed) expression++        Resolve (Just ListTransitiveDependencies) -> do+            expression <- getExpression++            (Dhall.Import.Types.Status { _cache }) <-+                State.execStateT (Dhall.Import.loadWith expression) status++            mapM_ print+                 .   fmap (   Pretty.pretty+                          .   Dhall.Core.importType+                          .   Dhall.Core.importHashed )+                 .   Data.Map.keys+                 $   _cache++        Resolve (Nothing) -> do+            expression <- getExpression++            (resolvedExpression, _) <-+                State.runStateT (Dhall.Import.loadWith expression) status+            render System.IO.stdout resolvedExpression+         Normalize -> do             expression <- getExpression @@ -347,10 +421,10 @@             renderDoc System.IO.stdout diff          Format {..} -> do-            Dhall.Format.format characterSet inplace+            Dhall.Format.format (Dhall.Format.Format {..})          Freeze {..} -> do-            Dhall.Freeze.freeze inplace standardVersion+            Dhall.Freeze.freeze inplace all_ standardVersion          Hash -> do             Dhall.Hash.hash standardVersion@@ -385,7 +459,7 @@         Encode {..} -> do             expression <- getExpression -            let term = Dhall.Binary.encodeWithVersion standardVersion expression+            let term = Dhall.Binary.encode expression              let bytes = Codec.Serialise.serialise term @@ -419,7 +493,7 @@                     else do                         throws (Codec.Serialise.deserialiseOrFail bytes) -            expression <- throws (Dhall.Binary.decodeWithVersion term)+            expression <- throws (Dhall.Binary.decode term)              let doc = Dhall.Pretty.prettyCharacterSet characterSet expression
src/Dhall/Parser.hs view
@@ -12,6 +12,7 @@      -- * Types     , Src(..)+    , SourcedException(..)     , ParseError(..)     , Parser(..)     ) where
src/Dhall/Parser/Combinators.hs view
@@ -1,4 +1,5 @@ {-# LANGUAGE CPP                        #-}+{-# LANGUAGE DeriveAnyClass             #-} {-# LANGUAGE DeriveDataTypeable         #-} {-# LANGUAGE MultiParamTypeClasses      #-} {-# LANGUAGE OverloadedStrings          #-}@@ -6,6 +7,7 @@   import           Control.Applicative        (Alternative (..), liftA2)+import           Control.Exception          (Exception) import           Control.Monad              (MonadPlus (..)) import           Data.Data                  (Data) import           Data.Semigroup             (Semigroup (..))@@ -25,7 +27,10 @@ import qualified Data.Sequence import qualified Data.Set import qualified Data.Text+import qualified Data.Text.Prettyprint.Doc               as Pretty+import qualified Data.Text.Prettyprint.Doc.Render.String as Pretty import qualified Dhall.Map+import qualified Dhall.Pretty import qualified Dhall.Util import qualified Dhall.Set import qualified Text.Megaparsec@@ -38,6 +43,18 @@ data Src = Src !Text.Megaparsec.SourcePos !Text.Megaparsec.SourcePos Text   -- Text field is intentionally lazy   deriving (Data, Eq, Show)++data SourcedException e = SourcedException Src e++instance Exception e => Exception (SourcedException e)++instance Show e => Show (SourcedException e) where+    show (SourcedException source exception) =+            show exception+        <>  "\n"+        <>  "\n"+        <>  Pretty.renderString+                (Pretty.layoutPretty Dhall.Pretty.layoutOpts (pretty source))  -- | Doesn't force the 'Text' part laxSrcEq :: Src -> Src -> Bool
src/Dhall/Parser/Expression.hs view
@@ -134,8 +134,9 @@                     case (shallowDenote a, shallowDenote b) of                         (ListLit _ xs, App f c) ->                             case shallowDenote f of-                                List     ->-                                    return (ListLit (Just c) xs)+                                List     -> case xs of+                                    [] -> return (ListLit (Just c) xs)+                                    _  -> return (Annot a b)                                 Optional -> case xs of                                     [x] -> return (OptionalLit c (Just x))                                     []  -> return (OptionalLit c Nothing)@@ -175,9 +176,9 @@                 CombineTypes <$ _combineTypes             <|> Prefer       <$ _prefer             <|> NaturalTimes <$ _times-            <|> BoolNE       <$ _notEqual+            <|> BoolEQ       <$ _doubleEqual -    precedence3Operator = BoolEQ <$ _doubleEqual+    precedence3Operator = BoolNE <$ _notEqual      precedence0Expression =             makeOperatorExpression precedence1Expression precedence0Operator@@ -192,8 +193,7 @@             makeOperatorExpression applicationExpression precedence3Operator      applicationExpression = do-            f <-    (do _constructors; return Constructors)-                <|> (do _Some; return Some)+            f <-    (do _Some; return Some)                 <|> return id             a <- noted importExpression             b <- Text.Megaparsec.many (noted importExpression)@@ -346,7 +346,8 @@                     'S' ->    Const Sort       <$ _Sort                     'T' ->                         choice-                            [ Text             <$ _Text+                            [ TextShow         <$ _TextShow+                            , Text             <$ _Text                             , BoolLit True     <$ _True                             , Const Type       <$ _Type                             ]
src/Dhall/Parser/Token.hs view
@@ -53,6 +53,7 @@     _Integer,     _Double,     _Text,+    _TextShow,     _List,     _True,     _False,@@ -110,6 +111,7 @@ import qualified Data.Text import qualified Dhall.Set import qualified Text.Megaparsec+import qualified Text.Megaparsec.Char.Lexer import qualified Text.Parser.Char import qualified Text.Parser.Combinators @@ -159,13 +161,15 @@ integerLiteral :: Parser Integer integerLiteral = (do     sign <- signPrefix-    a <- Text.Parser.Token.natural+    a <- Text.Megaparsec.Char.Lexer.decimal+    whitespace     return (sign a) ) <?> "integer literal"  naturalLiteral :: Parser Natural naturalLiteral = (do-    a <- Text.Parser.Token.natural-    return (fromIntegral a) ) <?> "natural literal"+    a <- Text.Megaparsec.Char.Lexer.decimal+    whitespace+    return a ) <?> "natural literal"  identifier :: Parser Var identifier = do@@ -173,7 +177,9 @@      let indexed = do             _ <- Text.Parser.Char.char '@'-            Text.Parser.Token.natural+            n <- Text.Megaparsec.Char.Lexer.decimal+            whitespace+            return n      n <- indexed <|> pure 0     return (V x n)@@ -330,7 +336,7 @@ quotedPathCharacter c =         ('\x20' <= c && c <= '\x21')     ||  ('\x23' <= c && c <= '\x2E')-    ||  ('\x30' <= c && c <= '\x7E')+    ||  ('\x30' <= c && c <= '\x10FFFF')  pathComponent :: Parser Text pathComponent = do@@ -620,6 +626,9 @@  _Text :: Parser () _Text = reserved "Text"++_TextShow :: Parser ()+_TextShow = reserved "Text/show"  _List :: Parser () _List = reserved "List"
src/Dhall/Pretty/Internal.hs view
@@ -195,13 +195,31 @@  -- | Pretty-print anonymous functions and function types arrows :: CharacterSet -> [(Doc Ann, Doc Ann)] -> Doc Ann-arrows characterSet =+arrows ASCII =     enclose'         ""+        "    "+        (" " <> rarrow ASCII <> " ")+        (rarrow ASCII <> "  ")+arrows Unicode =+    enclose'+        ""         "  "-        (" " <> rarrow characterSet <> " ")-        (rarrow characterSet <> space)+        (" " <> rarrow Unicode <> " ")+        (rarrow Unicode <> " ") +combine :: CharacterSet -> Text+combine ASCII   = "/\\"+combine Unicode = "∧"++combineTypes :: CharacterSet -> Text+combineTypes ASCII   = "//\\\\"+combineTypes Unicode = "⩓"++prefer :: CharacterSet -> Text+prefer ASCII   = "//"+prefer Unicode = "⫽"+ {-| Format an expression that holds a variable number of elements, such as a     list, record, or union -}@@ -612,7 +630,7 @@      prettyCombineExpression :: Pretty a => Expr s a -> Doc Ann     prettyCombineExpression a0@(Combine _ _) =-        prettyOperator "∧" (docs a0)+        prettyOperator (combine characterSet) (docs a0)       where         docs (Combine a b) = prettyPreferExpression b : docs a         docs (Note    _ b) = docs b@@ -624,7 +642,7 @@      prettyPreferExpression :: Pretty a => Expr s a -> Doc Ann     prettyPreferExpression a0@(Prefer _ _) =-        prettyOperator "⫽" (docs a0)+        prettyOperator (prefer characterSet) (docs a0)       where         docs (Prefer a b) = prettyCombineTypesExpression b : docs a         docs (Note   _ b) = docs b@@ -636,7 +654,7 @@      prettyCombineTypesExpression :: Pretty a => Expr s a -> Doc Ann     prettyCombineTypesExpression a0@(CombineTypes _ _) =-        prettyOperator "⩓" (docs a0)+        prettyOperator (combineTypes characterSet) (docs a0)       where         docs (CombineTypes a b) = prettyTimesExpression b : docs a         docs (Note         _ b) = docs b@@ -684,19 +702,17 @@      prettyApplicationExpression :: Pretty a => Expr s a -> Doc Ann     prettyApplicationExpression a0 = case a0 of-        App _ _        -> result-        Constructors _ -> result-        Some _         -> result-        Note _ b       -> prettyApplicationExpression b-        _              -> prettyImportExpression a0+        App _ _  -> result+        Some _   -> result+        Note _ b -> prettyApplicationExpression b+        _        -> prettyImportExpression a0       where         result = enclose' "" "" " " "" (fmap duplicate (reverse (docs a0))) -        docs (App        a b) = prettyImportExpression b : docs a-        docs (Constructors b) = [ prettyImportExpression b , keyword "constructors" ]-        docs (Some         a) = [ prettyImportExpression a , builtin "Some"         ]-        docs (Note       _ b) = docs b-        docs               b  = [ prettyImportExpression b ]+        docs (App  a b) = prettyImportExpression b : docs a+        docs (Some   a) = [ prettyImportExpression a , builtin "Some"         ]+        docs (Note _ b) = docs b+        docs         b  = [ prettyImportExpression b ]      prettyImportExpression :: Pretty a => Expr s a -> Doc Ann     prettyImportExpression (Embed a) =@@ -751,6 +767,8 @@         builtin "Double/show"     prettyPrimitiveExpression Text =         builtin "Text"+    prettyPrimitiveExpression TextShow =+        builtin "Text/show"     prettyPrimitiveExpression List =         builtin "List"     prettyPrimitiveExpression ListBuild =
src/Dhall/Repl.hs view
@@ -11,24 +11,29 @@     ) where  import Control.Exception ( SomeException(SomeException), displayException, throwIO )+import Control.Monad ( forM_ ) import Control.Monad.IO.Class ( MonadIO, liftIO ) import Control.Monad.State.Class ( MonadState, get, modify ) import Control.Monad.State.Strict ( evalStateT )-import Data.List ( elemIndex, isPrefixOf, nub )+import Data.List ( isPrefixOf, nub ) import Data.List.NonEmpty (NonEmpty(..))+import Data.Maybe ( mapMaybe ) import Data.Semigroup ((<>))+import Data.Text ( Text ) import Dhall.Binary (StandardVersion(..)) import Dhall.Context (Context)-import Dhall.Import (standardVersion)+import Dhall.Import (hashExpressionToCode, standardVersion) import Dhall.Pretty (CharacterSet(..)) import Lens.Family (set) import System.Console.Haskeline (Interrupt(..)) import System.Console.Haskeline.Completion ( Completion, simpleCompletion )+import System.Directory ( getDirectoryContents ) import System.Environment ( getEnvironment )  import qualified Control.Monad.Trans.State.Strict as State import qualified Data.HashSet import qualified Data.Text as Text+import qualified Data.Text.IO as Text.IO import qualified Data.Text.Prettyprint.Doc as Pretty import qualified Data.Text.Prettyprint.Doc.Render.Terminal as Pretty ( renderIO ) import qualified Dhall@@ -74,6 +79,7 @@   , explain          :: Bool   , characterSet     :: CharacterSet   , _standardVersion :: StandardVersion+  , outputHandle     :: Maybe System.IO.Handle   }  @@ -85,6 +91,7 @@     , explain = False     , _standardVersion = Dhall.Binary.defaultStandardVersion     , characterSet = Unicode+    , outputHandle = Just System.IO.stdout     }  @@ -138,14 +145,12 @@    modify ( \e -> e { envIt = Just ( Binding expr exprType ) } ) -  output System.IO.stdout expr+  output expr    typeOf :: ( MonadIO m, MonadState Env m ) => [String] -> m ()-typeOf [] =-  liftIO ( putStrLn ":type requires an argument to check the type of" )-+typeOf [] = fail ":type requires an argument to check the type of"  typeOf srcs = do   loaded <-@@ -157,7 +162,7 @@   exprType' <-     normalize exprType -  output System.IO.stdout exprType'+  output exprType'   applyContext@@ -202,20 +207,15 @@ -- Separate the equal sign to be its own word in order to simplify parsing -- This is intended to be used with the options that require assignment separateEqual :: [String] -> [String]-separateEqual [] = []-separateEqual (x:xs)-  -- Handle the case where there is no space between the var and "="-  | Just i <- elemIndex '=' x-  = let (a, _:b) = splitAt i x-    in  a : "=" : b : xs--  -- Handle the case where there is no space between the "=" and the expression-  | ('=':y):ys <- xs-  = x : "=" : y : ys--  | otherwise-  = x : xs-+separateEqual [] =+    []+separateEqual (str₀ : ('=' : str₁) : strs) =+    str₀ : "=" : str₁ : strs+separateEqual (str : strs)+    | (str₀, '=' : str₁) <- break (== '=') str =+        str₀ : "=" : str₁ : strs+    | otherwise =+        str : strs  addBinding :: ( MonadIO m, MonadState Env m ) => [String] -> m () addBinding (k : "=" : srcs) = do@@ -243,14 +243,125 @@           }     ) -  output-    System.IO.stdout-    ( Expr.Annot ( Expr.Var ( Dhall.V varName 0 ) ) t )+  output ( Expr.Annot ( Expr.Var ( Dhall.V varName 0 ) ) t ) -addBinding _ =-  liftIO ( fail ":let should be of the form `:let x = y`" )+addBinding _ = fail ":let should be of the form `:let x = y`" +hashBinding :: ( MonadIO m, MonadState Env m ) => [String] -> m ()+hashBinding [] = fail ":hash should be of the form `:hash expr"+hashBinding tokens = do+  loadedExpression <- parseAndLoad (unwords tokens)++  _ <- typeCheck loadedExpression++  normalizedExpression <- normalize loadedExpression++  Env{_standardVersion} <- get++  writeOutputHandle $ hashExpressionToCode _standardVersion normalizedExpression++saveFilePrefix :: FilePath+saveFilePrefix = ".dhall-repl"++-- | Find the index for the current _active_ dhall save file+currentSaveFileIndex :: MonadIO m => m (Maybe Int)+currentSaveFileIndex = do+  files <- liftIO $ getDirectoryContents "."++  let parseIndex file+        | saveFilePrefix `isPrefixOf` file+        , '-':index <- drop (length saveFilePrefix) file+        , [(x, "")] <- reads index -- safe version of read+        = Just x++        | otherwise+        = Nothing++  pure $ case mapMaybe parseIndex files of+    [] -> Nothing+    xs -> Just $ maximum xs++-- | Find the name for the current _active_ dhall save file+currentSaveFile :: MonadIO m => m (Maybe FilePath)+currentSaveFile =+  (fmap . fmap) (\i -> saveFilePrefix <> "-" <> show i) currentSaveFileIndex++-- | Find the name for the next dhall save file+nextSaveFile :: MonadIO m => m FilePath+nextSaveFile = do+  mIndex <- currentSaveFileIndex++  let nextIndex = maybe 0 succ mIndex++  pure $ saveFilePrefix <> "-" <> show nextIndex++loadBinding+  :: ( MonadIO m, MonadState Env m, Haskeline.MonadException m )+  => [String] -> m ()+loadBinding [] = do+  mFile <- currentSaveFile++  case mFile of+    Just file -> loadBinding [file]+    Nothing   ->+      fail $ ":load couldn't find any `" <> saveFilePrefix <> "-*` files"++loadBinding [file] = do+  -- Read commands from the save file+  replLines <- map words . lines <$> liftIO (readFile file)++  let runCommand ((c:cmd):opts)+        | c == optionsPrefix+        , Just action <- lookup cmd options+        = action opts+      runCommand _ = fail $+        ":load expects `" <> file <> "` to contain one command per line"++  -- Keep current handle in scope+  Env { outputHandle } <- get++  -- Discard output+  modify (\e -> e { outputHandle = Nothing })++  -- Run all the commands+  forM_ replLines runCommand++  -- Restore the previous handle+  modify (\e -> e { outputHandle = outputHandle })++  writeOutputHandle $ "Loaded `" <> Text.pack file <> "`\n"++loadBinding _ = fail ":load should be of the form `:load` or `:load file`"+ saveBinding :: ( MonadIO m, MonadState Env m ) => [String] -> m ()+-- Save all the bindings into a context save file+saveBinding [] = do+  file <- nextSaveFile++  saveBinding [file]++-- Save all the bindings into `file`+saveBinding [file] = do+  env <- get++  let bindings+        = reverse+        . (fmap . fmap) bindingExpr+        . Dhall.Context.toList+        $ envBindings env++      handler handle =+          State.evalStateT+            (forM_ bindings $ \(name, expr) -> do+              liftIO (System.IO.hPutStr handle $ ":let " <> Text.unpack name <> " = ")+              outputWithoutSpacing expr)+            (env { outputHandle = Just handle })++  liftIO (System.IO.withFile file System.IO.WriteMode handler)++  writeOutputHandle $ "Context saved to `" <> Text.pack file <> "`\n"++-- Save a single expression to `file` saveBinding (file : "=" : tokens) = do   loadedExpression <- parseAndLoad (unwords tokens) @@ -261,11 +372,28 @@   env <- get    let handler handle =-          State.evalStateT (output handle normalizedExpression) env+          State.evalStateT+            (output normalizedExpression)+            (env { outputHandle = Just handle })    liftIO (System.IO.withFile file System.IO.WriteMode handler)-saveBinding _ = fail ":save should be of the form `:save x = y`" +  writeOutputHandle $ "Expression saved to `" <> Text.pack file <> "`\n"++saveBinding _ = fail ":save should be of the form `:save`, `:save file`, or `:save file = expr`"++setOption :: ( MonadIO m, MonadState Env m ) => [String] -> m ()+setOption [ "--explain" ] = do+  modify (\e -> e { explain = True })+setOption _ = do+  writeOutputHandle ":set should be of the form `:set <command line option>`"++unsetOption :: ( MonadIO m, MonadState Env m ) => [String] -> m ()+unsetOption [ "--explain" ] = do+  modify (\e -> e { explain = False })+unsetOption _ = do+  writeOutputHandle ":unset should be of the form `:unset <command line option>`"+ cmdQuit :: ( MonadIO m, MonadState Env m ) => [String] -> m () cmdQuit _ = do   liftIO (putStrLn "Goodbye.")@@ -281,8 +409,12 @@   => Repline.Options m options =   [ ( "type", dontCrash . typeOf )+  , ( "hash", dontCrash . hashBinding )   , ( "let", dontCrash . addBinding . separateEqual )+  , ( "load", dontCrash . loadBinding )   , ( "save", dontCrash . saveBinding . separateEqual )+  , ( "set", dontCrash . setOption)+  , ( "unset", dontCrash . unsetOption)   , ( "quit", cmdQuit )   ] @@ -309,6 +441,10 @@   | reversedPrev == ":"   = pure . listCompletion $ fst <$> (options :: Repline.Options Repl) +  -- Complete load command+  | reversedPrev == reverse ":load "+  = Haskeline.listFiles word+   -- Complete file paths   | any (`isPrefixOf` word) [ "/", "./", "../", "~/" ]   = Haskeline.listFiles word@@ -318,12 +454,11 @@   = listCompletion . fmap fst <$> liftIO getEnvironment    -- Complete record fields and union alternatives-  | '.' `elem` word+  | var : subFields <- Text.split (== '.') (Text.pack word)+  , not $ null subFields   = do     Env { envBindings } <- get -    let var:subFields = Text.split (== '.') (Text.pack word)-     case Dhall.Context.lookup var 0 envBindings of        Nothing -> pure []@@ -378,26 +513,42 @@     m     ( \ e@SomeException{} -> liftIO ( putStrLn ( displayException e ) ) ) +writeOutputHandle :: (MonadIO m, MonadState Env m) => Text -> m ()+writeOutputHandle txt = do+  Env { outputHandle } <- get +  case outputHandle of+    Just handle -> liftIO $ Text.IO.hPutStrLn handle txt+    Nothing     -> pure ()+ output-    :: (Pretty.Pretty a, MonadState Env m, MonadIO m)-    => System.IO.Handle -> Dhall.Expr s a -> m ()-output handle expr = do-  Env { characterSet } <- get+  :: (Pretty.Pretty a, MonadState Env m, MonadIO m)+  => Dhall.Expr s a -> m ()+output expr = do+  writeOutputHandle "" -- Visual spacing -  liftIO (System.IO.hPutStrLn handle "")  -- Visual spacing+  outputWithoutSpacing expr -  let stream =-          Pretty.layoutSmart Dhall.Pretty.layoutOpts-              (Dhall.Pretty.prettyCharacterSet characterSet expr)+  writeOutputHandle "" -- Visual spacing -  supportsANSI <- liftIO (System.Console.ANSI.hSupportsANSI handle)-  let ansiStream =-          if supportsANSI-          then fmap Dhall.Pretty.annToAnsiStyle stream-          else Pretty.unAnnotateS stream+outputWithoutSpacing+  :: (Pretty.Pretty a, MonadState Env m, MonadIO m)+  => Dhall.Expr s a -> m ()+outputWithoutSpacing expr = do+  Env { characterSet, outputHandle } <- get -  liftIO (Pretty.renderIO handle ansiStream)-  liftIO (System.IO.hPutStrLn handle "") -- Pretty printing doesn't end with a new line+  case outputHandle of+    Nothing     -> pure ()+    Just handle -> do+      let stream =+              Pretty.layoutSmart Dhall.Pretty.layoutOpts+                  (Dhall.Pretty.prettyCharacterSet characterSet expr) -  liftIO (System.IO.hPutStrLn handle "")  -- Visual spacing+      supportsANSI <- liftIO (System.Console.ANSI.hSupportsANSI handle)+      let ansiStream =+              if supportsANSI+              then fmap Dhall.Pretty.annToAnsiStyle stream+              else Pretty.unAnnotateS stream++      liftIO (Pretty.renderIO handle ansiStream)+      liftIO (System.IO.hPutStrLn handle "") -- Pretty printing doesn't end with a new line
src/Dhall/Tutorial.hs view
@@ -426,6 +426,7 @@ --   ↳ ./file2 -- ... -- Cyclic import: ./file1+-- ... -- -- You can also import expressions by URL.  For example, you can find a Dhall -- expression hosted at this GitHub URL:@@ -476,7 +477,7 @@ -- *** Exception:  -- ↳ ./baz:  -- ...--- ...Error...: Missing file .../baz:+-- ...Error...: Missing file ...baz: -- ... -- -- This is because the parser thinks that @./baz:@ is a single token due to@@ -1143,48 +1144,28 @@ -- -- > data Example = Empty | Person { name :: Text, age :: Text } ----- You can resemble Haskell further by defining convenient constructors for each--- alternative, like this:+-- You could resemble Haskell further by defining convenient constructors for+-- each alternative, like this: ----- >     let Empty  = < Empty = {=} | Person : { name : Text, age : Natural } >--- > in  let Person =--- >         λ(p : { name : Text, age : Natural }) → < Person = p | Empty : {} >+-- > let Empty  = < Empty = {=} | Person : { name : Text, age : Natural } >+-- > let Person =+-- >       λ(p : { name : Text, age : Natural }) → < Person = p | Empty : {} > -- > in  [   Empty -- >     ,   Person { name = "John", age = 23 } -- >     ,   Person { name = "Amy" , age = 25 } -- >     ,   Empty -- >     ] ----- ... and Dhall even provides the @constructors@ keyword to automate this--- common pattern:+-- ... but there is no need to do so, since the Dhall language auto-generates+-- constructors for each alternative.  You can access each constructor as if it+-- were a field of the union type: ----- >     let MyType = constructors < Empty : {} | Person : { name : Text, age : Natural } >+-- > let MyType = < Empty : {} | Person : { name : Text, age : Natural } > -- > in  [   MyType.Empty {=} -- >     ,   MyType.Person { name = "John", age = 23 } -- >     ,   MyType.Person { name = "Amy" , age = 25 } -- >     ] ----- The @constructors@ keyword takes a union type argument and returns a record--- with one field per union type constructor:------ > $ dhall--- > constructors < Empty : {} | Person : { name : Text, age : Natural } >--- > <Ctrl-D>--- >--- > { Empty  :--- >     ∀(Empty : {}) → < Empty : {} | Person : { age : Natural, name : Text } >--- > , Person :--- >       ∀(Person : { age : Natural, name : Text })--- >     → < Empty : {} | Person : { age : Natural, name : Text } >--- > }--- >--- > { Empty  =--- >     λ(Empty : {}) → < Empty = Empty | Person : { age : Natural, name : Text } >--- > , Person =--- >       λ(Person : { age : Natural, name : Text })--- >     → < Person = Person | Empty : {} >--- > }--- -- You can also extract fields during pattern matching such as in the following -- function which renders each value to `Text`: --@@ -1628,7 +1609,7 @@ -- > z) (y.diff (n + List/length { index : Natural, value : a } kvs)) }) { count =  -- > 0, diff = λ(_ : Natural) → nil }).diff 0) ----- ... and run the expression through the the formatter:+-- ... and run the expression through the formatter: -- -- > $ dhall format < ./unformatted -- >   λ(a : Type)
src/Dhall/TypeCheck.hs view
@@ -359,6 +359,8 @@             Text -> return ()             _    -> Left (TypeError ctx e (CantTextAppend r tr))         return Text+    loop _      TextShow          = do+        return (Pi "_" Text Text)     loop _      List              = do         return (Pi "_" (Const Type) (Const Type))     loop ctx e@(ListLit  Nothing  xs) = do@@ -787,13 +789,6 @@                             _ -> Left (TypeError ctx e (HandlerNotAFunction kY tX))         mapM_ process (Dhall.Map.toList ktsY)         return t-    loop ctx e@(Constructors t  ) = do-        _ <- loop ctx t--        case Dhall.Core.normalize t of-            u@(Union _) -> loop ctx u-            t'          -> Left (TypeError ctx e (ConstructorsRequiresAUnionType t t'))-     loop ctx e@(Field r x       ) = do         t <- fmap Dhall.Core.normalize (loop ctx r) @@ -945,8 +940,7 @@ _NOT = "\ESC[1mnot\ESC[0m"  insert :: Pretty a => a -> Doc Ann-insert expression =-    "↳ " <> Pretty.align (Dhall.Util.snipDoc (Pretty.pretty expression))+insert = Dhall.Util.insert  prettyDiff :: (Eq a, Pretty a) => Expr s a -> Expr s a -> Doc Ann prettyDiff exprL exprR = Dhall.Diff.diffNormalized exprL exprR
src/Dhall/Util.hs view
@@ -5,11 +5,12 @@ module Dhall.Util     ( snip     , snipDoc+    , insert     ) where  import Data.Monoid ((<>)) import Data.Text (Text)-import Data.Text.Prettyprint.Doc (Doc)+import Data.Text.Prettyprint.Doc (Doc, Pretty) import Dhall.Pretty (Ann)  import qualified Data.Text@@ -67,3 +68,8 @@   where     go (_:xs) (_:ys) = go xs ys     go _ r = r++-- | Function to insert an aligned pretty expression+insert :: Pretty a => a -> Doc Ann+insert expression =+    "↳ " <> Pretty.align (snipDoc (Pretty.pretty expression))
+ tests/Dhall/Test/Dhall.hs view
@@ -0,0 +1,59 @@+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE RecordWildCards #-}+{-# LANGUAGE ScopedTypeVariables #-}+module Dhall.Test.Dhall where++import Control.Exception (SomeException, try)+import Numeric.Natural (Natural)+import Test.Tasty+import Test.Tasty.HUnit++import qualified Dhall+import qualified Dhall.Core+import qualified Dhall.Map++tests :: TestTree+tests =+    testGroup "Input"+     [ shouldShowDetailedTypeError ]++data MyType = MyType { foo :: String , bar :: Natural }++wrongDhallType :: Dhall.Type MyType +wrongDhallType = Dhall.Type { .. }+  where expected =+          Dhall.Core.Record+            ( Dhall.Map.fromList+              [ ( "bar", Dhall.Core.Natural)+              , ( "foo", Dhall.Core.Text )+              ]+            )+        extract _ = Nothing++shouldShowDetailedTypeError :: TestTree+shouldShowDetailedTypeError = testCase "detailed TypeError" $ do+  inputEx :: Either SomeException MyType <-+        try ( Dhall.input wrongDhallType "{  bar = 0, foo = \"foo\" }") ++  let expectedMsg =+        "\ESC[1;31mError\ESC[0m: Invalid Dhall.Type                                                  \n\+        \                                                                                \n\+        \Every Type must provide an extract function that succeeds if an expression      \n\+        \matches the expected type.  You provided a Type that disobeys this contract     \n\+        \                                                                                \n\+        \The Type provided has the expected dhall type:                                  \n\+        \                                                                                \n\+        \↳ { bar : Natural, foo : Text }\n\+        \                                                                                \n\+        \and it couldn't extract a value from the well-typed expression:                 \n\+        \                                                                                \n\+        \↳ { bar = 0, foo = \"foo\" }\n\+        \                                                                                \n"++  let assertMsg = "The exception message did not match the expected output"+  +  case inputEx of+    Left ex -> assertEqual assertMsg expectedMsg (show ex)+    Right _ -> fail "The extraction using a wrong type succeded"+ +
tests/Dhall/Test/Import.hs view
@@ -5,6 +5,7 @@ import Data.Text (Text) import Test.Tasty (TestTree) import Dhall.Import (MissingImports(..))+import Dhall.Parser (SourcedException(..)) import Control.Exception (catch, throwIO) import Data.Monoid ((<>)) @@ -23,38 +24,30 @@             [ shouldFail                 3                 "alternative of several unset env variables"-                "./tests/import/failure/alternativeEnv.dhall"+                "./dhall-lang/tests/import/failure/alternativeEnv.dhall"             , shouldFail                 1                 "alternative of env variable and missing"-                "./tests/import/failure/alternativeEnvMissing.dhall"+                "./dhall-lang/tests/import/failure/alternativeEnvMissing.dhall"             , shouldFail                 0                 "just missing"-                "./tests/import/failure/missing.dhall"+                "./dhall-lang/tests/import/failure/missing.dhall"             , shouldNotFail                 "alternative of env variable, missing, and a Natural"-                "./tests/import/success/alternativeEnvNaturalA.dhall"+                "./dhall-lang/tests/import/success/alternativeEnvNaturalA.dhall"             , shouldNotFail                 "alternative of env variable and a Natural"-                "./tests/import/success/alternativeEnvSimpleA.dhall"+                "./dhall-lang/tests/import/success/alternativeEnvSimpleA.dhall"             , shouldNotFail                 "alternative of a Natural and missing"-                "./tests/import/success/alternativeNaturalA.dhall"+                "./dhall-lang/tests/import/success/alternativeNaturalA.dhall"             ]         , Test.Tasty.testGroup "import relative to argument"             [ shouldNotFailRelative-                "works"-                "./tests/import/data/foo/bar"-                "./tests/import/success/relative.dhall"-            , shouldNotFailRelative                 "a semantic integrity check if fields are reordered"-                "./tests/import/success/"-                "./tests/import/success/fieldOrderA.dhall"-            , shouldNotFailRelative-                "a semantic integrity check when importing an expression using `constructors`"-                "./tests/import/success/"-                "./tests/import/success/issue553B.dhall"+                "./dhall-lang/tests/import/success/"+                "./dhall-lang/tests/import/success/fieldOrderA.dhall"             ]         ] @@ -88,9 +81,13 @@       (do           _ <- Dhall.Import.load actualExpr           fail "Import should have failed, but it succeeds")-      (\(MissingImports es) -> case length es == failures of-                                True -> pure ()-                                False -> fail ("Should have failed "-                                               <> show failures-                                               <> " times, but failed with: \n"-                                               <> show es)) )+      (\(SourcedException _ (MissingImports es)) ->+          case length es == failures of+              True -> pure ()+              False -> fail+                  (   "Should have failed "+                  <>  show failures+                  <>  " times, but failed with: \n"+                  <>  show es+                  )+      ) )
tests/Dhall/Test/Lint.hs view
@@ -22,6 +22,9 @@         [ should             "correctly handle multi-let expressions"             "success/multilet"+        , should+            "not fail when an inner expression removes all `let` bindings"+            "success/regression0"         ]  should :: Text -> Text -> TestTree
tests/Dhall/Test/Main.hs view
@@ -1,7 +1,8 @@ module Main where -import Test.Tasty (TestTree)+import           Test.Tasty               (TestTree) +import qualified Dhall.Test.Dhall import qualified Dhall.Test.Format import qualified Dhall.Test.Import import qualified Dhall.Test.Lint@@ -11,11 +12,13 @@ import qualified Dhall.Test.Regression import qualified Dhall.Test.Tutorial import qualified Dhall.Test.TypeCheck+import qualified GHC.IO.Encoding import qualified System.Directory import qualified System.Environment+import qualified System.IO import qualified Test.Tasty -import System.FilePath ((</>))+import           System.FilePath          ((</>))  allTests :: TestTree allTests =@@ -29,10 +32,13 @@         , Dhall.Test.Import.tests         , Dhall.Test.QuickCheck.tests         , Dhall.Test.Lint.tests+        , Dhall.Test.Dhall.tests         ]  main :: IO () main = do++    GHC.IO.Encoding.setLocaleEncoding System.IO.utf8     pwd <- System.Directory.getCurrentDirectory     System.Environment.setEnv "XDG_CACHE_HOME" (pwd </> ".cache")     Test.Tasty.defaultMain allTests
tests/Dhall/Test/Normalization.hs view
@@ -184,6 +184,8 @@         , shouldNormalize "Text/concatMapSep" "./success/prelude/Text/concatMapSep/1"         , shouldNormalize "Text/concatSep" "./success/prelude/Text/concatSep/0"         , shouldNormalize "Text/concatSep" "./success/prelude/Text/concatSep/1"+        , shouldNormalize "Text/show" "./success/prelude/Text/show/0"+        , shouldNormalize "Text/show" "./success/prelude/Text/show/1"         ]  simplifications :: TestTree@@ -276,8 +278,8 @@ should :: Text -> Text -> TestTree should name basename =     Test.Tasty.HUnit.testCase (Data.Text.unpack name) $ do-        let actualCode   = "./tests/normalization/" <> basename <> "A.dhall"-        let expectedCode = "./tests/normalization/" <> basename <> "B.dhall"+        let actualCode   = "./dhall-lang/tests/normalization/" <> basename <> "A.dhall"+        let expectedCode = "./dhall-lang/tests/normalization/" <> basename <> "B.dhall"          actualExpr <- case Dhall.Parser.exprFromText mempty actualCode of             Left  err  -> Control.Exception.throwIO err
tests/Dhall/Test/Parser.hs view
@@ -2,12 +2,15 @@  module Dhall.Test.Parser where -import Data.Text (Text)-import Test.Tasty (TestTree)+import           Data.Text            (Text)+import           Test.Tasty           (TestTree) +import qualified Codec.Serialise import qualified Control.Exception+import qualified Data.ByteString.Lazy import qualified Data.Text import qualified Data.Text.IO+import qualified Dhall.Binary import qualified Dhall.Parser import qualified Test.Tasty import qualified Test.Tasty.HUnit@@ -18,163 +21,168 @@         [ Test.Tasty.testGroup "whitespace"             [ shouldParse                 "prefix/suffix"-                "./tests/parser/success/whitespace"+                "./dhall-lang/tests/parser/success/whitespace"             , shouldParse                 "block comment"-                "./tests/parser/success/blockComment"+                "./dhall-lang/tests/parser/success/blockComment"             , shouldParse                 "nested block comment"-                "./tests/parser/success/nestedBlockComment"+                "./dhall-lang/tests/parser/success/nestedBlockComment"             , shouldParse                 "line comment"-                "./tests/parser/success/lineComment"+                "./dhall-lang/tests/parser/success/lineComment"             , shouldParse                 "Unicode comment"-                "./tests/parser/success/unicodeComment"+                "./dhall-lang/tests/parser/success/unicodeComment"             , shouldParse                 "whitespace buffet"-                "./tests/parser/success/whitespaceBuffet"+                "./dhall-lang/tests/parser/success/whitespaceBuffet"             ]         , shouldParse             "label"-            "./tests/parser/success/label"+            "./dhall-lang/tests/parser/success/label"         , shouldParse             "quoted label"-            "./tests/parser/success/quotedLabel"+            "./dhall-lang/tests/parser/success/quotedLabel"         , shouldParse             "double quoted string"-            "./tests/parser/success/doubleQuotedString"+            "./dhall-lang/tests/parser/success/doubleQuotedString"         , shouldParse             "Unicode double quoted string"-            "./tests/parser/success/unicodeDoubleQuotedString"+            "./dhall-lang/tests/parser/success/unicodeDoubleQuotedString"         , shouldParse             "escaped double quoted string"-            "./tests/parser/success/escapedDoubleQuotedString"+            "./dhall-lang/tests/parser/success/escapedDoubleQuotedString"         , shouldParse             "interpolated double quoted string"-            "./tests/parser/success/interpolatedDoubleQuotedString"+            "./dhall-lang/tests/parser/success/interpolatedDoubleQuotedString"         , shouldParse             "single quoted string"-            "./tests/parser/success/singleQuotedString"+            "./dhall-lang/tests/parser/success/singleQuotedString"         , shouldParse             "escaped single quoted string"-            "./tests/parser/success/escapedSingleQuotedString"+            "./dhall-lang/tests/parser/success/escapedSingleQuotedString"         , shouldParse             "interpolated single quoted string"-            "./tests/parser/success/interpolatedSingleQuotedString"+            "./dhall-lang/tests/parser/success/interpolatedSingleQuotedString"         , shouldParse             "double"-            "./tests/parser/success/double"+            "./dhall-lang/tests/parser/success/double"         , shouldParse             "natural"-            "./tests/parser/success/natural"+            "./dhall-lang/tests/parser/success/natural"         , shouldParse             "identifier"-            "./tests/parser/success/identifier"+            "./dhall-lang/tests/parser/success/identifier"         , shouldParse             "paths"-            "./tests/parser/success/paths"+            "./dhall-lang/tests/parser/success/paths"         , shouldParse             "path termination"-            "./tests/parser/success/pathTermination"+            "./dhall-lang/tests/parser/success/pathTermination"         , shouldParse             "urls"-            "./tests/parser/success/urls"+            "./dhall-lang/tests/parser/success/urls"         , shouldParse             "environmentVariables"-            "./tests/parser/success/environmentVariables"+            "./dhall-lang/tests/parser/success/environmentVariables"         , shouldParse             "lambda"-            "./tests/parser/success/lambda"+            "./dhall-lang/tests/parser/success/lambda"         , shouldParse             "if then else"-            "./tests/parser/success/ifThenElse"+            "./dhall-lang/tests/parser/success/ifThenElse"         , shouldParse             "let"-            "./tests/parser/success/let"+            "./dhall-lang/tests/parser/success/let"         , shouldParse             "forall"-            "./tests/parser/success/forall"+            "./dhall-lang/tests/parser/success/forall"         , shouldParse             "function type"-            "./tests/parser/success/functionType"+            "./dhall-lang/tests/parser/success/functionType"         , shouldParse             "operators"-            "./tests/parser/success/operators"+            "./dhall-lang/tests/parser/success/operators"         , shouldParse             "annotations"-            "./tests/parser/success/annotations"+            "./dhall-lang/tests/parser/success/annotations"         , shouldParse             "merge"-            "./tests/parser/success/merge"-        , shouldParse-            "constructors"-            "./tests/parser/success/constructors"+            "./dhall-lang/tests/parser/success/merge"         , shouldParse             "fields"-            "./tests/parser/success/fields"+            "./dhall-lang/tests/parser/success/fields"         , shouldParse             "record"-            "./tests/parser/success/record"+            "./dhall-lang/tests/parser/success/record"         , shouldParse             "union"-            "./tests/parser/success/union"+            "./dhall-lang/tests/parser/success/union"         , shouldParse             "list"-            "./tests/parser/success/list"+            "./dhall-lang/tests/parser/success/list"         , shouldParse             "builtins"-            "./tests/parser/success/builtins"+            "./dhall-lang/tests/parser/success/builtins"         , shouldParse             "import alternatives"-            "./tests/parser/success/importAlt"+            "./dhall-lang/tests/parser/success/importAlt"         , shouldParse             "large expression"-            "./tests/parser/success/largeExpression"+            "./dhall-lang/tests/parser/success/largeExpression"         , shouldParse             "names that begin with reserved identifiers"-            "./tests/parser/success/reservedPrefix"+            "./dhall-lang/tests/parser/success/reservedPrefix"         , shouldParse             "interpolated expressions with leading whitespace"-            "./tests/parser/success/template"+            "./dhall-lang/tests/parser/success/template"         , shouldParse             "collections with type annotations containing imports"-            "./tests/parser/success/collectionImportType"+            "./dhall-lang/tests/parser/success/collectionImportType"         , shouldParse             "a parenthesized custom header import"-            "./tests/parser/success/parenthesizeUsing"+            "./dhall-lang/tests/parser/success/parenthesizeUsing"         , shouldNotParse             "accessing a field of an import without parentheses"-            "./tests/parser/failure/importAccess.dhall"+            "./dhall-lang/tests/parser/failure/importAccess.dhall"         , shouldParse             "Sort"-            "./tests/parser/success/sort"+            "./dhall-lang/tests/parser/success/sort"         , shouldParse             "quoted path components"-            "./tests/parser/success/quotedPaths"+            "./dhall-lang/tests/parser/success/quotedPaths"         , shouldNotParse             "positive double out of bounds"-            "./tests/parser/failure/doubleBoundsPos.dhall"+            "./dhall-lang/tests/parser/failure/doubleBoundsPos.dhall"         , shouldNotParse             "negative double out of bounds"-            "./tests/parser/failure/doubleBoundsNeg.dhall"+            "./dhall-lang/tests/parser/failure/doubleBoundsNeg.dhall"         , shouldParse             "as Text"-            "./tests/parser/success/asText"-        , shouldParse-            "custom headers"-            "./tests/parser/success/customHeaders"+            "./dhall-lang/tests/parser/success/asText"         , shouldNotParse             "a multi-line literal without an initial newline"-            "./tests/parser/failure/mandatoryNewline.dhall"+            "./dhall-lang/tests/parser/failure/mandatoryNewline.dhall"+        , shouldParse+            "a Unicode path component"+            "./dhall-lang/tests/parser/success/unicodePaths"         ]  shouldParse :: Text -> FilePath -> TestTree-shouldParse name path = Test.Tasty.HUnit.testCase (Data.Text.unpack name) (do-    text <- Data.Text.IO.readFile (path <> "A.dhall")-    case Dhall.Parser.exprFromText mempty text of-        Left err -> Control.Exception.throwIO err-        Right _  -> return () )+shouldParse name path = Test.Tasty.HUnit.testCase (Data.Text.unpack name) $ do+    text    <- Data.Text.IO.readFile (path <> "A.dhall")+    encoded <- Data.ByteString.Lazy.readFile (path <> "B.dhallb")++    expression <- case Dhall.Parser.exprFromText mempty text of+      Left e -> Control.Exception.throwIO e+      Right a -> pure a++    let term  = Dhall.Binary.encode expression+        bytes = Codec.Serialise.serialise term++    let message = "The expected CBOR representation doesn't match the actual one"+    Test.Tasty.HUnit.assertEqual message encoded bytes  shouldNotParse :: Text -> FilePath -> TestTree shouldNotParse name path = Test.Tasty.HUnit.testCase (Data.Text.unpack name) (do
tests/Dhall/Test/QuickCheck.hs view
@@ -36,6 +36,7 @@  import qualified Codec.Serialise import qualified Data.Coerce+import qualified Data.List import qualified Dhall.Map import qualified Data.Sequence import qualified Dhall.Binary@@ -124,7 +125,8 @@     arbitrary = do         n   <- Test.QuickCheck.choose (0, 2)         kvs <- Test.QuickCheck.vectorOf n ((,) <$> arbitrary <*> arbitrary)-        return (Dhall.Map.fromList kvs)+        -- Sorting the fields here because serialization needs them in order+        return (Dhall.Map.fromList (Data.List.sortOn fst kvs))      shrink =             map Dhall.Map.fromList@@ -237,7 +239,6 @@                 , ( 1, lift2 CombineTypes)                 , ( 1, lift2 Prefer)                 , ( 1, lift3 Merge)-                , ( 1, lift1 Constructors)                 , ( 1, lift2 Field)                 , ( 1, lift2 Project)                 , ( 7, lift1 Embed)@@ -334,10 +335,10 @@ binaryRoundtrip expression =         wrap             (fmap-                Dhall.Binary.decodeWithVersion+                Dhall.Binary.decode                 (Codec.Serialise.deserialiseOrFail                   (Codec.Serialise.serialise-                    (Dhall.Binary.encodeWithVersion Dhall.Binary.defaultStandardVersion expression)+                    (Dhall.Binary.encode expression)                   )                 )             )
tests/Dhall/Test/Regression.hs view
@@ -20,7 +20,6 @@ import qualified Test.Tasty import qualified Test.Tasty.HUnit -import Control.DeepSeq (($!!)) import Dhall.Import (Imported) import Dhall.Parser (Src) import Dhall.TypeCheck (TypeError, X)@@ -35,7 +34,6 @@         , issue151         , issue164         , issue201-        , issue209         , issue216         , issue253         , parsing0@@ -130,15 +128,6 @@ issue201 = Test.Tasty.HUnit.testCase "Issue #201" (do     -- Verify that type synonyms work     _ <- Util.code "./tests/regression/issue201.dhall"-    return () )--issue209 :: TestTree-issue209 = Test.Tasty.HUnit.testCase "Issue #209" (do-    -- Verify that pretty-printing `constructors` doesn't trigger an infinite-    -- loop-    e <- Util.code "./tests/regression/issue209.dhall"-    let text = Dhall.Core.pretty e-    Just _ <- System.Timeout.timeout 1000000 (Control.Exception.evaluate $!! text)     return () )  issue216 :: TestTree
tests/Dhall/Test/TypeCheck.hs view
@@ -96,8 +96,8 @@ should :: Text -> Text -> TestTree should name basename =     Test.Tasty.HUnit.testCase (Data.Text.unpack name) $ do-        let actualCode   = "./tests/typecheck/" <> basename <> "A.dhall"-        let expectedCode = "./tests/typecheck/" <> basename <> "B.dhall"+        let actualCode   = "./dhall-lang/tests/typecheck/" <> basename <> "A.dhall"+        let expectedCode = "./dhall-lang/tests/typecheck/" <> basename <> "B.dhall"          actualExpr <- case Dhall.Parser.exprFromText mempty actualCode of             Left  err  -> Control.Exception.throwIO err@@ -116,7 +116,7 @@ shouldNotTypeCheck :: Text -> Text -> TestTree shouldNotTypeCheck name basename =     Test.Tasty.HUnit.testCase (Data.Text.unpack name) $ do-        let code = "./tests/typecheck/" <> basename <> ".dhall"+        let code = "./dhall-lang/tests/typecheck/" <> basename <> ".dhall"          expression <- case Dhall.Parser.exprFromText mempty code of             Left  exception  -> Control.Exception.throwIO exception
− tests/import/data/fieldOrder/1.dhall 
@@ -1,1 +0,0 @@-{ foo = 1, bar = True }
− tests/import/data/fieldOrder/2.dhall 
@@ -1,1 +0,0 @@-{ bar = True, foo = 1 }
− tests/import/data/foo/bar/a.dhall 
@@ -1,1 +0,0 @@-42
− tests/import/failure/alternativeEnv.dhall 
@@ -1,1 +0,0 @@-env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3
− tests/import/failure/alternativeEnvMissing.dhall 
@@ -1,1 +0,0 @@-env:UNSET ? missing
− tests/import/failure/missing.dhall 
@@ -1,1 +0,0 @@-missing
− tests/import/success/alternativeEnvNaturalA.dhall 
@@ -1,1 +0,0 @@-env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2
− tests/import/success/alternativeEnvNaturalB.dhall 
@@ -1,1 +0,0 @@-2
− tests/import/success/alternativeEnvSimpleA.dhall 
@@ -1,1 +0,0 @@-env:UNSET ? 3
− tests/import/success/alternativeEnvSimpleB.dhall 
@@ -1,1 +0,0 @@-3
− tests/import/success/alternativeNaturalA.dhall 
@@ -1,1 +0,0 @@-4 ? missing
− tests/import/success/alternativeNaturalB.dhall 
@@ -1,1 +0,0 @@-4
− tests/import/success/fieldOrderA.dhall 
@@ -1,5 +0,0 @@-{ example0 =-    ../data/fieldOrder/1.dhall sha256:261b3aca810973f81175d19b16226aaa5e76df7ea51c5d45e890dd6cdc49abbd-, example1 =-    ../data/fieldOrder/2.dhall sha256:261b3aca810973f81175d19b16226aaa5e76df7ea51c5d45e890dd6cdc49abbd-}
− tests/import/success/fieldOrderB.dhall 
@@ -1,1 +0,0 @@-{ example0 = { bar = True, foo = 1 }, example1 = { bar = True, foo = 1 } }
− tests/import/success/issue553A.dhall 
@@ -1,5 +0,0 @@-    let T = < A : {} | B : {} >--in  let t = constructors T--in  t
− tests/import/success/issue553B.dhall 
@@ -1,1 +0,0 @@-./issue553A.dhall sha256:250873549ddd262f27f3b197b2a2631fb569e7bdfe12446fc0912b4a2359a83e
− tests/import/success/relative.dhall 
@@ -1,2 +0,0 @@--- This file assumes its base directory is actually ./data/foo/bar/-./a.dhall : Natural
+ tests/lint/success/regression0A.dhall view
@@ -0,0 +1,7 @@+    let replicate = https://prelude.dhall-lang.org/List/replicate++in  let Config = { name : Text, age : Natural }++in  let Configs = List Config++in  replicate 10 Text "!"
+ tests/lint/success/regression0B.dhall view
@@ -0,0 +1,3 @@+let replicate = https://prelude.dhall-lang.org/List/replicate++in  replicate 10 Text "!"
− tests/normalization/success/haskell-tutorial/access/0A.dhall 
@@ -1,1 +0,0 @@-{ x = "foo" }.x
− tests/normalization/success/haskell-tutorial/access/0B.dhall 
@@ -1,1 +0,0 @@-"foo"
− tests/normalization/success/haskell-tutorial/access/1A.dhall 
@@ -1,1 +0,0 @@-< Foo : Text | Bar : Natural >.Foo
− tests/normalization/success/haskell-tutorial/access/1B.dhall 
@@ -1,1 +0,0 @@-λ(Foo : Text) → < Foo = Foo | Bar : Natural >
− tests/normalization/success/haskell-tutorial/combineTypes/0A.dhall 
@@ -1,1 +0,0 @@-{ foo : { bar : Text } } ⩓ { foo : { baz : Bool }, qux : Integer }
− tests/normalization/success/haskell-tutorial/combineTypes/0B.dhall 
@@ -1,1 +0,0 @@-{ foo : { bar : Text, baz : Bool }, qux : Integer }
− tests/normalization/success/haskell-tutorial/combineTypes/1A.dhall 
@@ -1,1 +0,0 @@-{ foo : { bar : Text } } //\\ { foo : { baz : Bool }, qux : Integer }
− tests/normalization/success/haskell-tutorial/combineTypes/1B.dhall 
@@ -1,1 +0,0 @@-{ foo : { bar : Text, baz : Bool }, qux : Integer }
− tests/normalization/success/haskell-tutorial/prefer/0A.dhall 
@@ -1,1 +0,0 @@-{ foo = 1, bar = "ABC" } // { baz = True }
− tests/normalization/success/haskell-tutorial/prefer/0B.dhall 
@@ -1,1 +0,0 @@-{ bar = "ABC", baz = True, foo = 1 }
− tests/normalization/success/haskell-tutorial/projection/0A.dhall 
@@ -1,1 +0,0 @@-{ x = 1, y = True, z = "ABC" }.{ x, y }
− tests/normalization/success/haskell-tutorial/projection/0B.dhall 
@@ -1,1 +0,0 @@-{ x = 1, y = True }
− tests/normalization/success/multiline/escapeA.dhall 
@@ -1,9 +0,0 @@--- Verify that an implementation is processing escape sequences correctly--''-''${-'''-$-"-\-''
− tests/normalization/success/multiline/escapeB.dhall 
@@ -1,1 +0,0 @@-"\${\n''\n\$\n\"\n\\\n"
− tests/normalization/success/multiline/hangingIndentA.dhall 
@@ -1,15 +0,0 @@-{- The indent is computed as the minimum number of leading spaces over all lines-   in a multi-line literal, including the line right before the closing quotes.-   In this case, there are three lines:--   * The first line containing "  foo" with two leading spaces-   * The second line containing "  bar" with two leading spaces-   * The third line containing "  " with two leading spaces--   Therefore we strip two leading spaces from all three lines--}--''-  foo-  bar-  ''
− tests/normalization/success/multiline/hangingIndentB.dhall 
@@ -1,1 +0,0 @@-"foo\nbar\n"
− tests/normalization/success/multiline/interestingA.dhall 
@@ -1,7 +0,0 @@--- Non-trivial example that combines several multi-line literal features--λ(x : Text) → ''-  ${x}    baz-      bar-    foo-    ''
− tests/normalization/success/multiline/interestingB.dhall 
@@ -1,1 +0,0 @@-λ(x : Text) → "${x}    baz\n    bar\n  foo\n  "
− tests/normalization/success/multiline/interiorIndentA.dhall 
@@ -1,16 +0,0 @@-{- The indent is computed as the minimum number of leading spaces over all lines-   in a multi-line literal, including the line right before the closing quotes.-   In this case, there are three lines:--   * The first line containing "  foo" with two leading spaces-   * The second line containing "  bar" with two leading spaces-   * The third line containing "" with zero leading spaces--   Since the last line has zero leading spaces, the minimum number of leading-   spaces over all three lines is zero, so we don't strip any spaces.--}--''-  foo-  bar-''
− tests/normalization/success/multiline/interiorIndentB.dhall 
@@ -1,1 +0,0 @@-"  foo\n  bar\n"
− tests/normalization/success/multiline/interpolationA.dhall 
@@ -1,9 +0,0 @@-{- This example verifies that an implementation is correctly breaking leading-   spaces at interpolated expressions.  The first line has the fewest number of-   leading spaces (2) due to the interruption by the interpolated expression.--}--''-${Natural/show 1}      foo-  bar-''
− tests/normalization/success/multiline/interpolationB.dhall 
@@ -1,1 +0,0 @@-"${Natural/show 1}      foo\n  bar\n"
− tests/normalization/success/multiline/preserveCommentA.dhall 
@@ -1,8 +0,0 @@-{- A comment within the interior of a multi-line literal counts as part of the-   literal--}--''--- Hello-{- world -}-''
− tests/normalization/success/multiline/preserveCommentB.dhall 
@@ -1,1 +0,0 @@-"-- Hello\n{- world -}\n"
− tests/normalization/success/multiline/singleLineA.dhall 
@@ -1,6 +0,0 @@-{- This is how you encode a multi-line literal that contains no newlines--   The leading newline is stripped--}-''-foo''
− tests/normalization/success/multiline/singleLineB.dhall 
@@ -1,1 +0,0 @@-"foo"
− tests/normalization/success/multiline/twoLinesA.dhall 
@@ -1,7 +0,0 @@-{- Verify that an implementation is correctly preserving newlines in the-   corresponding double-quoted literal--}--''-foo-bar''
− tests/normalization/success/multiline/twoLinesB.dhall 
@@ -1,1 +0,0 @@-"foo\nbar"
− tests/normalization/success/prelude/Bool/and/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.and [ True, False, True ]
− tests/normalization/success/prelude/Bool/and/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Bool/and/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.and ([] : List Bool)
− tests/normalization/success/prelude/Bool/and/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Bool/build/0A.dhall 
@@ -1,2 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.build -(λ(bool : Type) → λ(true : bool) → λ(false : bool) → true)
− tests/normalization/success/prelude/Bool/build/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Bool/build/1A.dhall 
@@ -1,2 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.build -(λ(bool : Type) → λ(true : bool) → λ(false : bool) → false)
− tests/normalization/success/prelude/Bool/build/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Bool/even/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.even [ False, True, False ]
− tests/normalization/success/prelude/Bool/even/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Bool/even/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.even [ False, True ]
− tests/normalization/success/prelude/Bool/even/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Bool/even/2A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.even [ False ]
− tests/normalization/success/prelude/Bool/even/2B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Bool/even/3A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.even ([] : List Bool)
− tests/normalization/success/prelude/Bool/even/3B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Bool/fold/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.fold True Natural 0 1
− tests/normalization/success/prelude/Bool/fold/0B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/success/prelude/Bool/fold/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.fold False Natural 0 1
− tests/normalization/success/prelude/Bool/fold/1B.dhall 
@@ -1,1 +0,0 @@-1
− tests/normalization/success/prelude/Bool/not/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.not True
− tests/normalization/success/prelude/Bool/not/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Bool/not/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.not False
− tests/normalization/success/prelude/Bool/not/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Bool/odd/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.odd [ True, False, True ]
− tests/normalization/success/prelude/Bool/odd/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Bool/odd/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.odd [ True, False ]
− tests/normalization/success/prelude/Bool/odd/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Bool/odd/2A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.odd [ True ]
− tests/normalization/success/prelude/Bool/odd/2B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Bool/odd/3A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.odd ([] : List Bool)
− tests/normalization/success/prelude/Bool/odd/3B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Bool/or/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.or [ True, False, True ]
− tests/normalization/success/prelude/Bool/or/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Bool/or/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.or ([] : List Bool)
− tests/normalization/success/prelude/Bool/or/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Bool/show/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.show True
− tests/normalization/success/prelude/Bool/show/0B.dhall 
@@ -1,1 +0,0 @@-"True"
− tests/normalization/success/prelude/Bool/show/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Bool`.show False
− tests/normalization/success/prelude/Bool/show/1B.dhall 
@@ -1,1 +0,0 @@-"False"
− tests/normalization/success/prelude/Double/show/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Double`.show -3.1
− tests/normalization/success/prelude/Double/show/0B.dhall 
@@ -1,1 +0,0 @@-"-3.1"
− tests/normalization/success/prelude/Double/show/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Double`.show 0.4
− tests/normalization/success/prelude/Double/show/1B.dhall 
@@ -1,1 +0,0 @@-"0.4"
− tests/normalization/success/prelude/Integer/show/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Integer`.show -3
− tests/normalization/success/prelude/Integer/show/0B.dhall 
@@ -1,1 +0,0 @@-"-3"
− tests/normalization/success/prelude/Integer/show/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Integer`.show +0
− tests/normalization/success/prelude/Integer/show/1B.dhall 
@@ -1,1 +0,0 @@-"+0"
− tests/normalization/success/prelude/Integer/toDouble/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Integer`.toDouble -3
− tests/normalization/success/prelude/Integer/toDouble/0B.dhall 
@@ -1,1 +0,0 @@--3.0
− tests/normalization/success/prelude/Integer/toDouble/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Integer`.toDouble +2
− tests/normalization/success/prelude/Integer/toDouble/1B.dhall 
@@ -1,1 +0,0 @@-2.0
− tests/normalization/success/prelude/List/all/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.all Natural Natural/even [ 2, 3, 5 ]
− tests/normalization/success/prelude/List/all/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/List/all/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.all Natural Natural/even ([] : List Natural)
− tests/normalization/success/prelude/List/all/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/List/any/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.any Natural Natural/even [ 2, 3, 5 ]
− tests/normalization/success/prelude/List/any/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/List/any/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.any Natural Natural/even ([] : List Natural)
− tests/normalization/success/prelude/List/any/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/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/success/prelude/List/build/0B.dhall 
@@ -1,1 +0,0 @@-[ "ABC", "DEF" ]
− tests/normalization/success/prelude/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/success/prelude/List/build/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Text
− tests/normalization/success/prelude/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/success/prelude/List/concat/0B.dhall 
@@ -1,1 +0,0 @@-[ 0, 1, 2, 3, 4, 5, 6, 7, 8 ]
− tests/normalization/success/prelude/List/concat/1A.dhall 
@@ -1,5 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.concat Natural-[ [] : List Natural-, [] : List Natural-, [] : List Natural-]
− tests/normalization/success/prelude/List/concat/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/success/prelude/List/concatMap/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.concatMap Natural Natural (λ(n : Natural) → [ n, n ]) [ 2, 3, 5 ]
− tests/normalization/success/prelude/List/concatMap/0B.dhall 
@@ -1,1 +0,0 @@-[ 2, 2, 3, 3, 5, 5 ]
− tests/normalization/success/prelude/List/concatMap/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.concatMap Natural Natural (λ(n : Natural) → [ n, n ]) ([] : List Natural)
− tests/normalization/success/prelude/List/concatMap/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/success/prelude/List/filter/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.filter Natural Natural/even [ 2, 3, 5 ]
− tests/normalization/success/prelude/List/filter/0B.dhall 
@@ -1,1 +0,0 @@-[ 2 ]
− tests/normalization/success/prelude/List/filter/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.filter Natural Natural/odd [ 2, 3, 5 ]
− tests/normalization/success/prelude/List/filter/1B.dhall 
@@ -1,1 +0,0 @@-[ 3, 5 ]
− tests/normalization/success/prelude/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/success/prelude/List/fold/0B.dhall 
@@ -1,1 +0,0 @@-10
− tests/normalization/success/prelude/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/success/prelude/List/fold/1B.dhall 
@@ -1,1 +0,0 @@-λ(nil : Natural) → 2 + (3 + (5 + nil))
− tests/normalization/success/prelude/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/success/prelude/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/success/prelude/List/generate/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.generate 5 Bool Natural/even
− tests/normalization/success/prelude/List/generate/0B.dhall 
@@ -1,1 +0,0 @@-[ True, False, True, False, True ]
− tests/normalization/success/prelude/List/generate/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.generate 0 Bool Natural/even
− tests/normalization/success/prelude/List/generate/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Bool
− tests/normalization/success/prelude/List/head/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.head Natural [ 0, 1, 2 ]
− tests/normalization/success/prelude/List/head/0B.dhall 
@@ -1,1 +0,0 @@-Some 0
− tests/normalization/success/prelude/List/head/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.head Natural ([] : List Natural)
− tests/normalization/success/prelude/List/head/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/success/prelude/List/indexed/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.indexed Bool [ True, False, True ]
− tests/normalization/success/prelude/List/indexed/0B.dhall 
@@ -1,4 +0,0 @@-[ { index = 0, value = True }-, { index = 1, value = False }-, { index = 2, value = True }-]
− tests/normalization/success/prelude/List/indexed/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.indexed Bool ([] : List Bool)
− tests/normalization/success/prelude/List/indexed/1B.dhall 
@@ -1,1 +0,0 @@-[] : List { index : Natural, value : Bool }
− tests/normalization/success/prelude/List/iterate/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.iterate 10 Natural (λ(x : Natural) → x * 2) 1
− tests/normalization/success/prelude/List/iterate/0B.dhall 
@@ -1,1 +0,0 @@-[ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512 ]
− tests/normalization/success/prelude/List/iterate/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.iterate 0 Natural (λ(x : Natural) → x * 2) 1
− tests/normalization/success/prelude/List/iterate/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/success/prelude/List/last/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.last Natural [ 0, 1, 2 ]
− tests/normalization/success/prelude/List/last/0B.dhall 
@@ -1,1 +0,0 @@-Some 2
− tests/normalization/success/prelude/List/last/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.last Natural ([] : List Natural)
− tests/normalization/success/prelude/List/last/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/success/prelude/List/length/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.length Natural [ 0, 1, 2 ]
− tests/normalization/success/prelude/List/length/0B.dhall 
@@ -1,1 +0,0 @@-3
− tests/normalization/success/prelude/List/length/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.length Natural ([] : List Natural)
− tests/normalization/success/prelude/List/length/1B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/success/prelude/List/map/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.map Natural Bool Natural/even [ 2, 3, 5 ]
− tests/normalization/success/prelude/List/map/0B.dhall 
@@ -1,1 +0,0 @@-[ True, False, False ]
− tests/normalization/success/prelude/List/map/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.map Natural Bool Natural/even ([] : List Natural)
− tests/normalization/success/prelude/List/map/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Bool
− tests/normalization/success/prelude/List/null/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.null Natural [ 0, 1, 2 ]
− tests/normalization/success/prelude/List/null/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/List/null/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.null Natural ([] : List Natural)
− tests/normalization/success/prelude/List/null/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/List/replicate/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.replicate 9 Natural 1
− tests/normalization/success/prelude/List/replicate/0B.dhall 
@@ -1,1 +0,0 @@-[ 1, 1, 1, 1, 1, 1, 1, 1, 1 ]
− tests/normalization/success/prelude/List/replicate/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.replicate 0 Natural 1
− tests/normalization/success/prelude/List/replicate/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/success/prelude/List/reverse/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.reverse Natural [ 0, 1, 2 ]
− tests/normalization/success/prelude/List/reverse/0B.dhall 
@@ -1,1 +0,0 @@-[ 2, 1, 0 ]
− tests/normalization/success/prelude/List/reverse/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.reverse Natural ([] : List Natural)
− tests/normalization/success/prelude/List/reverse/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/success/prelude/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/success/prelude/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/success/prelude/List/shifted/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.shifted Bool ([] : List (List { index : Natural, value : Bool }))
− tests/normalization/success/prelude/List/shifted/1B.dhall 
@@ -1,1 +0,0 @@-[] : List { index : Natural, value : Bool }
− tests/normalization/success/prelude/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/success/prelude/List/unzip/0B.dhall 
@@ -1,1 +0,0 @@-{ _1 = [ "ABC", "DEF", "GHI" ], _2 = [ True, False, True ] }
− tests/normalization/success/prelude/List/unzip/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`List`.unzip Text Bool ([] : List { _1 : Text, _2 : Bool })
− tests/normalization/success/prelude/List/unzip/1B.dhall 
@@ -1,1 +0,0 @@-{ _1 = [] : List Text, _2 = [] : List Bool }
− tests/normalization/success/prelude/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/success/prelude/Natural/build/0B.dhall 
@@ -1,1 +0,0 @@-3
− tests/normalization/success/prelude/Natural/build/1A.dhall 
@@ -1,6 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.build-( λ(natural : Type)-→ λ(succ : natural → natural)-→ λ(zero : natural)-→ zero-)
− tests/normalization/success/prelude/Natural/build/1B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/success/prelude/Natural/enumerate/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.enumerate 10
− tests/normalization/success/prelude/Natural/enumerate/0B.dhall 
@@ -1,1 +0,0 @@-[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ]
− tests/normalization/success/prelude/Natural/enumerate/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.enumerate 0
− tests/normalization/success/prelude/Natural/enumerate/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/success/prelude/Natural/even/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.even 3
− tests/normalization/success/prelude/Natural/even/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Natural/even/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.even 0
− tests/normalization/success/prelude/Natural/even/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Natural/fold/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.fold 3 Natural (λ(x : Natural) → 5 * x) 1
− tests/normalization/success/prelude/Natural/fold/0B.dhall 
@@ -1,1 +0,0 @@-125
− tests/normalization/success/prelude/Natural/fold/1A.dhall 
@@ -1,1 +0,0 @@-λ(zero : Natural) → (../../../../../../Prelude/package.dhall).`Natural`.fold 3 Natural (λ(x : Natural) → 5 * x) zero
− tests/normalization/success/prelude/Natural/fold/1B.dhall 
@@ -1,1 +0,0 @@-λ(zero : Natural) → 5 * (5 * (5 * zero))
− tests/normalization/success/prelude/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/success/prelude/Natural/fold/2B.dhall 
@@ -1,1 +0,0 @@-λ(natural : Type) → λ(succ : natural → natural) → λ(zero : natural) → succ (succ (succ zero))
− tests/normalization/success/prelude/Natural/isZero/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.isZero 2
− tests/normalization/success/prelude/Natural/isZero/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Natural/isZero/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.isZero 0
− tests/normalization/success/prelude/Natural/isZero/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Natural/odd/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.odd 3
− tests/normalization/success/prelude/Natural/odd/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Natural/odd/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.odd 0
− tests/normalization/success/prelude/Natural/odd/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Natural/product/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.product [ 2, 3, 5 ]
− tests/normalization/success/prelude/Natural/product/0B.dhall 
@@ -1,1 +0,0 @@-30
− tests/normalization/success/prelude/Natural/product/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.product ([] : List Natural)
− tests/normalization/success/prelude/Natural/product/1B.dhall 
@@ -1,1 +0,0 @@-1
− tests/normalization/success/prelude/Natural/show/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.show 3
− tests/normalization/success/prelude/Natural/show/0B.dhall 
@@ -1,1 +0,0 @@-"3"
− tests/normalization/success/prelude/Natural/show/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.show 0
− tests/normalization/success/prelude/Natural/show/1B.dhall 
@@ -1,1 +0,0 @@-"0"
− tests/normalization/success/prelude/Natural/sum/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.sum [ 2, 3, 5 ]
− tests/normalization/success/prelude/Natural/sum/0B.dhall 
@@ -1,1 +0,0 @@-10
− tests/normalization/success/prelude/Natural/sum/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.sum ([] : List Natural)
− tests/normalization/success/prelude/Natural/sum/1B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/success/prelude/Natural/toDouble/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.toDouble 3
− tests/normalization/success/prelude/Natural/toDouble/0B.dhall 
@@ -1,1 +0,0 @@-3.0
− tests/normalization/success/prelude/Natural/toDouble/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.toDouble 0
− tests/normalization/success/prelude/Natural/toDouble/1B.dhall 
@@ -1,1 +0,0 @@-0.0
− tests/normalization/success/prelude/Natural/toInteger/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.toInteger 3
− tests/normalization/success/prelude/Natural/toInteger/0B.dhall 
@@ -1,1 +0,0 @@-+3
− tests/normalization/success/prelude/Natural/toInteger/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Natural`.toInteger 0
− tests/normalization/success/prelude/Natural/toInteger/1B.dhall 
@@ -1,1 +0,0 @@-+0
− tests/normalization/success/prelude/Optional/all/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (Some 3)
− tests/normalization/success/prelude/Optional/all/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Optional/all/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.all Natural Natural/even (None Natural)
− tests/normalization/success/prelude/Optional/all/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Optional/any/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (Some 2)
− tests/normalization/success/prelude/Optional/any/0B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Optional/any/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.any Natural Natural/even (None Natural)
− tests/normalization/success/prelude/Optional/any/1B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/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/success/prelude/Optional/build/0B.dhall 
@@ -1,1 +0,0 @@-Some 1
− tests/normalization/success/prelude/Optional/build/1A.dhall 
@@ -1,7 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.build-Natural-( λ(optional : Type)-→ λ(some : Natural → optional)-→ λ(none : optional)-→ none-)
− tests/normalization/success/prelude/Optional/build/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/success/prelude/Optional/concat/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (Some 1))
− tests/normalization/success/prelude/Optional/concat/0B.dhall 
@@ -1,1 +0,0 @@-Some 1
− tests/normalization/success/prelude/Optional/concat/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (Some (None Natural))
− tests/normalization/success/prelude/Optional/concat/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/success/prelude/Optional/concat/2A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.concat Natural (None (Optional Natural))
− tests/normalization/success/prelude/Optional/concat/2B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/success/prelude/Optional/filter/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/even (Some 2)
− tests/normalization/success/prelude/Optional/filter/0B.dhall 
@@ -1,1 +0,0 @@-Some 2
− tests/normalization/success/prelude/Optional/filter/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.filter Natural Natural/odd (Some 2)
− tests/normalization/success/prelude/Optional/filter/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/success/prelude/Optional/fold/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.fold Natural (Some 2) Natural (λ(x : Natural) → x) 0
− tests/normalization/success/prelude/Optional/fold/0B.dhall 
@@ -1,1 +0,0 @@-2
− tests/normalization/success/prelude/Optional/fold/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.fold Natural (None Natural) Natural (λ(x : Natural) → x) 0
− tests/normalization/success/prelude/Optional/fold/1B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/success/prelude/Optional/head/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.head Natural [ None Natural, Some 1, Some 2 ]
− tests/normalization/success/prelude/Optional/head/0B.dhall 
@@ -1,1 +0,0 @@-Some 1
− tests/normalization/success/prelude/Optional/head/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.head Natural [ None Natural, None Natural ]
− tests/normalization/success/prelude/Optional/head/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/success/prelude/Optional/head/2A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.head Natural ([] : List (Optional Natural))
− tests/normalization/success/prelude/Optional/head/2B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/success/prelude/Optional/last/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.last Natural [ None Natural, Some 1, Some 2 ]
− tests/normalization/success/prelude/Optional/last/0B.dhall 
@@ -1,1 +0,0 @@-Some 2
− tests/normalization/success/prelude/Optional/last/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.last Natural [ None Natural, None Natural ]
− tests/normalization/success/prelude/Optional/last/1B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/success/prelude/Optional/last/2A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.last Natural ([] : List (Optional Natural))
− tests/normalization/success/prelude/Optional/last/2B.dhall 
@@ -1,1 +0,0 @@-None Natural
− tests/normalization/success/prelude/Optional/length/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.length Natural (Some 2)
− tests/normalization/success/prelude/Optional/length/0B.dhall 
@@ -1,1 +0,0 @@-1
− tests/normalization/success/prelude/Optional/length/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.length Natural (None Natural)
− tests/normalization/success/prelude/Optional/length/1B.dhall 
@@ -1,1 +0,0 @@-0
− tests/normalization/success/prelude/Optional/map/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (Some 3)
− tests/normalization/success/prelude/Optional/map/0B.dhall 
@@ -1,1 +0,0 @@-Some False
− tests/normalization/success/prelude/Optional/map/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.map Natural Bool Natural/even (None Natural)
− tests/normalization/success/prelude/Optional/map/1B.dhall 
@@ -1,1 +0,0 @@-None Bool
− tests/normalization/success/prelude/Optional/null/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.null Natural (Some 2)
− tests/normalization/success/prelude/Optional/null/0B.dhall 
@@ -1,1 +0,0 @@-False
− tests/normalization/success/prelude/Optional/null/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.null Natural (None Natural)
− tests/normalization/success/prelude/Optional/null/1B.dhall 
@@ -1,1 +0,0 @@-True
− tests/normalization/success/prelude/Optional/toList/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.toList Natural (Some 1)
− tests/normalization/success/prelude/Optional/toList/0B.dhall 
@@ -1,1 +0,0 @@-[ 1 ] : List Natural
− tests/normalization/success/prelude/Optional/toList/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.toList Natural (None Natural)
− tests/normalization/success/prelude/Optional/toList/1B.dhall 
@@ -1,1 +0,0 @@-[] : List Natural
− tests/normalization/success/prelude/Optional/unzip/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.unzip Text Bool (Some { _1 = "ABC", _2 = True })
− tests/normalization/success/prelude/Optional/unzip/0B.dhall 
@@ -1,1 +0,0 @@-{ _1 = Some "ABC", _2 = Some True }
− tests/normalization/success/prelude/Optional/unzip/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Optional`.unzip Text Bool (None { _1 : Text, _2 : Bool })
− tests/normalization/success/prelude/Optional/unzip/1B.dhall 
@@ -1,1 +0,0 @@-{ _1 = None Text, _2 = None Bool }
− tests/normalization/success/prelude/Text/concat/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Text`.concat [ "ABC", "DEF", "GHI" ]
− tests/normalization/success/prelude/Text/concat/0B.dhall 
@@ -1,1 +0,0 @@-"ABCDEFGHI"
− tests/normalization/success/prelude/Text/concat/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Text`.concat ([] : List Text)
− tests/normalization/success/prelude/Text/concat/1B.dhall 
@@ -1,1 +0,0 @@-""
− tests/normalization/success/prelude/Text/concatMap/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Text`.concatMap Natural (λ(n : Natural) → "${Natural/show n} ") [ 0, 1, 2 ]
− tests/normalization/success/prelude/Text/concatMap/0B.dhall 
@@ -1,1 +0,0 @@-"0 1 2 "
− tests/normalization/success/prelude/Text/concatMap/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Text`.concatMap Natural (λ(n : Natural) → "${Natural/show n} ") ([] : List Natural)
− tests/normalization/success/prelude/Text/concatMap/1B.dhall 
@@ -1,1 +0,0 @@-""
− tests/normalization/success/prelude/Text/concatMapSep/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show [ 0, 1, 2 ]
− tests/normalization/success/prelude/Text/concatMapSep/0B.dhall 
@@ -1,1 +0,0 @@-"0, 1, 2"
− tests/normalization/success/prelude/Text/concatMapSep/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Text`.concatMapSep ", " Natural Natural/show ([] : List Natural)
− tests/normalization/success/prelude/Text/concatMapSep/1B.dhall 
@@ -1,1 +0,0 @@-""
− tests/normalization/success/prelude/Text/concatSep/0A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Text`.concatSep ", " [ "ABC", "DEF", "GHI" ]
− tests/normalization/success/prelude/Text/concatSep/0B.dhall 
@@ -1,1 +0,0 @@-"ABC, DEF, GHI"
− tests/normalization/success/prelude/Text/concatSep/1A.dhall 
@@ -1,1 +0,0 @@-(../../../../../../Prelude/package.dhall).`Text`.concatSep ", " ([] : List Text)
− tests/normalization/success/prelude/Text/concatSep/1B.dhall 
@@ -1,1 +0,0 @@-""
− tests/normalization/success/remoteSystemsA.dhall 
@@ -1,52 +0,0 @@-let Text/concatMap = (../../../Prelude/package.dhall).`Text`.concatMap--let Text/concatSep = (../../../Prelude/package.dhall).`Text`.concatSep--let Row =-      { cores :-          Natural-      , host :-          Text-      , key :-          Text-      , mandatoryFeatures :-          List Text-      , platforms :-          List Text-      , speedFactor :-          Natural-      , supportedFeatures :-          List Text-      , user :-          Optional Text-      }--let renderRow =-        λ ( row-          : Row-          )-      → let host =-              Optional/fold-              Text-              row.user-              Text-              (λ(user : Text) → "${user}@${row.host}")-              row.host-        -        let platforms = Text/concatSep "," row.platforms-        -        let key = row.key-        -        let cores = Integer/show (Natural/toInteger row.cores)-        -        let speedFactor = Integer/show (Natural/toInteger row.speedFactor)-        -        let supportedFeatures = Text/concatSep "," row.supportedFeatures-        -        let mandatoryFeatures = Text/concatSep "," row.mandatoryFeatures-        -        in  ''-            ${host} ${platforms} ${key} ${cores} ${speedFactor} ${supportedFeatures} ${mandatoryFeatures}-            ''--in  Text/concatMap Row renderRow
− tests/normalization/success/remoteSystemsB.dhall 
@@ -1,212 +0,0 @@-  λ ( _-    : List-      { cores :-          Natural-      , host :-          Text-      , key :-          Text-      , mandatoryFeatures :-          List Text-      , platforms :-          List Text-      , speedFactor :-          Natural-      , supportedFeatures :-          List Text-      , user :-          Optional Text-      }-    )-→ List/fold-  { cores :-      Natural-  , host :-      Text-  , key :-      Text-  , mandatoryFeatures :-      List Text-  , platforms :-      List Text-  , speedFactor :-      Natural-  , supportedFeatures :-      List Text-  , user :-      Optional Text-  }-  _-  Text-  (   λ ( _-        : { cores :-              Natural-          , host :-              Text-          , key :-              Text-          , mandatoryFeatures :-              List Text-          , platforms :-              List Text-          , speedFactor :-              Natural-          , supportedFeatures :-              List Text-          , user :-              Optional Text-          }-        )-    → λ(_ : Text)-    →     ''-          ${Optional/fold-            Text-            _@1.user-            Text-            (λ(user : Text) → "${user}@${_@1.host}")-            _@1.host} ${merge-                        { Empty = λ(_ : {}) → "", NonEmpty = λ(_ : Text) → _ }-                        ( List/fold-                          Text-                          _@1.platforms-                          < Empty : {} | NonEmpty : Text >-                          (   λ(_ : Text)-                            → λ(_ : < Empty : {} | NonEmpty : Text >)-                            → merge-                              { Empty =-                                  λ(_ : {}) → < NonEmpty = _@2 | Empty : {} >-                              , NonEmpty =-                                    λ(_ : Text)-                                  → < NonEmpty = _@2 ++ "," ++ _ | Empty : {} >-                              }-                              _-                              : < Empty : {} | NonEmpty : Text >-                          )-                          < Empty = {=} | NonEmpty : Text >-                        )-                        : Text} ${_@1.key} ${Integer/show-                                             ( Natural/toInteger _@1.cores-                                             )} ${Integer/show-                                                  ( Natural/toInteger-                                                    _@1.speedFactor-                                                  )} ${merge-                                                       { Empty =-                                                           λ(_ : {}) → ""-                                                       , NonEmpty =-                                                           λ(_ : Text) → _-                                                       }-                                                       ( List/fold-                                                         Text-                                                         _@1.supportedFeatures-                                                         < Empty :-                                                             {}-                                                         | NonEmpty :-                                                             Text-                                                         >-                                                         (   λ(_ : Text)-                                                           → λ ( _-                                                               : < Empty :-                                                                     {}-                                                                 | NonEmpty :-                                                                     Text-                                                                 >-                                                               )-                                                           → merge-                                                             { Empty =-                                                                   λ(_ : {})-                                                                 → < NonEmpty =-                                                                       _@2-                                                                   | Empty :-                                                                       {}-                                                                   >-                                                             , NonEmpty =-                                                                   λ(_ : Text)-                                                                 → < NonEmpty =-                                                                           _@2-                                                                       ++  ","-                                                                       ++  _-                                                                   | Empty :-                                                                       {}-                                                                   >-                                                             }-                                                             _-                                                             : < Empty :-                                                                   {}-                                                               | NonEmpty :-                                                                   Text-                                                               >-                                                         )-                                                         < Empty =-                                                             {=}-                                                         | NonEmpty :-                                                             Text-                                                         >-                                                       )-                                                       : Text} ${merge-                                                                 { Empty =-                                                                       λ(_ : {})-                                                                     → ""-                                                                 , NonEmpty =-                                                                       λ ( _-                                                                         : Text-                                                                         )-                                                                     → _-                                                                 }-                                                                 ( List/fold-                                                                   Text-                                                                   _@1.mandatoryFeatures-                                                                   < Empty :-                                                                       {}-                                                                   | NonEmpty :-                                                                       Text-                                                                   >-                                                                   (   λ ( _-                                                                         : Text-                                                                         )-                                                                     → λ ( _-                                                                         : < Empty :-                                                                               {}-                                                                           | NonEmpty :-                                                                               Text-                                                                           >-                                                                         )-                                                                     → merge-                                                                       { Empty =-                                                                             λ ( _-                                                                               : {}-                                                                               )-                                                                           → < NonEmpty =-                                                                                 _@2-                                                                             | Empty :-                                                                                 {}-                                                                             >-                                                                       , NonEmpty =-                                                                             λ ( _-                                                                               : Text-                                                                               )-                                                                           → < NonEmpty =-                                                                                     _@2-                                                                                 ++  ","-                                                                                 ++  _-                                                                             | Empty :-                                                                                 {}-                                                                             >-                                                                       }-                                                                       _-                                                                       : < Empty :-                                                                             {}-                                                                         | NonEmpty :-                                                                             Text-                                                                         >-                                                                   )-                                                                   < Empty =-                                                                       {=}-                                                                   | NonEmpty :-                                                                       Text-                                                                   >-                                                                 )-                                                                 : Text}-          ''-      ++  _-  )-  ""
− tests/normalization/success/simple/doubleShowA.dhall 
@@ -1,1 +0,0 @@-{ example0 = Double/show -0.42, example1 = Double/show 13.37 }
− tests/normalization/success/simple/doubleShowB.dhall 
@@ -1,1 +0,0 @@-{ example0 = "-0.42", example1 = "13.37" }
− tests/normalization/success/simple/integerShowA.dhall 
@@ -1,4 +0,0 @@-{ example0 = Integer/show +1337-, example1 = Integer/show -42-, example2 = Integer/show +0-}
− tests/normalization/success/simple/integerShowB.dhall 
@@ -1,1 +0,0 @@-{ example0 = "+1337", example1 = "-42", example2 = "+0" }
− tests/normalization/success/simple/integerToDoubleA.dhall 
@@ -1,10 +0,0 @@-[ Integer/toDouble +179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792-, Integer/toDouble +179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791-, Integer/toDouble +179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218945-, Integer/toDouble +179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944--, Integer/toDouble -179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792-, Integer/toDouble -179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791-, Integer/toDouble -179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218945-, Integer/toDouble -179769313486231560835325876058105298516207002341652166261661174625869553267292326574530099287946549246750631490335877017522087105926987962906277604735569213290190919152394180476217125334960946356387261286640198029037799514183602981511756283727771403830521483963923935633133642802139091669457927874464075218944-]
− tests/normalization/success/simple/integerToDoubleB.dhall 
@@ -1,9 +0,0 @@-[ Infinity-, 1.7976931348623157e308-, 1.7976931348623157e308-, 1.7976931348623155e308-, -Infinity-, -1.7976931348623157e308-, -1.7976931348623157e308-, -1.7976931348623155e308-]
− tests/normalization/success/simple/letletA.dhall 
@@ -1,3 +0,0 @@-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 
@@ -1,1 +0,0 @@-1337
− tests/normalization/success/simple/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/success/simple/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/success/simple/multiLineA.dhall 
@@ -1,4 +0,0 @@-''- foo-bar-''
− tests/normalization/success/simple/multiLineB.dhall 
@@ -1,4 +0,0 @@-''- foo-bar-''
− tests/normalization/success/simple/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/success/simple/naturalBuildB.dhall 
@@ -1,7 +0,0 @@-{ example0 =-    1-, example1 =-    1-, example2 =-    λ(id : ∀(a : Type) → a → a) → id Natural 1-}
− tests/normalization/success/simple/naturalPlusA.dhall 
@@ -1,1 +0,0 @@-1 + 2
− tests/normalization/success/simple/naturalPlusB.dhall 
@@ -1,1 +0,0 @@-3
− tests/normalization/success/simple/naturalShowA.dhall 
@@ -1,1 +0,0 @@-Natural/show 42
− tests/normalization/success/simple/naturalShowB.dhall 
@@ -1,1 +0,0 @@-"42"
− tests/normalization/success/simple/naturalToIntegerA.dhall 
@@ -1,1 +0,0 @@-Natural/toInteger 1
− tests/normalization/success/simple/naturalToIntegerB.dhall 
@@ -1,1 +0,0 @@-+1
− tests/normalization/success/simple/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/success/simple/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/success/simple/optionalBuildFoldA.dhall 
@@ -1,1 +0,0 @@-Optional/build Text (Optional/fold Text ([ "foo" ] : Optional Text))
− tests/normalization/success/simple/optionalBuildFoldB.dhall 
@@ -1,1 +0,0 @@-[ "foo" ] : Optional Text
− tests/normalization/success/simple/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/success/simple/optionalFoldB.dhall 
@@ -1,1 +0,0 @@-{ example0 = 1, example1 = 2 }
− tests/normalization/success/simple/sortOperatorA.dhall 
@@ -1,1 +0,0 @@-{ b = 2 } // { a = 1 }
− tests/normalization/success/simple/sortOperatorB.dhall 
@@ -1,1 +0,0 @@-{ a = 1, b = 2 }
− tests/normalization/success/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/success/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/success/simplifications/eqA.dhall 
@@ -1,4 +0,0 @@-{ example0 = λ(x : Bool) → x == True-, example1 = λ(x : Bool) → True == x-, example2 = λ(x : Bool) → x == x-}
− tests/normalization/success/simplifications/eqB.dhall 
@@ -1,4 +0,0 @@-{ example0 = λ(x : Bool) → x-, example1 = λ(x : Bool) → x-, example2 = λ(x : Bool) → True-}
− tests/normalization/success/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/success/simplifications/ifThenElseB.dhall 
@@ -1,3 +0,0 @@-{ example0 = λ(x : Bool) → x-, example1 = λ(x : Bool) → λ(y : Text) → y-}
− tests/normalization/success/simplifications/neA.dhall 
@@ -1,4 +0,0 @@-{ example0 = λ(x : Bool) → x != False-, example1 = λ(x : Bool) → False != x-, example2 = λ(x : Bool) → x != x-}
− tests/normalization/success/simplifications/neB.dhall 
@@ -1,4 +0,0 @@-{ example0 = λ(x : Bool) → x-, example1 = λ(x : Bool) → x-, example2 = λ(x : Bool) → False-}
− tests/normalization/success/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/success/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/parser/failure/doubleBoundsNeg.dhall 
@@ -1,1 +0,0 @@--179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0
− tests/parser/failure/doubleBoundsPos.dhall 
@@ -1,1 +0,0 @@-179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497792.0
− tests/parser/failure/importAccess.dhall 
@@ -1,1 +0,0 @@-./testImport .hello
− tests/parser/failure/mandatoryNewline.dhall 
@@ -1,2 +0,0 @@--- Multi-line literals require a mandatory newline after the opening quotes-''ABC''
− tests/parser/success/annotationsA.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/success/annotationsB.dhall 
@@ -1,84 +0,0 @@-[-  26,-  [-    8,-    {-      "foo": [-        3,-        7,-        [-          3,-          7,-          [-            4,-            "Integer"-          ],-          [-            4,-            null,-            [-              15,-              1-            ],-            [-              15,-              2-            ],-            [-              15,-              3-            ]-          ]-        ],-        [-          4,-          null,-          [-            15,-            1-          ],-          [-            15,-            2-          ],-          [-            15,-            3-          ]-        ]-      ],-      "bar": [-        5,-        "Integer"-      ],-      "baz": [-        5,-        "Integer",-        [-          15,-          1-        ]-      ]-    }-  ],-  [-    7,-    {-      "foo": [-        0,-        "List",-        "Integer"-      ],-      "bar": [-        0,-        "Optional",-        "Integer"-      ],-      "baz": [-        0,-        "Optional",-        "Integer"-      ]-    }-  ]-]
− tests/parser/success/asTextA.dhall 
@@ -1,1 +0,0 @@-https://example.com/foo as Text
− tests/parser/success/asTextB.dhall 
@@ -1,11 +0,0 @@-[-  24,-  null,-  1,-  null,-  1,-  "example.com",-  "foo",-  null,-  null-]
− tests/parser/success/blockCommentA.dhall 
@@ -1,3 +0,0 @@-{- foo -}--1
− tests/parser/success/blockCommentB.dhall 
@@ -1,4 +0,0 @@-[-  15,-  1-]
− tests/parser/success/builtinsA.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/success/builtinsB.dhall 
@@ -1,57 +0,0 @@-[-  1,-  "x",-  [-    7,-    {-      "field0": "Bool",-      "field1": [-        0,-        "Optional",-        [-          0,-          "Optional",-          "Bool"-        ]-      ],-      "field2": "Natural",-      "field3": "Integer",-      "field4": "Double",-      "field5": "Text",-      "field6": [-        0,-        "List",-        [-          0,-          "List",-          "Bool"-        ]-      ]-    }-  ],-  [-    8,-    {-      "field00": "Natural/fold",-      "field01": "Natural/build",-      "field02": "Natural/isZero",-      "field03": "Natural/even",-      "field04": "Natural/odd",-      "field05": "Natural/toInteger",-      "field06": "Natural/show",-      "field07": "Integer/show",-      "field08": "Double/show",-      "field09": "List/build",-      "field10": "List/fold",-      "field11": "List/length",-      "field12": "List/head",-      "field13": "List/last",-      "field14": "List/indexed",-      "field15": "List/reverse",-      "field16": "Optional/fold",-      "field17": "Optional/build",-      "field18": true,-      "field19": false-    }-  ]-]
− tests/parser/success/collectionImportTypeA.dhall 
@@ -1,3 +0,0 @@-{ example0 = [] : Optional ./type.dhall-, example1 = [] : List ./type.dhall-}
− tests/parser/success/collectionImportTypeB.dhall 
@@ -1,25 +0,0 @@-[-  8,-  {-    "example0": [-      5,-      [-        24,-        null,-        0,-        3,-        "type.dhall"-      ]-    ],-    "example1": [-      4,-      [-        24,-        null,-        0,-        3,-        "type.dhall"-      ]-    ]-  }-]
− tests/parser/success/constructorsA.dhall 
@@ -1,1 +0,0 @@-constructors < Left : Natural | Right : Bool >
− tests/parser/success/constructorsB.dhall 
@@ -1,10 +0,0 @@-[-  13,-  [-    11,-    {-      "Left": "Natural",-      "Right": "Bool"-    }-  ]-]
− tests/parser/success/customHeadersA.dhall 
@@ -1,1 +0,0 @@-https://example.com/foo using ./headers.dhall
− tests/parser/success/customHeadersB.dhall 
@@ -1,17 +0,0 @@-[-  24,-  null,-  0,-  [-    24,-    null,-    0,-    3,-    "headers.dhall"-  ],-  1,-  "example.com",-  "foo",-  null,-  null-]
− tests/parser/success/doubleA.dhall 
@@ -1,1 +0,0 @@-[ 1.1, -1.1, 1e1, 1.1e1, -1.1 ]
− tests/parser/success/doubleB.dhall 
@@ -1,9 +0,0 @@-[-  4,-  null,-  1.1,-  -1.1,-  10,-  11,-  -1.1-]
− tests/parser/success/doubleQuotedStringA.dhall 
@@ -1,1 +0,0 @@-"ABC"
− tests/parser/success/doubleQuotedStringB.dhall 
@@ -1,4 +0,0 @@-[-  18,-  "ABC"-]
− tests/parser/success/environmentVariablesA.dhall 
@@ -1,5 +0,0 @@-[ env:FOO--  -- Yes, this is legal-, env:"\"\\\a\b\f\n\r\t\v"-]
− tests/parser/success/environmentVariablesB.dhall 
@@ -1,18 +0,0 @@-[-  4,-  null,-  [-    24,-    null,-    0,-    6,-    "FOO"-  ],-  [-    24,-    null,-    0,-    6,-    "\\\"\\\\\\a\\b\\f\\n\\r\\t\\v"-  ]-]
− tests/parser/success/escapedDoubleQuotedStringA.dhall 
@@ -1,1 +0,0 @@-"\\\"\$\\\/\b\f\n\r\t \u2200(a : Type) \u2192 a"
− tests/parser/success/escapedDoubleQuotedStringB.dhall 
@@ -1,4 +0,0 @@-[-  18,-  "\\\"$\\/\b\f\n\r\t ∀(a : Type) → a"-]
− tests/parser/success/escapedSingleQuotedStringA.dhall 
@@ -1,4 +0,0 @@-''-''${-'''-''
− tests/parser/success/escapedSingleQuotedStringB.dhall 
@@ -1,4 +0,0 @@-[-  18,-  "${\n''\n"-]
− tests/parser/success/fieldsA.dhall 
@@ -1,1 +0,0 @@-({ foo = { bar = { baz = 1 } } }).foo. bar .baz
− tests/parser/success/fieldsB.dhall 
@@ -1,31 +0,0 @@-[-  9,-  [-    9,-    [-      9,-      [-        8,-        {-          "foo": [-            8,-            {-              "bar": [-                8,-                {-                  "baz": [-                    15,-                    1-                  ]-                }-              ]-            }-          ]-        }-      ],-      "foo"-    ],-    "bar"-  ],-  "baz"-]
− tests/parser/success/forallA.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → forall (b : Type) -> a
− tests/parser/success/forallB.dhall 
@@ -1,11 +0,0 @@-[-  2,-  "a",-  "Type",-  [-    2,-    "b",-    "Type",-    "a"-  ]-]
− tests/parser/success/functionTypeA.dhall 
@@ -1,1 +0,0 @@-Bool → Bool -> Bool
− tests/parser/success/functionTypeB.dhall 
@@ -1,9 +0,0 @@-[-  2,-  "Bool",-  [-    2,-    "Bool",-    "Bool"-  ]-]
− tests/parser/success/identifierA.dhall 
@@ -1,1 +0,0 @@-λ(a : Type) → λ(a : Type) → a@1
− tests/parser/success/identifierB.dhall 
@@ -1,14 +0,0 @@-[-  1,-  "a",-  "Type",-  [-    1,-    "a",-    "Type",-    [-      "a",-      1-    ]-  ]-]
− tests/parser/success/ifThenElseA.dhall 
@@ -1,1 +0,0 @@-if True then 1 else 2
− tests/parser/success/ifThenElseB.dhall 
@@ -1,12 +0,0 @@-[-  14,-  true,-  [-    15,-    1-  ],-  [-    15,-    2-  ]-]
− tests/parser/success/importAltA.dhall 
@@ -1,1 +0,0 @@-env:UNSET1 as Text ? env:UNSET2 ? missing ? env:UNSET3 ? 2
− tests/parser/success/importAltB.dhall 
@@ -1,47 +0,0 @@-[-  3,-  11,-  [-    3,-    11,-    [-      3,-      11,-      [-        3,-        11,-        [-          24,-          null,-          1,-          6,-          "UNSET1"-        ],-        [-          24,-          null,-          0,-          6,-          "UNSET2"-        ]-      ],-      [-        24,-        null,-        0,-        7-      ]-    ],-    [-      24,-      null,-      0,-      6,-      "UNSET3"-    ]-  ],-  [-    15,-    2-  ]-]
− tests/parser/success/interpolatedDoubleQuotedStringA.dhall 
@@ -1,1 +0,0 @@-"ABC${Integer/show 123}"
− tests/parser/success/interpolatedDoubleQuotedStringB.dhall 
@@ -1,13 +0,0 @@-[-  18,-  "ABC",-  [-    0,-    "Integer/show",-    [-      15,-      123-    ]-  ],-  ""-]
− tests/parser/success/interpolatedSingleQuotedStringA.dhall 
@@ -1,4 +0,0 @@-''-ABC-${Integer/show 123}-''
− tests/parser/success/interpolatedSingleQuotedStringB.dhall 
@@ -1,13 +0,0 @@-[-  18,-  "ABC\n",-  [-    0,-    "Integer/show",-    [-      15,-      123-    ]-  ],-  "\n"-]
− tests/parser/success/labelA.dhall 
@@ -1,2 +0,0 @@-let _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/ = 1-in  _ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/
− tests/parser/success/labelB.dhall 
@@ -1,10 +0,0 @@-[-  25,-  "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/",-  null,-  [-    15,-    1-  ],-  "_ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-/"-]
− tests/parser/success/lambdaA.dhall 
@@ -1,1 +0,0 @@-λ(a : Type) → \(b : Type) -> a
− tests/parser/success/lambdaB.dhall 
@@ -1,11 +0,0 @@-[-  1,-  "a",-  "Type",-  [-    1,-    "b",-    "Type",-    "a"-  ]-]
− tests/parser/success/largeExpressionA.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/success/largeExpressionB.dhall 
@@ -1,1303 +0,0 @@-[-  1,-  "xs",-  [-    0,-    "List",-    [-      7,-      {-        "cores": "Natural",-        "host": "Text",-        "key": "Text",-        "mandatoryFeatures": [-          0,-          "List",-          "Text"-        ],-        "platforms": [-          0,-          "List",-          [-            11,-            {-              "AArch64_Linux": [-                7,-                {}-              ],-              "ARMv5tel_Linux": [-                7,-                {}-              ],-              "ARMv7l_Linux": [-                7,-                {}-              ],-              "I686_Cygwin": [-                7,-                {}-              ],-              "I686_Linux": [-                7,-                {}-              ],-              "MIPS64el_Linux": [-                7,-                {}-              ],-              "PowerPC_Linux": [-                7,-                {}-              ],-              "X86_64_Cygwin": [-                7,-                {}-              ],-              "X86_64_Darwin": [-                7,-                {}-              ],-              "X86_64_FreeBSD": [-                7,-                {}-              ],-              "X86_64_Linux": [-                7,-                {}-              ],-              "X86_64_Solaris": [-                7,-                {}-              ]-            }-          ]-        ],-        "speedFactor": "Natural",-        "supportedFeatures": [-          0,-          "List",-          "Text"-        ],-        "user": [-          0,-          "Optional",-          "Text"-        ]-      }-    ]-  ],-  [-    0,-    [-      0,-      [-        0,-        [-          0,-          [-            0,-            "List/fold",-            [-              7,-              {-                "cores": "Natural",-                "host": "Text",-                "key": "Text",-                "mandatoryFeatures": [-                  0,-                  "List",-                  "Text"-                ],-                "platforms": [-                  0,-                  "List",-                  [-                    11,-                    {-                      "AArch64_Linux": [-                        7,-                        {}-                      ],-                      "ARMv5tel_Linux": [-                        7,-                        {}-                      ],-                      "ARMv7l_Linux": [-                        7,-                        {}-                      ],-                      "I686_Cygwin": [-                        7,-                        {}-                      ],-                      "I686_Linux": [-                        7,-                        {}-                      ],-                      "MIPS64el_Linux": [-                        7,-                        {}-                      ],-                      "PowerPC_Linux": [-                        7,-                        {}-                      ],-                      "X86_64_Cygwin": [-                        7,-                        {}-                      ],-                      "X86_64_Darwin": [-                        7,-                        {}-                      ],-                      "X86_64_FreeBSD": [-                        7,-                        {}-                      ],-                      "X86_64_Linux": [-                        7,-                        {}-                      ],-                      "X86_64_Solaris": [-                        7,-                        {}-                      ]-                    }-                  ]-                ],-                "speedFactor": "Natural",-                "supportedFeatures": [-                  0,-                  "List",-                  "Text"-                ],-                "user": [-                  0,-                  "Optional",-                  "Text"-                ]-              }-            ]-          ],-          "xs"-        ],-        "Text"-      ],-      [-        1,-        "x",-        [-          7,-          {-            "cores": "Natural",-            "host": "Text",-            "key": "Text",-            "mandatoryFeatures": [-              0,-              "List",-              "Text"-            ],-            "platforms": [-              0,-              "List",-              [-                11,-                {-                  "AArch64_Linux": [-                    7,-                    {}-                  ],-                  "ARMv5tel_Linux": [-                    7,-                    {}-                  ],-                  "ARMv7l_Linux": [-                    7,-                    {}-                  ],-                  "I686_Cygwin": [-                    7,-                    {}-                  ],-                  "I686_Linux": [-                    7,-                    {}-                  ],-                  "MIPS64el_Linux": [-                    7,-                    {}-                  ],-                  "PowerPC_Linux": [-                    7,-                    {}-                  ],-                  "X86_64_Cygwin": [-                    7,-                    {}-                  ],-                  "X86_64_Darwin": [-                    7,-                    {}-                  ],-                  "X86_64_FreeBSD": [-                    7,-                    {}-                  ],-                  "X86_64_Linux": [-                    7,-                    {}-                  ],-                  "X86_64_Solaris": [-                    7,-                    {}-                  ]-                }-              ]-            ],-            "speedFactor": "Natural",-            "supportedFeatures": [-              0,-              "List",-              "Text"-            ],-            "user": [-              0,-              "Optional",-              "Text"-            ]-          }-        ],-        [-          1,-          "y",-          "Text",-          [-            3,-            6,-            [-              3,-              6,-              [-                3,-                6,-                [-                  3,-                  6,-                  [-                    3,-                    6,-                    [-                      3,-                      6,-                      [-                        3,-                        6,-                        [-                          3,-                          6,-                          [-                            3,-                            6,-                            [-                              3,-                              6,-                              [-                                3,-                                6,-                                [-                                  3,-                                  6,-                                  [-                                    3,-                                    6,-                                    [-                                      3,-                                      6,-                                      [-                                        0,-                                        [-                                          0,-                                          [-                                            0,-                                            [-                                              0,-                                              [-                                                0,-                                                "Optional/fold",-                                                "Text"-                                              ],-                                              [-                                                9,-                                                "x",-                                                "user"-                                              ]-                                            ],-                                            "Text"-                                          ],-                                          [-                                            1,-                                            "user",-                                            "Text",-                                            [-                                              3,-                                              6,-                                              [-                                                3,-                                                6,-                                                [-                                                  3,-                                                  6,-                                                  "user",-                                                  [-                                                    18,-                                                    "@"-                                                  ]-                                                ],-                                                [-                                                  9,-                                                  "x",-                                                  "host"-                                                ]-                                              ],-                                              [-                                                18,-                                                ""-                                              ]-                                            ]-                                          ]-                                        ],-                                        [-                                          9,-                                          "x",-                                          "host"-                                        ]-                                      ],-                                      [-                                        18,-                                        " "-                                      ]-                                    ],-                                    [-                                      6,-                                      [-                                        8,-                                        {-                                          "Empty": [-                                            1,-                                            [-                                              7,-                                              {}-                                            ],-                                            [-                                              18,-                                              ""-                                            ]-                                          ],-                                          "NonEmpty": [-                                            1,-                                            "result",-                                            "Text",-                                            "result"-                                          ]-                                        }-                                      ],-                                      [-                                        0,-                                        [-                                          0,-                                          [-                                            0,-                                            [-                                              0,-                                              [-                                                0,-                                                "List/fold",-                                                [-                                                  11,-                                                  {-                                                    "AArch64_Linux": [-                                                      7,-                                                      {}-                                                    ],-                                                    "ARMv5tel_Linux": [-                                                      7,-                                                      {}-                                                    ],-                                                    "ARMv7l_Linux": [-                                                      7,-                                                      {}-                                                    ],-                                                    "I686_Cygwin": [-                                                      7,-                                                      {}-                                                    ],-                                                    "I686_Linux": [-                                                      7,-                                                      {}-                                                    ],-                                                    "MIPS64el_Linux": [-                                                      7,-                                                      {}-                                                    ],-                                                    "PowerPC_Linux": [-                                                      7,-                                                      {}-                                                    ],-                                                    "X86_64_Cygwin": [-                                                      7,-                                                      {}-                                                    ],-                                                    "X86_64_Darwin": [-                                                      7,-                                                      {}-                                                    ],-                                                    "X86_64_FreeBSD": [-                                                      7,-                                                      {}-                                                    ],-                                                    "X86_64_Linux": [-                                                      7,-                                                      {}-                                                    ],-                                                    "X86_64_Solaris": [-                                                      7,-                                                      {}-                                                    ]-                                                  }-                                                ]-                                              ],-                                              [-                                                9,-                                                "x",-                                                "platforms"-                                              ]-                                            ],-                                            [-                                              11,-                                              {-                                                "Empty": [-                                                  7,-                                                  {}-                                                ],-                                                "NonEmpty": "Text"-                                              }-                                            ]-                                          ],-                                          [-                                            1,-                                            "element",-                                            [-                                              11,-                                              {-                                                "AArch64_Linux": [-                                                  7,-                                                  {}-                                                ],-                                                "ARMv5tel_Linux": [-                                                  7,-                                                  {}-                                                ],-                                                "ARMv7l_Linux": [-                                                  7,-                                                  {}-                                                ],-                                                "I686_Cygwin": [-                                                  7,-                                                  {}-                                                ],-                                                "I686_Linux": [-                                                  7,-                                                  {}-                                                ],-                                                "MIPS64el_Linux": [-                                                  7,-                                                  {}-                                                ],-                                                "PowerPC_Linux": [-                                                  7,-                                                  {}-                                                ],-                                                "X86_64_Cygwin": [-                                                  7,-                                                  {}-                                                ],-                                                "X86_64_Darwin": [-                                                  7,-                                                  {}-                                                ],-                                                "X86_64_FreeBSD": [-                                                  7,-                                                  {}-                                                ],-                                                "X86_64_Linux": [-                                                  7,-                                                  {}-                                                ],-                                                "X86_64_Solaris": [-                                                  7,-                                                  {}-                                                ]-                                              }-                                            ],-                                            [-                                              1,-                                              "status",-                                              [-                                                11,-                                                {-                                                  "Empty": [-                                                    7,-                                                    {}-                                                  ],-                                                  "NonEmpty": "Text"-                                                }-                                              ],-                                              [-                                                6,-                                                [-                                                  8,-                                                  {-                                                    "Empty": [-                                                      1,-                                                      [-                                                        7,-                                                        {}-                                                      ],-                                                      [-                                                        12,-                                                        "NonEmpty",-                                                        [-                                                          6,-                                                          [-                                                            8,-                                                            {-                                                              "AArch64_Linux": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "aarch64-linux"-                                                                ]-                                                              ],-                                                              "ARMv5tel_Linux": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "armv5tel-linux"-                                                                ]-                                                              ],-                                                              "ARMv7l_Linux": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "armv7l-linux"-                                                                ]-                                                              ],-                                                              "I686_Cygwin": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "i686-cygwin"-                                                                ]-                                                              ],-                                                              "I686_Linux": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "i686-linux"-                                                                ]-                                                              ],-                                                              "MIPS64el_Linux": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "mips64el-linux"-                                                                ]-                                                              ],-                                                              "PowerPC_Linux": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "powerpc-linux"-                                                                ]-                                                              ],-                                                              "X86_64_Cygwin": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "x86_64-cygwin"-                                                                ]-                                                              ],-                                                              "X86_64_Darwin": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "x86_64-darwin"-                                                                ]-                                                              ],-                                                              "X86_64_FreeBSD": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "x86_64-freebsd"-                                                                ]-                                                              ],-                                                              "X86_64_Linux": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "x86_64-linux"-                                                                ]-                                                              ],-                                                              "X86_64_Solaris": [-                                                                1,-                                                                [-                                                                  7,-                                                                  {}-                                                                ],-                                                                [-                                                                  18,-                                                                  "x86_64-solaris"-                                                                ]-                                                              ]-                                                            }-                                                          ],-                                                          "element"-                                                        ],-                                                        {-                                                          "Empty": [-                                                            7,-                                                            {}-                                                          ]-                                                        }-                                                      ]-                                                    ],-                                                    "NonEmpty": [-                                                      1,-                                                      "result",-                                                      "Text",-                                                      [-                                                        12,-                                                        "NonEmpty",-                                                        [-                                                          3,-                                                          6,-                                                          [-                                                            3,-                                                            6,-                                                            [-                                                              6,-                                                              [-                                                                8,-                                                                {-                                                                  "AArch64_Linux": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "aarch64-linux"-                                                                    ]-                                                                  ],-                                                                  "ARMv5tel_Linux": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "armv5tel-linux"-                                                                    ]-                                                                  ],-                                                                  "ARMv7l_Linux": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "armv7l-linux"-                                                                    ]-                                                                  ],-                                                                  "I686_Cygwin": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "i686-cygwin"-                                                                    ]-                                                                  ],-                                                                  "I686_Linux": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "i686-linux"-                                                                    ]-                                                                  ],-                                                                  "MIPS64el_Linux": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "mips64el-linux"-                                                                    ]-                                                                  ],-                                                                  "PowerPC_Linux": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "powerpc-linux"-                                                                    ]-                                                                  ],-                                                                  "X86_64_Cygwin": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "x86_64-cygwin"-                                                                    ]-                                                                  ],-                                                                  "X86_64_Darwin": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "x86_64-darwin"-                                                                    ]-                                                                  ],-                                                                  "X86_64_FreeBSD": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "x86_64-freebsd"-                                                                    ]-                                                                  ],-                                                                  "X86_64_Linux": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "x86_64-linux"-                                                                    ]-                                                                  ],-                                                                  "X86_64_Solaris": [-                                                                    1,-                                                                    [-                                                                      7,-                                                                      {}-                                                                    ],-                                                                    [-                                                                      18,-                                                                      "x86_64-solaris"-                                                                    ]-                                                                  ]-                                                                }-                                                              ],-                                                              "element"-                                                            ],-                                                            [-                                                              18,-                                                              ","-                                                            ]-                                                          ],-                                                          "result"-                                                        ],-                                                        {-                                                          "Empty": [-                                                            7,-                                                            {}-                                                          ]-                                                        }-                                                      ]-                                                    ]-                                                  }-                                                ],-                                                "status",-                                                [-                                                  11,-                                                  {-                                                    "Empty": [-                                                      7,-                                                      {}-                                                    ],-                                                    "NonEmpty": "Text"-                                                  }-                                                ]-                                              ]-                                            ]-                                          ]-                                        ],-                                        [-                                          12,-                                          "Empty",-                                          [-                                            8,-                                            {}-                                          ],-                                          {-                                            "NonEmpty": "Text"-                                          }-                                        ]-                                      ],-                                      "Text"-                                    ]-                                  ],-                                  [-                                    18,-                                    " "-                                  ]-                                ],-                                [-                                  9,-                                  "x",-                                  "key"-                                ]-                              ],-                              [-                                18,-                                " "-                              ]-                            ],-                            [-                              0,-                              "Integer/show",-                              [-                                0,-                                "Natural/toInteger",-                                [-                                  9,-                                  "x",-                                  "cores"-                                ]-                              ]-                            ]-                          ],-                          [-                            18,-                            " "-                          ]-                        ],-                        [-                          0,-                          "Integer/show",-                          [-                            0,-                            "Natural/toInteger",-                            [-                              9,-                              "x",-                              "speedFactor"-                            ]-                          ]-                        ]-                      ],-                      [-                        18,-                        " "-                      ]-                    ],-                    [-                      6,-                      [-                        8,-                        {-                          "Empty": [-                            1,-                            [-                              7,-                              {}-                            ],-                            [-                              18,-                              ""-                            ]-                          ],-                          "NonEmpty": [-                            1,-                            "result",-                            "Text",-                            "result"-                          ]-                        }-                      ],-                      [-                        0,-                        [-                          0,-                          [-                            0,-                            [-                              0,-                              [-                                0,-                                "List/fold",-                                "Text"-                              ],-                              [-                                9,-                                "x",-                                "supportedFeatures"-                              ]-                            ],-                            [-                              11,-                              {-                                "Empty": [-                                  7,-                                  {}-                                ],-                                "NonEmpty": "Text"-                              }-                            ]-                          ],-                          [-                            1,-                            "element",-                            "Text",-                            [-                              1,-                              "status",-                              [-                                11,-                                {-                                  "Empty": [-                                    7,-                                    {}-                                  ],-                                  "NonEmpty": "Text"-                                }-                              ],-                              [-                                6,-                                [-                                  8,-                                  {-                                    "Empty": [-                                      1,-                                      [-                                        7,-                                        {}-                                      ],-                                      [-                                        12,-                                        "NonEmpty",-                                        "element",-                                        {-                                          "Empty": [-                                            7,-                                            {}-                                          ]-                                        }-                                      ]-                                    ],-                                    "NonEmpty": [-                                      1,-                                      "result",-                                      "Text",-                                      [-                                        12,-                                        "NonEmpty",-                                        [-                                          3,-                                          6,-                                          [-                                            3,-                                            6,-                                            "element",-                                            [-                                              18,-                                              ","-                                            ]-                                          ],-                                          "result"-                                        ],-                                        {-                                          "Empty": [-                                            7,-                                            {}-                                          ]-                                        }-                                      ]-                                    ]-                                  }-                                ],-                                "status",-                                [-                                  11,-                                  {-                                    "Empty": [-                                      7,-                                      {}-                                    ],-                                    "NonEmpty": "Text"-                                  }-                                ]-                              ]-                            ]-                          ]-                        ],-                        [-                          12,-                          "Empty",-                          [-                            8,-                            {}-                          ],-                          {-                            "NonEmpty": "Text"-                          }-                        ]-                      ],-                      "Text"-                    ]-                  ],-                  [-                    18,-                    " "-                  ]-                ],-                [-                  6,-                  [-                    8,-                    {-                      "Empty": [-                        1,-                        [-                          7,-                          {}-                        ],-                        [-                          18,-                          ""-                        ]-                      ],-                      "NonEmpty": [-                        1,-                        "result",-                        "Text",-                        "result"-                      ]-                    }-                  ],-                  [-                    0,-                    [-                      0,-                      [-                        0,-                        [-                          0,-                          [-                            0,-                            "List/fold",-                            "Text"-                          ],-                          [-                            9,-                            "x",-                            "mandatoryFeatures"-                          ]-                        ],-                        [-                          11,-                          {-                            "Empty": [-                              7,-                              {}-                            ],-                            "NonEmpty": "Text"-                          }-                        ]-                      ],-                      [-                        1,-                        "element",-                        "Text",-                        [-                          1,-                          "status",-                          [-                            11,-                            {-                              "Empty": [-                                7,-                                {}-                              ],-                              "NonEmpty": "Text"-                            }-                          ],-                          [-                            6,-                            [-                              8,-                              {-                                "Empty": [-                                  1,-                                  [-                                    7,-                                    {}-                                  ],-                                  [-                                    12,-                                    "NonEmpty",-                                    "element",-                                    {-                                      "Empty": [-                                        7,-                                        {}-                                      ]-                                    }-                                  ]-                                ],-                                "NonEmpty": [-                                  1,-                                  "result",-                                  "Text",-                                  [-                                    12,-                                    "NonEmpty",-                                    [-                                      3,-                                      6,-                                      [-                                        3,-                                        6,-                                        "element",-                                        [-                                          18,-                                          ","-                                        ]-                                      ],-                                      "result"-                                    ],-                                    {-                                      "Empty": [-                                        7,-                                        {}-                                      ]-                                    }-                                  ]-                                ]-                              }-                            ],-                            "status",-                            [-                              11,-                              {-                                "Empty": [-                                  7,-                                  {}-                                ],-                                "NonEmpty": "Text"-                              }-                            ]-                          ]-                        ]-                      ]-                    ],-                    [-                      12,-                      "Empty",-                      [-                        8,-                        {}-                      ],-                      {-                        "NonEmpty": "Text"-                      }-                    ]-                  ],-                  "Text"-                ]-              ],-              [-                18,-                "\n"-              ]-            ],-            "y"-          ]-        ]-      ]-    ],-    [-      18,-      ""-    ]-  ]-]
− tests/parser/success/letA.dhall 
@@ -1,3 +0,0 @@-    let x = 1-in  let y : Integer = 2-in  x
− tests/parser/success/letB.dhall 
@@ -1,19 +0,0 @@-[-  25,-  "x",-  null,-  [-    15,-    1-  ],-  [-    25,-    "y",-    "Integer",-    [-      15,-      2-    ],-    "x"-  ]-]
− tests/parser/success/lineCommentA.dhall 
@@ -1,3 +0,0 @@--- foo--1
− tests/parser/success/lineCommentB.dhall 
@@ -1,4 +0,0 @@-[-  15,-  1-]
− tests/parser/success/listA.dhall 
@@ -1,4 +0,0 @@-[ [1, 2, 3]-, [1, 2, 3] : List Integer-, [] : List Integer-]
− tests/parser/success/listB.dhall 
@@ -1,40 +0,0 @@-[-  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 
@@ -1,7 +0,0 @@-  λ(x : <>)-→ { bar = merge {=} x : Integer-  , foo =-      merge-      { Left = λ(b : Bool) → b, Right = Natural/even }-      < Left = True | Right : Natural >-  }
− tests/parser/success/mergeB.dhall 
@@ -1,45 +0,0 @@-[-  1,-  "x",-  [-    11,-    {}-  ],-  [-    8,-    {-      "bar": [-        6,-        [-          8,-          {}-        ],-        "x",-        "Integer"-      ],-      "foo": [-        6,-        [-          8,-          {-            "Left": [-              1,-              "b",-              "Bool",-              "b"-            ],-            "Right": "Natural/even"-          }-        ],-        [-          12,-          "Left",-          true,-          {-            "Right": "Natural"-          }-        ]-      ]-    }-  ]-]
− tests/parser/success/multiletA.dhall 
@@ -1,3 +0,0 @@-let a = 1-let b = 2-in  a + b
− tests/parser/success/multiletB.dhall 
@@ -1,21 +0,0 @@-[-  25,-  "a",-  null,-  [-    15,-    1-  ],-  "b",-  null,-  [-    15,-    2-  ],-  [-    3,-    4,-    "a",-    "b"-  ]-]
− tests/parser/success/naturalA.dhall 
@@ -1,1 +0,0 @@-[ +0, +1, +01, +10 ]
− tests/parser/success/naturalB.dhall 
@@ -1,20 +0,0 @@-[-  4,-  null,-  [-    16,-    0-  ],-  [-    16,-    1-  ],-  [-    16,-    1-  ],-  [-    16,-    10-  ]-]
− tests/parser/success/nestedBlockCommentA.dhall 
@@ -1,3 +0,0 @@-{- foo {- bar -} baz -}--1
− tests/parser/success/nestedBlockCommentB.dhall 
@@ -1,4 +0,0 @@-[-  15,-  1-]
− tests/parser/success/operatorsA.dhall 
@@ -1,2 +0,0 @@-  { foo = (False && Natural/even (+1 + +2 * +3)) || True == False != True }-∧ { bar = [ "ABC" ++ "DEF" ] # [ "GHI" ] } ⫽ { baz = True }
− tests/parser/success/operatorsB.dhall 
@@ -1,96 +0,0 @@-[-  3,-  8,-  [-    8,-    {-      "foo": [-        3,-        0,-        [-          3,-          1,-          false,-          [-            0,-            "Natural/even",-            [-              3,-              4,-              [-                16,-                1-              ],-              [-                3,-                5,-                [-                  16,-                  2-                ],-                [-                  16,-                  3-                ]-              ]-            ]-          ]-        ],-        [-          3,-          3,-          [-            3,-            2,-            true,-            false-          ],-          true-        ]-      ]-    }-  ],-  [-    3,-    9,-    [-      8,-      {-        "bar": [-          3,-          7,-          [-            4,-            null,-            [-              3,-              6,-              [-                18,-                "ABC"-              ],-              [-                18,-                "DEF"-              ]-            ]-          ],-          [-            4,-            null,-            [-              18,-              "GHI"-            ]-          ]-        ]-      }-    ],-    [-      8,-      {-        "baz": true-      }-    ]-  ]-]
− tests/parser/success/parenthesizeUsingA.dhall 
@@ -1,1 +0,0 @@-https://raw.githubusercontent.com/dhall-lang/Prelude/c79c2bc3c46f129cc5b6d594ce298a381bcae92c/List/replicate using (./a.dhall sha256:16173e984d35ee3ffd8b6b79167df89480e67d1cd03ea5d0fc93689e4d928e61) sha256:b0e3ec1797b32c80c0bcb7e8254b08c7e9e35e75e6b410c7ac21477ab90167ad
− tests/parser/success/parenthesizeUsingB.dhall 
@@ -1,27 +0,0 @@-[-  24,-  [-    "sha256",-    "b0e3ec1797b32c80c0bcb7e8254b08c7e9e35e75e6b410c7ac21477ab90167ad"-  ],-  0,-  [-    24,-    [-      "sha256",-      "16173e984d35ee3ffd8b6b79167df89480e67d1cd03ea5d0fc93689e4d928e61"-    ],-    0,-    3,-    "a.dhall"-  ],-  1,-  "raw.githubusercontent.com",-  "dhall-lang",-  "Prelude",-  "c79c2bc3c46f129cc5b6d594ce298a381bcae92c",-  "List",-  "replicate",-  null,-  null-]
− tests/parser/success/pathTerminationA.dhall 
@@ -1,3 +0,0 @@--- Verify that certain punctuation marks terminate paths correctly-  λ(x : ./example)-→ [./example, {bar = <baz = ./example>, qux = ./example}, ./example]
− tests/parser/success/pathTerminationB.dhall 
@@ -1,53 +0,0 @@-[-  1,-  "x",-  [-    24,-    null,-    0,-    3,-    "example"-  ],-  [-    4,-    null,-    [-      24,-      null,-      0,-      3,-      "example"-    ],-    [-      8,-      {-        "qux": [-          24,-          null,-          0,-          3,-          "example"-        ],-        "bar": [-          12,-          "baz",-          [-            24,-            null,-            0,-            3,-            "example"-          ],-          {}-        ]-      }-    ],-    [-      24,-      null,-      0,-      3,-      "example"-    ]-  ]-]
− tests/parser/success/pathsA.dhall 
@@ -1,5 +0,0 @@-[ /absolute/path-, ./relative/path-, ~/home/anchored/path-, /ipfs/QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx/Prelude-]
− tests/parser/success/pathsB.dhall 
@@ -1,38 +0,0 @@-[-  4,-  null,-  [-    24,-    null,-    0,-    2,-    "absolute",-    "path"-  ],-  [-    24,-    null,-    0,-    3,-    "relative",-    "path"-  ],-  [-    24,-    null,-    0,-    5,-    "home",-    "anchored",-    "path"-  ],-  [-    24,-    null,-    0,-    2,-    "ipfs",-    "QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx",-    "Prelude"-  ]-]
− tests/parser/success/quotedLabelA.dhall 
@@ -1,4 +0,0 @@-{ example1 = let `let` = 1 in `let`-, example2 = let `:.` = 1 in `:.`-, example3 = let `$ref` = 1 in `$ref`-}
− tests/parser/success/quotedLabelB.dhall 
@@ -1,35 +0,0 @@-[-  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 
@@ -1,3 +0,0 @@-{ example0 = /"foo"/bar/"baz qux"-, example1 = https://example.com/foo/"bar?baz"?qux-}
− tests/parser/success/quotedPathsB.dhall 
@@ -1,26 +0,0 @@-[-  8,-  {-    "example0": [-      24,-      null,-      0,-      2,-      "foo",-      "bar",-      "baz qux"-    ],-    "example1": [-      24,-      null,-      0,-      null,-      1,-      "example.com",-      "foo",-      "bar?baz",-      "qux",-      null-    ]-  }-]
− tests/parser/success/recordA.dhall 
@@ -1,4 +0,0 @@-{ foo = 1-, bar = +2-, baz = True-} : { foo : Integer, bar : Natural, baz : Bool }
− tests/parser/success/recordB.dhall 
@@ -1,25 +0,0 @@-[-  26,-  [-    8,-    {-      "foo": [-        15,-        1-      ],-      "bar": [-        16,-        2-      ],-      "baz": true-    }-  ],-  [-    7,-    {-      "foo": "Integer",-      "bar": "Natural",-      "baz": "Bool"-    }-  ]-]
− tests/parser/success/reservedPrefixA.dhall 
@@ -1,1 +0,0 @@-let TypeSynonym = Integer in 1 : TypeSynonym
− tests/parser/success/reservedPrefixB.dhall 
@@ -1,14 +0,0 @@-[-  25,-  "TypeSynonym",-  null,-  "Integer",-  [-    26,-    [-      15,-      1-    ],-    "TypeSynonym"-  ]-]
− tests/parser/success/singleQuotedStringA.dhall 
@@ -1,4 +0,0 @@-''-ABC-DEF-''
− tests/parser/success/singleQuotedStringB.dhall 
@@ -1,4 +0,0 @@-[-  18,-  "ABC\nDEF\n"-]
− tests/parser/success/sortA.dhall 
@@ -1,1 +0,0 @@-Sort
− tests/parser/success/sortB.dhall 
@@ -1,1 +0,0 @@-"Sort"
− tests/parser/success/templateA.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/success/templateB.dhall 
@@ -1,60 +0,0 @@-[-  1,-  "record",-  [-    7,-    {-      "name": "Text",-      "value": "Double",-      "taxed_value": "Double",-      "in_ca": "Bool"-    }-  ],-  [-    18,-    "Hello ",-    [-      9,-      "record",-      "name"-    ],-    "\nYou have just won ",-    [-      0,-      "Double/show",-      [-        9,-        "record",-        "value"-      ]-    ],-    " dollars!\n",-    [-      14,-      [-        9,-        "record",-        "in_ca"-      ],-      [-        18,-        "Well, ",-        [-          0,-          "Double/show",-          [-            9,-            "record",-            "taxed_value"-          ]-        ],-        " dollars, after taxes"-      ],-      [-        18,-        ""-      ]-    ],-    "\n"-  ]-]
− tests/parser/success/unicodeCommentA.dhall 
@@ -1,3 +0,0 @@-{- ∀(a : Type) → a -}--1
− tests/parser/success/unicodeCommentB.dhall 
@@ -1,4 +0,0 @@-[-  15,-  1-]
− tests/parser/success/unicodeDoubleQuotedStringA.dhall 
@@ -1,1 +0,0 @@-"∀(a : Type) → a"
− tests/parser/success/unicodeDoubleQuotedStringB.dhall 
@@ -1,4 +0,0 @@-[-  18,-  "∀(a : Type) → a"-]
− tests/parser/success/unionA.dhall 
@@ -1,4 +0,0 @@-< A : {   }-| B = { = }-| C : {}-> : < A : {} | B : {} | C : {} >
− tests/parser/success/unionB.dhall 
@@ -1,38 +0,0 @@-[-  26,-  [-    12,-    "B",-    [-      8,-      {}-    ],-    {-      "A": [-        7,-        {}-      ],-      "C": [-        7,-        {}-      ]-    }-  ],-  [-    11,-    {-      "A": [-        7,-        {}-      ],-      "B": [-        7,-        {}-      ],-      "C": [-        7,-        {}-      ]-    }-  ]-]
− tests/parser/success/urlsA.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/success/urlsB.dhall 
@@ -1,110 +0,0 @@-[-  4,-  null,-  [-    24,-    null,-    0,-    null,-    0,-    "example.com",-    "someFile.dhall",-    null,-    null-  ],-  [-    24,-    null,-    0,-    null,-    1,-    "john:doe@example.com:8080",-    "foo",-    "bar",-    "qux=0",-    "xyzzy"-  ],-  [-    24,-    null,-    0,-    null,-    0,-    "prelude.dhall-lang.org",-    "package.dhall",-    null,-    null-  ],-  [-    24,-    null,-    0,-    null,-    1,-    "ipfs.io",-    "ipfs",-    "QmQ8w5PLcsNz56dMvRtq54vbuPe9cNnCCUXAQp6xLc6Ccx",-    "Prelude",-    null,-    null-  ],-  [-    24,-    null,-    0,-    null,-    1,-    "raw.githubusercontent.com",-    "dhall-lang",-    "dhall-haskell",-    "18e4e9a18dc53271146df3ccf5b4177c3552236b",-    "examples",-    "True",-    null,-    null-  ],-  [-    24,-    null,-    0,-    null,-    1,-    "127.0.0.1",-    "index.dhall",-    null,-    null-  ],-  [-    24,-    null,-    0,-    null,-    1,-    "[::]",-    "index.dhall",-    null,-    null-  ],-  [-    24,-    null,-    0,-    null,-    1,-    "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]",-    "tutorial.dhall",-    null,-    null-  ],-  [-    24,-    null,-    0,-    null,-    1,-    "-._~%2C!$&'()*+,;=:@-._~%2C!$&'()*+,;=:",-    "foo",-    "/-._~%2C!$&'()*+,;=:@/?",-    "/-._~%2C!$&'()*+,;=:@/?"-  ]-]
− tests/parser/success/whitespaceA.dhall 
@@ -1,3 +0,0 @@--1-
− tests/parser/success/whitespaceB.dhall 
@@ -1,4 +0,0 @@-[-  15,-  1-]
− tests/parser/success/whitespaceBuffetA.dhall 
@@ -1,9 +0,0 @@-    -- This-
-     Natural/even {--
-{- file--}
-  has-
- -}  +2 -- mixed {- line endings -}
− tests/parser/success/whitespaceBuffetB.dhall 
@@ -1,8 +0,0 @@-[-  0,-  "Natural/even",-  [-    16,-    2-  ]-]
− tests/regression/issue209.dhall 
@@ -1,1 +0,0 @@-constructors <>
tests/tutorial/unions3A.dhall view
@@ -1,4 +1,4 @@-    let MyType = constructors < Empty : {} | Person : { name : Text, age : Natural } >+    let MyType = < Empty : {} | Person : { name : Text, age : Natural } > in  [   MyType.Empty {=}     ,   MyType.Person { name = "John", age = 23 }     ,   MyType.Person { name = "Amy" , age = 25 }
tests/tutorial/unions4A.dhall view
@@ -1,1 +1,1 @@-constructors < Empty : {} | Person : { name : Text, age : Natural } >+< Empty : {} | Person : { name : Text, age : Natural } >
− tests/typecheck/failure/combineMixedRecords.dhall 
@@ -1,1 +0,0 @@-{ foo = 1 } ∧ { bar = Text }
− tests/typecheck/failure/hurkensParadox.dhall 
@@ -1,49 +0,0 @@-    let bottom : Type = ∀(any : Type) → any--in  let not : Type → Type = λ(p : Type) → p → bottom--in  let pow = λ(X : Kind) → X → Type--in  let U = ∀(X : Kind) → (pow (pow X) → X) → pow (pow X)--in  let tau-        : pow (pow U) → U-        =   λ(t : pow (pow U))-          → λ(X : Kind)-          → λ(f : pow (pow X) → X)-          → λ(p : pow X)-          → t (λ(x : U) → p (f (x X f)))--in  let sigma : U → pow (pow U) = λ(s : U) → s U (λ(t : pow (pow U)) → tau t)--in  let Delta-        : pow U-        = λ(y : U) → not (∀(p : pow U) → sigma y p → p (tau (sigma y)))--in  let Omega : U = tau (λ(p : pow U) → ∀(x : U) → sigma x p → p x)--in  let Theta : Type = ∀(p : pow U) → (∀(x : U) → sigma x p → p x) → p Omega--in  let D : Type = ∀(p : pow U) → sigma Omega p → p (tau (sigma Omega))--in  let lem1-        : ∀(p : pow U) → (∀(x : U) → sigma x p → p x) → p Omega-        =   λ(p : pow U)-          → λ(t1 : ∀(x : U) → sigma x p → p x)-          → t1 Omega (λ(x : U) → t1 (tau (sigma x)))--in  let lem3 : D = λ(p : pow U) → lem1 (λ(y : U) → p (tau (sigma y)))--in  let lem2-        : not D-        = lem1-          Delta-          (   λ(x : U)-            → λ(H2 : sigma x Delta)-            → λ(H3 : ∀(p : pow U) → sigma x p → p (tau (sigma x)))-            → H3 Delta H2 (λ(pp : pow U) → H3 (λ(y : U) → pp (tau (sigma y))))-          )--in  let evidence : bottom = lem2 lem3--in  evidence
− tests/typecheck/failure/mixedUnions.dhall 
@@ -1,1 +0,0 @@-< Left : Natural | Right : Type >
− tests/typecheck/failure/preferMixedRecords.dhall 
@@ -1,1 +0,0 @@-{ foo = 1 } ⫽ { bar = Text }
− tests/typecheck/success/accessEncodedTypeA.dhall 
@@ -1,4 +0,0 @@-  λ ( record-    : ∀(k : Kind) → ∀(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k) → k-    )-→ record Type (λ(x : Type) → λ(y : Type → Type) → x)
− tests/typecheck/success/accessEncodedTypeB.dhall 
@@ -1,4 +0,0 @@-  ∀ ( record-    : ∀(k : Kind) → ∀(makeRecord : ∀(x : Type) → ∀(y : Type → Type) → k) → k-    )-→ Type
− tests/typecheck/success/accessTypeA.dhall 
@@ -1,1 +0,0 @@-λ(record : { x : Type, y : Type → Type }) → record.x
− tests/typecheck/success/accessTypeB.dhall 
@@ -1,1 +0,0 @@-∀(record : { x : Type, y : Type → Type }) → Type
− tests/typecheck/success/prelude/Bool/and/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/and [ True, False, True ]
− tests/typecheck/success/prelude/Bool/and/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/and/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/and ([] : List Bool)
− tests/typecheck/success/prelude/Bool/and/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/build/0A.dhall 
@@ -1,2 +0,0 @@-../../../../../../Prelude/Bool/build -(λ(bool : Type) → λ(true : bool) → λ(false : bool) → true)
− tests/typecheck/success/prelude/Bool/build/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/build/1A.dhall 
@@ -1,2 +0,0 @@-../../../../../../Prelude/Bool/build -(λ(bool : Type) → λ(true : bool) → λ(false : bool) → false)
− tests/typecheck/success/prelude/Bool/build/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/even/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/even [ False, True, False ]
− tests/typecheck/success/prelude/Bool/even/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/even/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/even [ False, True ]
− tests/typecheck/success/prelude/Bool/even/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/even/2A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/even [ False ]
− tests/typecheck/success/prelude/Bool/even/2B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/even/3A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/even ([] : List Bool)
− tests/typecheck/success/prelude/Bool/even/3B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/fold/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/fold True Natural 0 1
− tests/typecheck/success/prelude/Bool/fold/0B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Bool/fold/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/fold False Natural 0 1
− tests/typecheck/success/prelude/Bool/fold/1B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Bool/not/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/not True
− tests/typecheck/success/prelude/Bool/not/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/not/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/not False
− tests/typecheck/success/prelude/Bool/not/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/odd/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/odd [ True, False, True ]
− tests/typecheck/success/prelude/Bool/odd/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/odd/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/odd [ True, False ]
− tests/typecheck/success/prelude/Bool/odd/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/odd/2A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/odd [ True ]
− tests/typecheck/success/prelude/Bool/odd/2B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/odd/3A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/odd ([] : List Bool)
− tests/typecheck/success/prelude/Bool/odd/3B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/or/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/or [ True, False, True ]
− tests/typecheck/success/prelude/Bool/or/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/or/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/or ([] : List Bool)
− tests/typecheck/success/prelude/Bool/or/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Bool/show/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/show True
− tests/typecheck/success/prelude/Bool/show/0B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Bool/show/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Bool/show False
− tests/typecheck/success/prelude/Bool/show/1B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Double/show/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Double/show -3.1
− tests/typecheck/success/prelude/Double/show/0B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Double/show/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Double/show 0.4
− tests/typecheck/success/prelude/Double/show/1B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Integer/show/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Integer/show -3
− tests/typecheck/success/prelude/Integer/show/0B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Integer/show/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Integer/show +0
− tests/typecheck/success/prelude/Integer/show/1B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Integer/toDouble/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Integer/toDouble -3
− tests/typecheck/success/prelude/Integer/toDouble/0B.dhall 
@@ -1,1 +0,0 @@-Double
− tests/typecheck/success/prelude/Integer/toDouble/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Integer/toDouble +2
− tests/typecheck/success/prelude/Integer/toDouble/1B.dhall 
@@ -1,1 +0,0 @@-Double
− tests/typecheck/success/prelude/List/all/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/all Natural Natural/even [ 2, 3, 5 ]
− tests/typecheck/success/prelude/List/all/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/List/all/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/all Natural Natural/even ([] : List Natural)
− tests/typecheck/success/prelude/List/all/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/List/any/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/any Natural Natural/even [ 2, 3, 5 ]
− tests/typecheck/success/prelude/List/any/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/List/any/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/any Natural Natural/even ([] : List Natural)
− tests/typecheck/success/prelude/List/any/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/List/build/0A.dhall 
@@ -1,7 +0,0 @@-../../../../../../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 
@@ -1,1 +0,0 @@-List Text
− tests/typecheck/success/prelude/List/build/1A.dhall 
@@ -1,7 +0,0 @@-../../../../../../Prelude/List/build-Text-( λ(list : Type)-→ λ(cons : Text → list → list)-→ λ(nil : list)-→ nil-)
− tests/typecheck/success/prelude/List/build/1B.dhall 
@@ -1,1 +0,0 @@-List Text
− tests/typecheck/success/prelude/List/concat/0A.dhall 
@@ -1,5 +0,0 @@-../../../../../../Prelude/List/concat Natural-[ [ 0, 1, 2 ]-, [ 3, 4 ]-, [ 5, 6, 7, 8 ]-]
− tests/typecheck/success/prelude/List/concat/0B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/concat/1A.dhall 
@@ -1,5 +0,0 @@-../../../../../../Prelude/List/concat Natural-[ [] : List Natural-, [] : List Natural-, [] : List Natural-]
− tests/typecheck/success/prelude/List/concat/1B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/concatMap/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/concatMap Natural Natural (λ(n : Natural) → [ n, n ]) [ 2, 3, 5 ]
− tests/typecheck/success/prelude/List/concatMap/0B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/concatMap/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/concatMap Natural Natural (λ(n : Natural) → [ n, n ]) ([] : List Natural)
− tests/typecheck/success/prelude/List/concatMap/1B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/filter/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/filter Natural Natural/even [ 2, 3, 5 ]
− tests/typecheck/success/prelude/List/filter/0B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/filter/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/filter Natural Natural/odd [ 2, 3, 5 ]
− tests/typecheck/success/prelude/List/filter/1B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/fold/0A.dhall 
@@ -1,6 +0,0 @@-../../../../../../Prelude/List/fold-Natural-[ 2, 3, 5 ]-Natural-(λ(x : Natural) → λ(y : Natural) → x + y)-0
− tests/typecheck/success/prelude/List/fold/0B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/List/fold/1A.dhall 
@@ -1,7 +0,0 @@-  λ(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 
@@ -1,1 +0,0 @@-∀(nil : Natural) → Natural
− tests/typecheck/success/prelude/List/fold/2A.dhall 
@@ -1,4 +0,0 @@-  λ(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 
@@ -1,1 +0,0 @@-∀(list : Type) → ∀(cons : Natural → list → list) → ∀(nil : list) → list
− tests/typecheck/success/prelude/List/generate/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/generate 5 Bool Natural/even
− tests/typecheck/success/prelude/List/generate/0B.dhall 
@@ -1,1 +0,0 @@-List Bool
− tests/typecheck/success/prelude/List/generate/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/generate 0 Bool Natural/even
− tests/typecheck/success/prelude/List/generate/1B.dhall 
@@ -1,1 +0,0 @@-List Bool
− tests/typecheck/success/prelude/List/head/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/head Natural [ 0, 1, 2 ]
− tests/typecheck/success/prelude/List/head/0B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/List/head/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/head Natural ([] : List Natural)
− tests/typecheck/success/prelude/List/head/1B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/List/indexed/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/indexed Bool [ True, False, True ]
− tests/typecheck/success/prelude/List/indexed/0B.dhall 
@@ -1,1 +0,0 @@-List { index : Natural, value : Bool }
− tests/typecheck/success/prelude/List/indexed/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/indexed Bool ([] : List Bool)
− tests/typecheck/success/prelude/List/indexed/1B.dhall 
@@ -1,1 +0,0 @@-List { index : Natural, value : Bool }
− tests/typecheck/success/prelude/List/iterate/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/iterate 10 Natural (λ(x : Natural) → x * 2) 1
− tests/typecheck/success/prelude/List/iterate/0B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/iterate/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/iterate 0 Natural (λ(x : Natural) → x * 2) 1
− tests/typecheck/success/prelude/List/iterate/1B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/last/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/last Natural [ 0, 1, 2 ]
− tests/typecheck/success/prelude/List/last/0B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/List/last/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/last Natural ([] : List Natural)
− tests/typecheck/success/prelude/List/last/1B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/List/length/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/length Natural [ 0, 1, 2 ]
− tests/typecheck/success/prelude/List/length/0B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/List/length/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/length Natural ([] : List Natural)
− tests/typecheck/success/prelude/List/length/1B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/List/map/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/map Natural Bool Natural/even [ 2, 3, 5 ]
− tests/typecheck/success/prelude/List/map/0B.dhall 
@@ -1,1 +0,0 @@-List Bool
− tests/typecheck/success/prelude/List/map/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/map Natural Bool Natural/even ([] : List Natural)
− tests/typecheck/success/prelude/List/map/1B.dhall 
@@ -1,1 +0,0 @@-List Bool
− tests/typecheck/success/prelude/List/null/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/null Natural [ 0, 1, 2 ]
− tests/typecheck/success/prelude/List/null/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/List/null/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/null Natural ([] : List Natural)
− tests/typecheck/success/prelude/List/null/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/List/replicate/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/replicate 9 Natural 1
− tests/typecheck/success/prelude/List/replicate/0B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/replicate/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/replicate 0 Natural 1
− tests/typecheck/success/prelude/List/replicate/1B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/reverse/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/reverse Natural [ 0, 1, 2 ]
− tests/typecheck/success/prelude/List/reverse/0B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/reverse/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/reverse Natural ([] : List Natural)
− tests/typecheck/success/prelude/List/reverse/1B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/List/shifted/0A.dhall 
@@ -1,15 +0,0 @@-../../../../../../Prelude/List/shifted-Bool-[ [ { index = 0, value = True }-  , { index = 1, value = True }-  , { index = 2, value = False }-  ]-, [ { index = 0, value = False }-  , { index = 1, value = False }-  ]-, [ { index = 0, value = True }-  , { index = 1, value = True }-  , { index = 2, value = True }-  , { index = 3, value = True }-  ]-]
− tests/typecheck/success/prelude/List/shifted/0B.dhall 
@@ -1,1 +0,0 @@-List { index : Natural, value : Bool }
− tests/typecheck/success/prelude/List/shifted/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/shifted Bool ([] : List (List { index : Natural, value : Bool }))
− tests/typecheck/success/prelude/List/shifted/1B.dhall 
@@ -1,1 +0,0 @@-List { index : Natural, value : Bool }
− tests/typecheck/success/prelude/List/unzip/0A.dhall 
@@ -1,7 +0,0 @@-../../../../../../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 
@@ -1,1 +0,0 @@-{ _1 : List Text, _2 : List Bool }
− tests/typecheck/success/prelude/List/unzip/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/List/unzip Text Bool ([] : List { _1 : Text, _2 : Bool })
− tests/typecheck/success/prelude/List/unzip/1B.dhall 
@@ -1,1 +0,0 @@-{ _1 : List Text, _2 : List Bool }
− tests/typecheck/success/prelude/Monoid/00A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.and
− tests/typecheck/success/prelude/Monoid/00B.dhall 
@@ -1,1 +0,0 @@-../../../../../Prelude/Monoid Bool
− tests/typecheck/success/prelude/Monoid/01A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.or
− tests/typecheck/success/prelude/Monoid/01B.dhall 
@@ -1,1 +0,0 @@-../../../../../Prelude/Monoid Bool
− tests/typecheck/success/prelude/Monoid/02A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.even
− tests/typecheck/success/prelude/Monoid/02B.dhall 
@@ -1,1 +0,0 @@-../../../../../Prelude/Monoid Bool
− tests/typecheck/success/prelude/Monoid/03A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Bool`.odd
− tests/typecheck/success/prelude/Monoid/03B.dhall 
@@ -1,1 +0,0 @@-../../../../../Prelude/Monoid Bool
− tests/typecheck/success/prelude/Monoid/04A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.concat
− tests/typecheck/success/prelude/Monoid/04B.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → ../../../../../Prelude/Monoid (List a)
− tests/typecheck/success/prelude/Monoid/05A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`List`.shifted
− tests/typecheck/success/prelude/Monoid/05B.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → ../../../../../Prelude/Monoid (List { index : Natural, value : a })
− tests/typecheck/success/prelude/Monoid/06A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.sum
− tests/typecheck/success/prelude/Monoid/06B.dhall 
@@ -1,1 +0,0 @@-../../../../../Prelude/Monoid Natural
− tests/typecheck/success/prelude/Monoid/07A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Natural`.product
− tests/typecheck/success/prelude/Monoid/07B.dhall 
@@ -1,1 +0,0 @@-../../../../../Prelude/Monoid Natural
− tests/typecheck/success/prelude/Monoid/08A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.head
− tests/typecheck/success/prelude/Monoid/08B.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → ../../../../../Prelude/Monoid (Optional a)
− tests/typecheck/success/prelude/Monoid/09A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Optional`.last
− tests/typecheck/success/prelude/Monoid/09B.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → ../../../../../Prelude/Monoid (Optional a)
− tests/typecheck/success/prelude/Monoid/10A.dhall 
@@ -1,1 +0,0 @@-(../../../../../Prelude/package.dhall).`Text`.concat
− tests/typecheck/success/prelude/Monoid/10B.dhall 
@@ -1,1 +0,0 @@-../../../../../Prelude/Monoid Text
− tests/typecheck/success/prelude/Natural/build/0A.dhall 
@@ -1,6 +0,0 @@-../../../../../../Prelude/Natural/build-( λ(natural : Type)-→ λ(succ : natural → natural)-→ λ(zero : natural)-→ succ (succ (succ zero))-)
− tests/typecheck/success/prelude/Natural/build/0B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Natural/build/1A.dhall 
@@ -1,6 +0,0 @@-../../../../../../Prelude/Natural/build-( λ(natural : Type)-→ λ(succ : natural → natural)-→ λ(zero : natural)-→ zero-)
− tests/typecheck/success/prelude/Natural/build/1B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Natural/enumerate/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/enumerate 10
− tests/typecheck/success/prelude/Natural/enumerate/0B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/Natural/enumerate/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/enumerate 0
− tests/typecheck/success/prelude/Natural/enumerate/1B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/Natural/even/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/even 3
− tests/typecheck/success/prelude/Natural/even/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Natural/even/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/even 0
− tests/typecheck/success/prelude/Natural/even/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Natural/fold/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/fold 3 Natural (λ(x : Natural) → 5 * x) 1
− tests/typecheck/success/prelude/Natural/fold/0B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Natural/fold/1A.dhall 
@@ -1,1 +0,0 @@-λ(zero : Natural) → ../../../../../../Prelude/Natural/fold 3 Natural (λ(x : Natural) → 5 * x) zero
− tests/typecheck/success/prelude/Natural/fold/1B.dhall 
@@ -1,1 +0,0 @@-∀(zero : Natural) → Natural
− tests/typecheck/success/prelude/Natural/fold/2A.dhall 
@@ -1,4 +0,0 @@-  λ(natural : Type)-→ λ(succ : natural → natural)-→ λ(zero : natural)-→ ../../../../../../Prelude/Natural/fold 3 natural succ zero
− tests/typecheck/success/prelude/Natural/fold/2B.dhall 
@@ -1,1 +0,0 @@-∀(natural : Type) → ∀(succ : natural → natural) → ∀(zero : natural) → natural
− tests/typecheck/success/prelude/Natural/isZero/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/isZero 2
− tests/typecheck/success/prelude/Natural/isZero/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Natural/isZero/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/isZero 0
− tests/typecheck/success/prelude/Natural/isZero/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Natural/odd/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/odd 3
− tests/typecheck/success/prelude/Natural/odd/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Natural/odd/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/odd 0
− tests/typecheck/success/prelude/Natural/odd/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Natural/product/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/product [ 2, 3, 5 ]
− tests/typecheck/success/prelude/Natural/product/0B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Natural/product/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/product ([] : List Natural)
− tests/typecheck/success/prelude/Natural/product/1B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Natural/show/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/show 3
− tests/typecheck/success/prelude/Natural/show/0B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Natural/show/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/show 0
− tests/typecheck/success/prelude/Natural/show/1B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Natural/sum/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/sum [ 2, 3, 5 ]
− tests/typecheck/success/prelude/Natural/sum/0B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Natural/sum/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/sum ([] : List Natural)
− tests/typecheck/success/prelude/Natural/sum/1B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Natural/toDouble/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/toDouble 3
− tests/typecheck/success/prelude/Natural/toDouble/0B.dhall 
@@ -1,1 +0,0 @@-Double
− tests/typecheck/success/prelude/Natural/toDouble/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/toDouble 0
− tests/typecheck/success/prelude/Natural/toDouble/1B.dhall 
@@ -1,1 +0,0 @@-Double
− tests/typecheck/success/prelude/Natural/toInteger/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/toInteger 3
− tests/typecheck/success/prelude/Natural/toInteger/0B.dhall 
@@ -1,1 +0,0 @@-Integer
− tests/typecheck/success/prelude/Natural/toInteger/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Natural/toInteger 0
− tests/typecheck/success/prelude/Natural/toInteger/1B.dhall 
@@ -1,1 +0,0 @@-Integer
− tests/typecheck/success/prelude/Optional/all/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/all Natural Natural/even (Some 3)
− tests/typecheck/success/prelude/Optional/all/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Optional/all/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/all Natural Natural/even (None Natural)
− tests/typecheck/success/prelude/Optional/all/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Optional/any/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/any Natural Natural/even (Some 2)
− tests/typecheck/success/prelude/Optional/any/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Optional/any/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/any Natural Natural/even (None Natural)
− tests/typecheck/success/prelude/Optional/any/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Optional/build/0A.dhall 
@@ -1,7 +0,0 @@-../../../../../../Prelude/Optional/build-Natural-( λ(optional : Type)-→ λ(some : Natural → optional)-→ λ(none : optional)-→ some 1-)
− tests/typecheck/success/prelude/Optional/build/0B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/build/1A.dhall 
@@ -1,7 +0,0 @@-../../../../../../Prelude/Optional/build-Natural-( λ(optional : Type)-→ λ(some : Natural → optional)-→ λ(none : optional)-→ none-)
− tests/typecheck/success/prelude/Optional/build/1B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/concat/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/concat Natural (Some (Some 1))
− tests/typecheck/success/prelude/Optional/concat/0B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/concat/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/concat Natural (Some (None Natural))
− tests/typecheck/success/prelude/Optional/concat/1B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/concat/2A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/concat Natural (None (Optional Natural))
− tests/typecheck/success/prelude/Optional/concat/2B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/filter/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/filter Natural Natural/even (Some 2)
− tests/typecheck/success/prelude/Optional/filter/0B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/filter/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/filter Natural Natural/odd (Some 2)
− tests/typecheck/success/prelude/Optional/filter/1B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/fold/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/fold Natural (Some 2) Natural (λ(x : Natural) → x) 0
− tests/typecheck/success/prelude/Optional/fold/0B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Optional/fold/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/fold Natural (None Natural) Natural (λ(x : Natural) → x) 0
− tests/typecheck/success/prelude/Optional/fold/1B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Optional/head/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/head Natural [ None Natural, Some 1, Some 2 ]
− tests/typecheck/success/prelude/Optional/head/0B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/head/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/head Natural [ None Natural, None Natural ]
− tests/typecheck/success/prelude/Optional/head/1B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/head/2A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/head Natural ([] : List (Optional Natural))
− tests/typecheck/success/prelude/Optional/head/2B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/last/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/last Natural [ None Natural, Some 1, Some 2 ]
− tests/typecheck/success/prelude/Optional/last/0B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/last/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/last Natural [ None Natural, None Natural ]
− tests/typecheck/success/prelude/Optional/last/1B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/last/2A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/last Natural ([] : List (Optional Natural))
− tests/typecheck/success/prelude/Optional/last/2B.dhall 
@@ -1,1 +0,0 @@-Optional Natural
− tests/typecheck/success/prelude/Optional/length/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/length Natural (Some 2)
− tests/typecheck/success/prelude/Optional/length/0B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Optional/length/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/length Natural (None Natural)
− tests/typecheck/success/prelude/Optional/length/1B.dhall 
@@ -1,1 +0,0 @@-Natural
− tests/typecheck/success/prelude/Optional/map/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/map Natural Bool Natural/even (Some 3)
− tests/typecheck/success/prelude/Optional/map/0B.dhall 
@@ -1,1 +0,0 @@-Optional Bool
− tests/typecheck/success/prelude/Optional/map/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/map Natural Bool Natural/even (None Natural)
− tests/typecheck/success/prelude/Optional/map/1B.dhall 
@@ -1,1 +0,0 @@-Optional Bool
− tests/typecheck/success/prelude/Optional/null/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/null Natural (Some 2)
− tests/typecheck/success/prelude/Optional/null/0B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Optional/null/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/null Natural (None Natural)
− tests/typecheck/success/prelude/Optional/null/1B.dhall 
@@ -1,1 +0,0 @@-Bool
− tests/typecheck/success/prelude/Optional/toList/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/toList Natural (Some 1)
− tests/typecheck/success/prelude/Optional/toList/0B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/Optional/toList/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/toList Natural (None Natural)
− tests/typecheck/success/prelude/Optional/toList/1B.dhall 
@@ -1,1 +0,0 @@-List Natural
− tests/typecheck/success/prelude/Optional/unzip/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/unzip Text Bool (Some { _1 = "ABC", _2 = True })
− tests/typecheck/success/prelude/Optional/unzip/0B.dhall 
@@ -1,1 +0,0 @@-{ _1 : Optional Text, _2 : Optional Bool }
− tests/typecheck/success/prelude/Optional/unzip/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Optional/unzip Text Bool (None { _1 : Text, _2 : Bool })
− tests/typecheck/success/prelude/Optional/unzip/1B.dhall 
@@ -1,1 +0,0 @@-{ _1 : Optional Text, _2 : Optional Bool }
− tests/typecheck/success/prelude/Text/concat/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Text/concat [ "ABC", "DEF", "GHI" ]
− tests/typecheck/success/prelude/Text/concat/0B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Text/concat/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Text/concat ([] : List Text)
− tests/typecheck/success/prelude/Text/concat/1B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Text/concatMap/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Text/concatMap Natural (λ(n : Natural) → "${Natural/show n} ") [ 0, 1, 2 ]
− tests/typecheck/success/prelude/Text/concatMap/0B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Text/concatMap/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Text/concatMap Natural (λ(n : Natural) → "${Natural/show n} ") ([] : List Natural)
− tests/typecheck/success/prelude/Text/concatMap/1B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Text/concatMapSep/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Text/concatMapSep ", " Natural Natural/show [ 0, 1, 2 ]
− tests/typecheck/success/prelude/Text/concatMapSep/0B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Text/concatMapSep/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Text/concatMapSep ", " Natural Natural/show ([] : List Natural)
− tests/typecheck/success/prelude/Text/concatMapSep/1B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Text/concatSep/0A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Text/concatSep ", " [ "ABC", "DEF", "GHI" ]
− tests/typecheck/success/prelude/Text/concatSep/0B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/prelude/Text/concatSep/1A.dhall 
@@ -1,1 +0,0 @@-../../../../../../Prelude/Text/concatSep ", " ([] : List Text)
− tests/typecheck/success/prelude/Text/concatSep/1B.dhall 
@@ -1,1 +0,0 @@-Text
− tests/typecheck/success/recordOfRecordOfTypesA.dhall 
@@ -1,3 +0,0 @@-let types = { Scopes = < Public : {} | Private : {} >}-let prelude = { types = types }-in  prelude.types.Scopes.Public {=}
− tests/typecheck/success/recordOfRecordOfTypesB.dhall 
@@ -1,1 +0,0 @@-< Public : {} | Private : {} >
− tests/typecheck/success/recordOfTypesA.dhall 
@@ -1,1 +0,0 @@-{ x = Text, y = List }
− tests/typecheck/success/recordOfTypesB.dhall 
@@ -1,1 +0,0 @@-{ x : Type, y : Type → Type }
− tests/typecheck/success/simple/access/0A.dhall 
@@ -1,1 +0,0 @@-{ x = Text }.x
− tests/typecheck/success/simple/access/0B.dhall 
@@ -1,1 +0,0 @@-Type
− tests/typecheck/success/simple/access/1A.dhall 
@@ -1,1 +0,0 @@-< Foo : Text | Bar : Natural >.Foo
− tests/typecheck/success/simple/access/1B.dhall 
@@ -1,1 +0,0 @@-∀(Foo : Text) → < Bar : Natural | Foo : Text >
− tests/typecheck/success/simple/alternativesAreTypesA.dhall 
@@ -1,1 +0,0 @@-< Left = List | Right : Type >
− tests/typecheck/success/simple/alternativesAreTypesB.dhall 
@@ -1,1 +0,0 @@-< Left : Type → Type | Right : Type >
− tests/typecheck/success/simple/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/success/simple/anonymousFunctionsInTypesB.dhall 
@@ -1,4 +0,0 @@-  ∀(HigherOrderType : (Type → Type) → Type)-→ ∀(x : HigherOrderType (λ(a : Type) → List a))-→ HigherOrderType (λ(a : Type) → List a)-
− tests/typecheck/success/simple/fieldsAreTypesA.dhall 
@@ -1,1 +0,0 @@-{ x = Bool, y = Text, z = List }
− tests/typecheck/success/simple/fieldsAreTypesB.dhall 
@@ -1,1 +0,0 @@-{ x : Type, y : Type, z : Type → Type }
− tests/typecheck/success/simple/kindParameterA.dhall 
@@ -1,1 +0,0 @@-λ(k : Kind) → λ(a : k → k → Type) → λ(x : k) → a x
− tests/typecheck/success/simple/kindParameterB.dhall 
@@ -1,1 +0,0 @@-∀(k : Kind) → (k → k → Type) → k → k → Type
− tests/typecheck/success/simple/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/success/simple/mergeEquivalenceB.dhall 
@@ -1,1 +0,0 @@-∀(a : Type) → ∀(f : {} → a) → ∀(ts : < Bar : {} | Baz : {} >) → a
− tests/typecheck/success/simple/mixedFieldAccessA.dhall 
@@ -1,7 +0,0 @@--- Verify that users can use `.` to both access a record field and a union--- constructor within the same expression.  This is a common idiom if a user--- provides a types package.--let Scope = < Public : {} | Private : {} >-let types = { Scope = Scope }-in types.Scope.Public {=}
− tests/typecheck/success/simple/mixedFieldAccessB.dhall 
@@ -1,1 +0,0 @@-< Private : {} | Public : {} >
− tests/typecheck/success/simple/unionsOfTypesA.dhall 
@@ -1,1 +0,0 @@-< Left = List | Right : Type >
− tests/typecheck/success/simple/unionsOfTypesB.dhall 
@@ -1,1 +0,0 @@-< Left : Type → Type | Right : Type >