packages feed

dhall 1.24.0 → 1.25.0

raw patch · 858 files changed

+3690/−1449 lines, 858 filesdep +eitherdep +gaugedep +spoondep −criteriondep ~ansi-terminaldep ~basedep ~deepseqbinary-addedPVP ok

version bump matches the API change (PVP)

Dependencies added: either, gauge, spoon, th-lift-instances

Dependencies removed: criterion

Dependency ranges changed: ansi-terminal, base, deepseq, memory, profunctors, semigroups

API changes (from Hackage documentation)

- 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.Binary: instance Dhall.Binary.ToTerm a => Dhall.Binary.ToTerm (Dhall.Core.Expr s a)
- Dhall.Core: OptionalLit :: Expr s a -> Maybe (Expr s a) -> Expr s a
- Dhall.Import: cacher :: Functor f => LensLike' f (Status m) (Import -> Expr Src X -> StateT (Status m) m ())
- Dhall.Import: exprFromImport :: Import -> StateT (Status IO) IO Resolved
- Dhall.Import: exprToImport :: Import -> Expr Src X -> StateT (Status IO) IO ()
- Dhall.Import: manager :: Functor f => LensLike' f (Status m) (Maybe Dynamic)
- Dhall.Import: resolver :: Functor f => LensLike' f (Status m) (Import -> StateT (Status m) m Resolved)
- 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.Map: instance (GHC.Classes.Eq k, GHC.Classes.Eq v) => GHC.Classes.Eq (Dhall.Map.Map k v)
- Dhall.Map: instance Data.Foldable.Foldable (Dhall.Map.Map k)
- Dhall.Map: instance Data.Traversable.Traversable (Dhall.Map.Map k)
- Dhall.Map: traverseWithKey_ :: Ord k => Applicative f => (k -> a -> f ()) -> Map k a -> f ()
- Dhall.TypeCheck: ConstructorsRequiresAUnionType :: Expr s a -> Expr s a -> TypeMessage s a
- Dhall.TypeCheck: InvalidField :: Text -> 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: instance Data.Data.Data Dhall.TypeCheck.X
- Dhall.TypeCheck: instance Data.Text.Prettyprint.Doc.Internal.Pretty Dhall.TypeCheck.X
- Dhall.TypeCheck: instance Dhall.Binary.FromTerm Dhall.TypeCheck.X
- Dhall.TypeCheck: instance Dhall.Binary.ToTerm Dhall.TypeCheck.X
- Dhall.TypeCheck: instance GHC.Classes.Eq Dhall.TypeCheck.X
- Dhall.TypeCheck: instance GHC.Show.Show Dhall.TypeCheck.X
+ Dhall: ExtractErrors :: NonEmpty (ExtractError s a) -> ExtractErrors s a
+ Dhall: [getErrors] :: ExtractErrors s a -> NonEmpty (ExtractError s a)
+ Dhall: extractError :: Text -> Extractor s a b
+ Dhall: fromMonadic :: MonadicExtractor s a b -> Extractor s a b
+ 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.ExtractError 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.Exception.Type.Exception (Dhall.ExtractErrors 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.ExtractError 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.ExtractErrors s a)
+ Dhall: instance (Data.Text.Prettyprint.Doc.Internal.Pretty s, Data.Typeable.Internal.Typeable s, Data.Text.Prettyprint.Doc.Internal.Pretty a, Data.Typeable.Internal.Typeable a) => GHC.Exception.Type.Exception (Dhall.InvalidType s a)
+ Dhall: instance GHC.Base.Semigroup (Dhall.ExtractErrors s a)
+ Dhall: newtype ExtractErrors s a
+ Dhall: toMonadic :: Extractor s a b -> MonadicExtractor s a b
+ Dhall: type Extractor s a = Validation (ExtractErrors s a)
+ Dhall: type MonadicExtractor s a = Either (ExtractErrors s a)
+ Dhall: typeError :: Expr s a -> Expr s a -> Extractor s a b
+ Dhall.Binary: instance Dhall.Binary.FromTerm Dhall.X.X
+ Dhall.Binary: instance Dhall.Binary.ToTerm Dhall.X.X
+ Dhall.Binary: instance Dhall.Binary.ToTerm a => Dhall.Binary.ToTerm (Dhall.Core.Expr Dhall.X.X a)
+ Dhall.Core: Location :: ImportMode
+ Dhall.Core: ToMap :: Expr s a -> Maybe (Expr s a) -> Expr s a
+ Dhall.Core: instance (Control.DeepSeq.NFData s, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Dhall.Core.Binding s a)
+ Dhall.Core: instance (Control.DeepSeq.NFData s, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Dhall.Core.Chunks s a)
+ Dhall.Core: instance (Control.DeepSeq.NFData s, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Dhall.Core.Expr s a)
+ Dhall.Core: instance (Language.Haskell.TH.Syntax.Lift s, Language.Haskell.TH.Syntax.Lift a, Data.Data.Data s, Data.Data.Data a) => Language.Haskell.TH.Syntax.Lift (Dhall.Core.Binding s a)
+ Dhall.Core: instance (Language.Haskell.TH.Syntax.Lift s, Language.Haskell.TH.Syntax.Lift a, Data.Data.Data s, Data.Data.Data a) => Language.Haskell.TH.Syntax.Lift (Dhall.Core.Chunks s a)
+ Dhall.Core: instance (Language.Haskell.TH.Syntax.Lift s, Language.Haskell.TH.Syntax.Lift a, Data.Data.Data s, Data.Data.Data a) => Language.Haskell.TH.Syntax.Lift (Dhall.Core.Expr s a)
+ Dhall.Core: instance Control.DeepSeq.NFData Dhall.Core.Const
+ Dhall.Core: instance Control.DeepSeq.NFData Dhall.Core.Directory
+ Dhall.Core: instance Control.DeepSeq.NFData Dhall.Core.File
+ Dhall.Core: instance Control.DeepSeq.NFData Dhall.Core.FilePrefix
+ Dhall.Core: instance Control.DeepSeq.NFData Dhall.Core.Import
+ Dhall.Core: instance Control.DeepSeq.NFData Dhall.Core.ImportHashed
+ Dhall.Core: instance Control.DeepSeq.NFData Dhall.Core.ImportMode
+ Dhall.Core: instance Control.DeepSeq.NFData Dhall.Core.ImportType
+ Dhall.Core: instance Control.DeepSeq.NFData Dhall.Core.Scheme
+ Dhall.Core: instance Control.DeepSeq.NFData Dhall.Core.URL
+ Dhall.Core: instance Control.DeepSeq.NFData Dhall.Core.Var
+ Dhall.Core: instance Language.Haskell.TH.Syntax.Lift Dhall.Core.Const
+ Dhall.Core: instance Language.Haskell.TH.Syntax.Lift Dhall.Core.Var
+ Dhall.Core: shallowDenote :: Expr s a -> Expr s a
+ Dhall.Import: Depends :: Chained -> Chained -> Depends
+ Dhall.Import: [child] :: Depends -> Chained
+ Dhall.Import: [parent] :: Depends -> Chained
+ Dhall.Import: chainImport :: Chained -> Import -> StateT Status IO Chained
+ Dhall.Import: chainedChangeMode :: ImportMode -> Chained -> Chained
+ Dhall.Import: chainedFromLocalHere :: FilePrefix -> File -> ImportMode -> Chained
+ Dhall.Import: chainedImport :: Chained -> Import
+ Dhall.Import: data Chained
+ Dhall.Import: data Depends
+ Dhall.Import: data ImportSemantics
+ Dhall.Import: graph :: Functor f => LensLike' f Status [Depends]
+ Dhall.Import: localToPath :: MonadIO io => FilePrefix -> File -> io FilePath
+ Dhall.Import: remote :: Functor f => LensLike' f Status (URL -> StateT Status IO Text)
+ Dhall.Import: toHeaders :: Expr s a -> [HTTPHeader]
+ Dhall.Import: writeExpressionToSemanticCache :: Expr Src X -> IO ()
+ Dhall.Main: Text :: Maybe FilePath -> Mode
+ Dhall.Map: elems :: Ord k => Map k v -> [v]
+ Dhall.Map: fromListWithKey :: Ord k => (k -> v -> v -> v) -> [(k, v)] -> Map k v
+ Dhall.Map: instance (Control.DeepSeq.NFData k, Control.DeepSeq.NFData v) => Control.DeepSeq.NFData (Dhall.Map.Map k v)
+ Dhall.Map: instance (Data.Data.Data a, Language.Haskell.TH.Syntax.Lift a) => Language.Haskell.TH.Syntax.Lift (Dhall.Map.Keys a)
+ Dhall.Map: instance (Data.Data.Data k, Data.Data.Data v, Language.Haskell.TH.Syntax.Lift k, Language.Haskell.TH.Syntax.Lift v, GHC.Classes.Ord k) => Language.Haskell.TH.Syntax.Lift (Dhall.Map.Map k v)
+ Dhall.Map: instance (GHC.Classes.Ord k, GHC.Classes.Eq v) => GHC.Classes.Eq (Dhall.Map.Map k v)
+ Dhall.Map: instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Dhall.Map.Keys a)
+ Dhall.Map: instance Data.Data.Data a => Data.Data.Data (Dhall.Map.Keys a)
+ Dhall.Map: instance GHC.Classes.Ord k => Data.Foldable.Foldable (Dhall.Map.Map k)
+ Dhall.Map: instance GHC.Classes.Ord k => Data.Traversable.Traversable (Dhall.Map.Map k)
+ Dhall.Map: instance GHC.Generics.Generic (Dhall.Map.Keys a)
+ Dhall.Map: instance GHC.Generics.Generic (Dhall.Map.Map k v)
+ Dhall.Map: keysSet :: Map k v -> Set k
+ Dhall.Map: outerJoin :: Ord k => (a -> c) -> (b -> c) -> (k -> a -> b -> c) -> Map k a -> Map k b -> Map k c
+ Dhall.Map: restrictKeys :: Ord k => Map k a -> Set k -> Map k a
+ Dhall.Map: size :: Map k v -> Int
+ Dhall.Map: unorderedFromList :: Ord k => [(k, v)] -> Map k v
+ Dhall.Map: unorderedSingleton :: k -> v -> Map k v
+ Dhall.Map: unorderedTraverseWithKey :: Ord k => Applicative f => (k -> a -> f b) -> Map k a -> f (Map k b)
+ Dhall.Parser.Expression: Parsers :: Parser (Expr Src a) -> Parser (Expr Src a) -> Parsers a
+ Dhall.Parser.Expression: [completeExpression_] :: Parsers a -> Parser (Expr Src a)
+ Dhall.Parser.Expression: [importExpression_] :: Parsers a -> Parser (Expr Src a)
+ Dhall.Parser.Expression: completeExpression :: Parser a -> Parser (Expr Src a)
+ Dhall.Parser.Expression: data Parsers a
+ Dhall.Parser.Expression: dropLiteral :: Int -> Chunks s a -> Chunks s a
+ Dhall.Parser.Expression: emptyLine :: Chunks s a -> Bool
+ Dhall.Parser.Expression: env :: Parser ImportType
+ Dhall.Parser.Expression: getOffset :: MonadParsec e s m => m Int
+ Dhall.Parser.Expression: getSourcePos :: MonadParsec e s m => m SourcePos
+ Dhall.Parser.Expression: http :: Parser ImportType
+ Dhall.Parser.Expression: importExpression :: Parser a -> Parser (Expr Src a)
+ Dhall.Parser.Expression: importHash_ :: Parser (Digest SHA256)
+ Dhall.Parser.Expression: importHashed_ :: Parser ImportHashed
+ Dhall.Parser.Expression: importType_ :: Parser ImportType
+ Dhall.Parser.Expression: import_ :: Parser Import
+ Dhall.Parser.Expression: leadingSpaces :: Chunks s a -> Text
+ Dhall.Parser.Expression: linesLiteral :: Chunks s a -> NonEmpty (Chunks s a)
+ Dhall.Parser.Expression: local :: Parser ImportType
+ Dhall.Parser.Expression: localRaw :: Parser ImportType
+ Dhall.Parser.Expression: missing :: Parser ImportType
+ Dhall.Parser.Expression: noted :: Parser (Expr Src a) -> Parser (Expr Src a)
+ Dhall.Parser.Expression: parsers :: Parser a -> Parsers a
+ Dhall.Parser.Expression: renderChunks :: Chunks s a -> Text
+ Dhall.Parser.Expression: setOffset :: MonadParsec e s m => Int -> m ()
+ Dhall.Parser.Expression: splitOn :: Text -> Text -> NonEmpty Text
+ Dhall.Parser.Expression: toDoubleQuoted :: Chunks Src a -> Chunks Src a
+ Dhall.Parser.Expression: unlinesLiteral :: NonEmpty (Chunks s a) -> Chunks s a
+ Dhall.Parser.Token: FileComponent :: ComponentType
+ Dhall.Parser.Token: URLComponent :: ComponentType
+ Dhall.Parser.Token: _Bool :: Parser ()
+ Dhall.Parser.Token: _Double :: Parser ()
+ Dhall.Parser.Token: _DoubleShow :: Parser ()
+ Dhall.Parser.Token: _False :: Parser ()
+ Dhall.Parser.Token: _Integer :: Parser ()
+ Dhall.Parser.Token: _IntegerShow :: Parser ()
+ Dhall.Parser.Token: _IntegerToDouble :: Parser ()
+ Dhall.Parser.Token: _Kind :: Parser ()
+ Dhall.Parser.Token: _List :: Parser ()
+ Dhall.Parser.Token: _ListBuild :: Parser ()
+ Dhall.Parser.Token: _ListFold :: Parser ()
+ Dhall.Parser.Token: _ListHead :: Parser ()
+ Dhall.Parser.Token: _ListIndexed :: Parser ()
+ Dhall.Parser.Token: _ListLast :: Parser ()
+ Dhall.Parser.Token: _ListLength :: Parser ()
+ Dhall.Parser.Token: _ListReverse :: Parser ()
+ Dhall.Parser.Token: _Location :: Parser ()
+ Dhall.Parser.Token: _NaN :: Parser ()
+ Dhall.Parser.Token: _Natural :: Parser ()
+ Dhall.Parser.Token: _NaturalBuild :: Parser ()
+ Dhall.Parser.Token: _NaturalEven :: Parser ()
+ Dhall.Parser.Token: _NaturalFold :: Parser ()
+ Dhall.Parser.Token: _NaturalIsZero :: Parser ()
+ Dhall.Parser.Token: _NaturalOdd :: Parser ()
+ Dhall.Parser.Token: _NaturalShow :: Parser ()
+ Dhall.Parser.Token: _NaturalToInteger :: Parser ()
+ Dhall.Parser.Token: _None :: Parser ()
+ Dhall.Parser.Token: _Optional :: Parser ()
+ Dhall.Parser.Token: _OptionalBuild :: Parser ()
+ Dhall.Parser.Token: _OptionalFold :: Parser ()
+ Dhall.Parser.Token: _Some :: Parser ()
+ Dhall.Parser.Token: _Sort :: Parser ()
+ Dhall.Parser.Token: _Text :: Parser ()
+ Dhall.Parser.Token: _TextShow :: Parser ()
+ Dhall.Parser.Token: _True :: Parser ()
+ Dhall.Parser.Token: _Type :: Parser ()
+ Dhall.Parser.Token: _and :: Parser ()
+ Dhall.Parser.Token: _arrow :: Parser ()
+ Dhall.Parser.Token: _as :: Parser ()
+ Dhall.Parser.Token: _at :: Parser ()
+ Dhall.Parser.Token: _bar :: Parser ()
+ Dhall.Parser.Token: _closeAngle :: Parser ()
+ Dhall.Parser.Token: _closeBrace :: Parser ()
+ Dhall.Parser.Token: _closeBracket :: Parser ()
+ Dhall.Parser.Token: _closeParens :: Parser ()
+ Dhall.Parser.Token: _colon :: Parser ()
+ Dhall.Parser.Token: _combine :: Parser ()
+ Dhall.Parser.Token: _combineTypes :: Parser ()
+ Dhall.Parser.Token: _comma :: Parser ()
+ Dhall.Parser.Token: _dot :: Parser ()
+ Dhall.Parser.Token: _doubleEqual :: Parser ()
+ Dhall.Parser.Token: _else :: Parser ()
+ Dhall.Parser.Token: _equal :: Parser ()
+ Dhall.Parser.Token: _forall :: Parser ()
+ Dhall.Parser.Token: _if :: Parser ()
+ Dhall.Parser.Token: _importAlt :: Parser ()
+ Dhall.Parser.Token: _in :: Parser ()
+ Dhall.Parser.Token: _lambda :: Parser ()
+ Dhall.Parser.Token: _let :: Parser ()
+ Dhall.Parser.Token: _listAppend :: Parser ()
+ Dhall.Parser.Token: _merge :: Parser ()
+ Dhall.Parser.Token: _missing :: Parser ()
+ Dhall.Parser.Token: _notEqual :: Parser ()
+ Dhall.Parser.Token: _openAngle :: Parser ()
+ Dhall.Parser.Token: _openBrace :: Parser ()
+ Dhall.Parser.Token: _openBracket :: Parser ()
+ Dhall.Parser.Token: _openParens :: Parser ()
+ Dhall.Parser.Token: _or :: Parser ()
+ Dhall.Parser.Token: _plus :: Parser ()
+ Dhall.Parser.Token: _prefer :: Parser ()
+ Dhall.Parser.Token: _textAppend :: Parser ()
+ Dhall.Parser.Token: _then :: Parser ()
+ Dhall.Parser.Token: _times :: Parser ()
+ Dhall.Parser.Token: _toMap :: Parser ()
+ Dhall.Parser.Token: _using :: Parser ()
+ Dhall.Parser.Token: anyLabel :: Parser Text
+ Dhall.Parser.Token: bashEnvironmentVariable :: Parser Text
+ Dhall.Parser.Token: data ComponentType
+ Dhall.Parser.Token: doubleInfinity :: Parser Double
+ Dhall.Parser.Token: doubleLiteral :: Parser Double
+ Dhall.Parser.Token: file_ :: ComponentType -> Parser File
+ Dhall.Parser.Token: hexNumber :: Parser Int
+ Dhall.Parser.Token: hexdig :: Char -> Bool
+ Dhall.Parser.Token: httpRaw :: Parser URL
+ Dhall.Parser.Token: identifier :: Parser Var
+ Dhall.Parser.Token: integerLiteral :: Parser Integer
+ Dhall.Parser.Token: label :: Parser Text
+ Dhall.Parser.Token: labels :: Parser (Set Text)
+ Dhall.Parser.Token: naturalLiteral :: Parser Natural
+ Dhall.Parser.Token: posixEnvironmentVariable :: Parser Text
+ Dhall.Parser.Token: validCodepoint :: Char -> Bool
+ Dhall.Parser.Token: whitespace :: Parser ()
+ Dhall.Set: fromSet :: Set a -> Set a
+ Dhall.Set: instance (Data.Data.Data a, Language.Haskell.TH.Syntax.Lift a, GHC.Classes.Ord a) => Language.Haskell.TH.Syntax.Lift (Dhall.Set.Set a)
+ Dhall.Set: instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Dhall.Set.Set a)
+ Dhall.Set: isSorted :: Ord a => Set a -> Bool
+ Dhall.Set: null :: Set a -> Bool
+ Dhall.Set: sort :: Ord a => Set a -> Set a
+ Dhall.Src: instance Control.DeepSeq.NFData Dhall.Src.Src
+ Dhall.Src: instance Language.Haskell.TH.Syntax.Lift Dhall.Src.Src
+ Dhall.TypeCheck: HeterogenousRecordToMap :: Expr s a -> Expr s a -> Expr s a -> TypeMessage s a
+ Dhall.TypeCheck: InvalidToMapType :: Expr s a -> TypeMessage s a
+ Dhall.TypeCheck: MapTypeMismatch :: Expr s a -> Expr s a -> TypeMessage s a
+ Dhall.TypeCheck: MissingConstructor :: Text -> Expr s a -> TypeMessage s a
+ Dhall.TypeCheck: MissingToMapType :: TypeMessage s a
+ Dhall.TypeCheck: MustMapARecord :: Expr s a -> Expr s a -> TypeMessage s a
+ Dhall.TypeCheck: ProjectionTypeMismatch :: Text -> Expr s a -> Expr s a -> Expr s a -> Expr s a -> TypeMessage s 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)) (Extractor Src X)) a -> RecordType a
- Dhall: Type :: (Expr Src X -> Maybe a) -> Expr Src X -> Type a
+ Dhall: Type :: (Expr Src X -> Extractor Src X a) -> Expr Src X -> Type a
- Dhall: [extract] :: Type a -> Expr Src X -> Maybe a
+ Dhall: [extract] :: Type a -> Expr Src X -> Extractor Src X a
- Dhall.Binary: decodeExpression :: Term -> Either DecodingFailure (Expr s Import)
+ Dhall.Binary: decodeExpression :: FromTerm a => Term -> Either DecodingFailure (Expr s a)
- Dhall.Context: lookup :: Text -> Integer -> Context a -> Maybe a
+ Dhall.Context: lookup :: Text -> Int -> Context a -> Maybe a
- Dhall.Core: V :: Text -> !Integer -> Var
+ Dhall.Core: V :: Text -> !Int -> Var
- Dhall.Core: shift :: Integer -> Var -> Expr s a -> Expr s a
+ Dhall.Core: shift :: Int -> Var -> Expr s a -> Expr s a
- Dhall.Import: Imported :: NonEmpty Import -> e -> Imported e
+ Dhall.Import: Imported :: NonEmpty Chained -> e -> Imported e
- Dhall.Import: [importStack] :: Imported e -> NonEmpty Import
+ Dhall.Import: [importStack] :: Imported e -> NonEmpty Chained
- Dhall.Import: cache :: Functor f => LensLike' f (Status m) (Map Import (NodeId, Expr Src X))
+ Dhall.Import: cache :: Functor f => LensLike' f Status (Map Chained ImportSemantics)
- Dhall.Import: data Status m
+ Dhall.Import: data Status
- Dhall.Import: emptyStatus :: FilePath -> Status IO
+ Dhall.Import: emptyStatus :: FilePath -> Status
- Dhall.Import: loadWith :: MonadCatch m => Expr Src Import -> StateT (Status m) m (Expr Src X)
+ Dhall.Import: loadWith :: Expr Src Import -> StateT Status IO (Expr Src X)
- Dhall.Import: normalizer :: Functor f => LensLike' f (Status m) (Maybe (ReifiedNormalizer X))
+ Dhall.Import: normalizer :: Functor f => LensLike' f Status (Maybe (ReifiedNormalizer X))
- Dhall.Import: stack :: Functor f => LensLike' f (Status m) (NonEmpty Import)
+ Dhall.Import: stack :: Functor f => LensLike' f Status (NonEmpty Chained)
- Dhall.Import: standardVersion :: Functor f => LensLike' f (Status m) StandardVersion
+ Dhall.Import: standardVersion :: Functor f => LensLike' f Status StandardVersion
- Dhall.Import: startingContext :: Functor f => LensLike' f (Status m) (Context (Expr Src X))
+ Dhall.Import: startingContext :: Functor f => LensLike' f Status (Context (Expr Src X))
- Dhall.Map: sort :: Ord k => Map k v -> Map k v
+ Dhall.Map: sort :: Map k v -> Map k v

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

Files

CHANGELOG.md view
@@ -1,3 +1,118 @@+1.25.0++* Supports version 8.0.0 of the standard+    * See: https://github.com/dhall-lang/dhall-lang/releases/tag/v8.0.0+* BREAKING CHANGE: Remove support for old-style `List`-like `Optional` literals+    * List-like `Optional` Literals (i.e. `[ 1 ] : Optional Natural`) are no+      longer valid+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1002+* BREAKING CHANGE: Add support for semi-semantic caching+    * This change significantly improves the performance of imports+    * This change also automatically caches imports without an integrity check+    * This changes several types in `Dhall.Import` to support this new+      feature+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1113+* BREAKING CHANGE: Implement new Unicode braced escape sequence+    * Escape sequences encoding surrogate pairs are no longer valid+    * Instead, characters previously encoded as surrogate pairs can instead be+      encoded as a braced sequence+    * For example: "\uD834\uDD1E" must now be written as "\u{1D11E}"+    * See: https://github.com/dhall-lang/dhall-haskell/pull/987+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1104+* BREAKING CHANGE: Make the type of extract richer:+    * `Dhall.extract` can now return a detailed error instead of just a `Maybe`+    * This is a breaking chnage because the type of `extract` changed+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1011+* BREAKING CHANGE: Add support for importing expressions `as Location`+    * This is a breaking change because a new `Location` constructor was added+      to `ImportMode`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1019+* BREAKING CHANGE: Switch `Var` to use an `Int`+    * This is a performance improvement, but also a breaking change since the+      `Integer` in the `Var` constructor was changed to an `Int`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1044+* BREAKING CHANGE: Add new `toMap` keyword+    * This is a breaking change to the API because a new `ToMap` constructor+      was added to the `Expr` type+    * This is also a technically breaking change to the language because `toMap`+      is now a reserved keyword, although most code should be unaffected in+      practice+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1041+* BREAKING CHANGE: Sort the fields of a record projection during normalization+    * This is a technically breaking change to the language because any+      expressions with an uninterpreted record projection will have a different+      semantic integrity check.  However, most could should be unaffected in+      practice+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1111+* BUG FIX: Fix substitution into record projection by type+    * An expression like this one was being incorrectly rejected:+      `let e = { a = 10, b = "Text" } let s = { a : Natural } in e.(s)`, which+      this change fixes+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1012+* BUG FIX: Reject record projection when there is a field type mismatch+    * Record projection by type was previously not checking the expected+      field types, which this change fixes+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1027+* BUG FIX: Fix linting of unused let bindings+    * Certain let bindings were not correctly detected as unused, which this+      change fixes+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1001+* BUG FIX: Fix `--file` option+    * The `--file` option from the previous release did not work, due to not+      computing relative paths correctly, which this change fixes+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1004+* BUG FIX: Minor fix to `dhall diff`+    * `dhall diff` was incorrectly displaying spurious differences for+      identical lists that were function arguments, which this change fixes+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1006+* BUG FIX: Allow `Sort` as type annotation+    * This should have been implemented in the previous release as part of+      supporting version 8.0.0 of the standard, but was missed+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1024+* BUG FIX: `Dhall.Map`: Reflect original key ordering in `Ord` instance+    * `Dhall.Map` now considers key order when comparing `Map`s, which it should+      have done before, but didn't+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1050+* BUG FIX: Consistently format multi-line strings+    * The formatter now formats naked multi-line strings the same as nested+      multi-line strings+    * Specifically, naked multi-line strings can now be formatted on a single+      (just like nested multi-line strings)+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1056+* BUG FIX: Make `isNormalized` consistent with `normalize`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1115+* BUG FIX: Make `normalizeWithM` consistent with `normalize`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1126+* BUG FIX: Fix import alternatives to recover from type errors+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1152+* Feature: Semi-semantic caching+    * The Haskell implementation now implicitly caches *all* local imports, not+      just imports frozen by integrity checks, so that you don't have to freeze+      them when doing local development+    * These cached imports are still correctly invalidated if they or any of+      their dependencies change+    * This new implicit cache is stored underneath `~/.cache/dhall-haskell` by+      default+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1154+* Feature: New `dhall text` subcommand+    * This new subcommand supersedes the old `dhall-to-text` executable+* Feature: Add `instance Lift (Expr s a)`+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1119+* Fixes and improvements to error messages:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1030+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1137+* Fixes and improvements to tests:+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1155+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1159+* Performance improvements+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1036+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1051+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1048+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1057+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1065+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1066+    * See: https://github.com/dhall-lang/dhall-haskell/pull/1085+ 1.24.0  * Supports version 8.0.0 of the standard
benchmark/deep-nested-large-record/Main.hs view
@@ -1,13 +1,13 @@ {-# LANGUAGE OverloadedStrings #-} module Main (main) where -import Criterion.Main (defaultMain)+import Gauge(defaultMain) -import qualified Criterion as Criterion import qualified Data.Sequence as Seq import qualified Dhall.Core as Core import qualified Dhall.Import as Import import qualified Dhall.TypeCheck as TypeCheck+import qualified Gauge  dhallPreludeImport :: Core.Import dhallPreludeImport = Core.Import@@ -21,8 +21,8 @@     }   } -issue412 :: Core.Expr s TypeCheck.X -> Criterion.Benchmarkable-issue412 prelude = Criterion.whnf TypeCheck.typeOf expr+issue412 :: Core.Expr s TypeCheck.X -> Gauge.Benchmarkable+issue412 prelude = Gauge.whnf TypeCheck.typeOf expr   where     expr       = Core.Let (pure (Core.Binding "prelude" Nothing prelude))@@ -30,8 +30,8 @@       $ Seq.replicate 5       $ Core.Var (Core.V "prelude" 0) `Core.Field` "types" `Core.Field` "Little" `Core.Field` "Foo" -unionPerformance :: Core.Expr s TypeCheck.X -> Criterion.Benchmarkable-unionPerformance prelude = Criterion.whnf TypeCheck.typeOf expr+unionPerformance :: Core.Expr s TypeCheck.X -> Gauge.Benchmarkable+unionPerformance prelude = Gauge.whnf TypeCheck.typeOf expr   where     innerBinding =         Core.Binding "big" Nothing@@ -47,6 +47,6 @@ main = do   prelude <- Import.load (Core.Embed dhallPreludeImport)   defaultMain-    [ Criterion.bench "issue 412" (issue412 prelude)-    , Criterion.bench "union performance" (unionPerformance prelude)+    [ Gauge.bench "issue 412" (issue412 prelude)+    , Gauge.bench "union performance" (unionPerformance prelude)     ]
benchmark/deep-nested-large-record/prelude.dhall view
@@ -1,5 +1,5 @@ { types =-  { Big = constructors ./BigEnum.dhall-  , Little = constructors ./LittleEnum.dhall+  { Big = ./BigEnum.dhall+  , Little = ./LittleEnum.dhall   } }
− benchmark/dhall-command/Main.hs 
@@ -1,20 +0,0 @@--{-# LANGUAGE OverloadedStrings #-}--module Main where--import qualified Dhall.Main as Main-import           Dhall.Binary (defaultStandardVersion)--options :: Main.Options-options = Main.Options-  { Main.mode = Main.Default Nothing False False-  , Main.explain = False-  , Main.plain = False-  , Main.ascii = False-  , Main.standardVersion = defaultStandardVersion-  }--main :: IO ()-main = do-  Main.command options
− benchmark/map/Main.hs 
@@ -1,44 +0,0 @@-{-# LANGUAGE BangPatterns     #-}-{-# LANGUAGE TypeApplications #-}--module Main where--import Criterion.Main (defaultMain, bgroup, bench, whnf, nfIO)--import qualified Criterion.Main as Criterion-import qualified Dhall.Map as Map--testData :: Integer -> Map.Map Integer Integer-testData i = foldr (\j -> Map.insert j j) mempty [1 .. i]--benchOrderedTraversal :: String -> Map.Map Integer Integer -> Criterion.Benchmark-benchOrderedTraversal dataLabel mapData =-    bgroup ("Ordered Traversals: " <> dataLabel)-        [ bench "traverseWithKey" $-            whnf (Map.traverseWithKey (\_ i -> pure @Maybe $ i ^ i)) mapData-        , bench "traverseWithKey_" $-            whnf (Map.traverseWithKey_ (\_ i -> pure @Maybe (i ^ i) *> pure ())) mapData-        ]--benchUnorderedTraversal :: String -> Map.Map Integer Integer -> Criterion.Benchmark-benchUnorderedTraversal dataLabel mapData =-    bgroup ("Unordered Traversals: " <> dataLabel)-        [ bench "unorderedTraverseWithKey_" $-            whnf (Map.unorderedTraverseWithKey_ (\_ i -> pure @Maybe (i ^ i) *> pure ())) mapData-        ]--main :: IO ()-main = do-    let !smallMap  = testData 10-        !mediumMap = testData 1000-        !largeMap  = testData 100000-    defaultMain-        [ benchOrderedTraversal   "small" smallMap-        , benchUnorderedTraversal "small" smallMap--        , benchOrderedTraversal   "medium" mediumMap-        , benchUnorderedTraversal "medium" mediumMap--        , benchOrderedTraversal   "large"  largeMap-        , benchUnorderedTraversal "large"  largeMap-        ]
benchmark/parser/Main.hs view
@@ -4,18 +4,19 @@ module Main where  import Control.Monad (forM)-import Criterion.Main (defaultMain, bgroup, bench, whnf, nfIO) import Data.Map (Map, foldrWithKey, singleton, unions) import Data.Monoid ((<>))+import Gauge (defaultMain, bgroup, bench, whnf, nfIO)  import System.Directory  import qualified Codec.Serialise-import qualified Criterion.Main as Criterion+import qualified Gauge import qualified Data.ByteString.Lazy import qualified Data.Text as T import qualified Data.Text.IO as TIO import qualified Dhall.Binary+import qualified Dhall.Core as Dhall import qualified Dhall.Parser as Dhall  #if MIN_VERSION_directory(1,2,3)@@ -38,7 +39,7 @@ type PreludeFiles = Map FilePath T.Text  loadPreludeFiles :: IO PreludeFiles-loadPreludeFiles = loadDirectory "Prelude"+loadPreludeFiles = loadDirectory "./dhall-lang/Prelude"     where         loadDirectory :: FilePath -> IO PreludeFiles         loadDirectory dir =@@ -55,24 +56,25 @@         loadFile :: FilePath -> IO PreludeFiles         loadFile path = singleton path <$> TIO.readFile path -benchParser :: PreludeFiles -> Criterion.Benchmark+benchParser :: PreludeFiles -> Gauge.Benchmark benchParser =       bgroup "exprFromText"     . foldrWithKey (\name expr -> (benchExprFromText name expr :)) [] -benchExprFromText :: String -> T.Text -> Criterion.Benchmark+benchExprFromText :: String -> T.Text -> Gauge.Benchmark benchExprFromText name expr =     bench name $ whnf (Dhall.exprFromText "(input)") expr  benchExprFromBytes-    :: String -> Data.ByteString.Lazy.ByteString -> Criterion.Benchmark+    :: String -> Data.ByteString.Lazy.ByteString -> Gauge.Benchmark benchExprFromBytes name bytes = bench name (whnf f bytes)   where     f bytes = do         term <- case Codec.Serialise.deserialiseOrFail bytes of             Left  _    -> Nothing             Right term -> return term-        case Dhall.Binary.decodeExpression term of+        case Dhall.Binary.decodeExpression term+          :: Either Dhall.Binary.DecodingFailure (Dhall.Expr () Dhall.Import) of             Left  _          -> Nothing             Right expression -> return expression
dhall-lang/Prelude/JSON/Tagged view
@@ -62,6 +62,16 @@ -} let Tagged     : Type → Type-    = λ(a : Type) → { field : Text, nesting : ./Nesting, contents : a }+    =   λ ( a+          : Type+          )+      → { field :+            Text+        , nesting :+              ./Nesting sha256:6284802edd41d5d725aa1ec7687e614e21ad1be7e14dd10996bfa9625105c335+            ? ./Nesting+        , contents :+            a+        }  in  Tagged
dhall-lang/Prelude/JSON/package.dhall view
@@ -4,4 +4,25 @@ , keyValue =       ./keyValue sha256:a0a97199d280c4cce72ffcbbf93b7ceda0a569cf4d173ac98e0aaaa78034b98c     ? ./keyValue+, string =+      ./string sha256:7a8ac435d30a96092d72889f3d48eabf7cba47ecf553fd6bc07a79fdf473e8d2+    ? ./string+, number =+      ./number sha256:534745568065ae19d2b0fe1d09eeb071e9717d0f392187eb0bc95f386b018bec+    ? ./number+, object =+      ./object sha256:a4e047cf157c3971b026b3942a87d474c85950d9b9654f8ebc8631740abf75a9+    ? ./object+, array =+      ./array sha256:3a4c06cf135f4c80619e48c0808f6600d19782705bc59ee7c27cfc2e0f097eb7+    ? ./array+, bool =+      ./bool sha256:018d29f030b45d642aba6bb81bf2c19a7bf183684612ce7a2c8afd2099783c48+    ? ./bool+, null =+      ./null sha256:52c1d45ab2ca54875b444bfb1afdea497c8c9b0652e5044fafd8b16d97f4b78d+    ? ./null+, render =+      ./render sha256:81f5a84efbb35211b1556838e86d17ed497912cf765bfa4ab76708b21e5371f1+    ? ./render }
dhall-lang/Prelude/Text/package.dhall view
@@ -1,14 +1,14 @@ { concat =-      ./concat sha256:35e20d9403fbadb1a0061edb84e076ed56313709fa4bc8124d86ff54896f20ac+      ./concat sha256:731265b0288e8a905ecff95c97333ee2db614c39d69f1514cb8eed9259745fc0     ? ./concat , concatMap =-      ./concatMap sha256:175d893ad7f2b2c05fff9e32f0d9cbadc7f5fce57945071508cf3603f8aa298e+      ./concatMap sha256:7a0b0b99643de69d6f94ba49441cd0fa0507cbdfa8ace0295f16097af37e226f     ? ./concatMap , concatMapSep =-      ./concatMapSep sha256:46b81a9e211fb8278bf2793e75e8175fef79e0e3e478ef1016e3233ecc2ddfe6+      ./concatMapSep sha256:c272aca80a607bc5963d1fcb38819e7e0d3e72ac4d02b1183b1afb6a91340840     ? ./concatMapSep , concatSep =-      ./concatSep sha256:d28e61f5057a240e857e09dba1b040fa3477bddb9659c5606c760852a9165890+      ./concatSep sha256:e4401d69918c61b92a4c0288f7d60a6560ca99726138ed8ebc58dca2cd205e58     ? ./concatSep , show =       ./show sha256:c9dc5de3e5f32872dbda57166804865e5e80785abe358ff61f1d8ac45f1f4784
dhall-lang/Prelude/package.dhall view
@@ -13,6 +13,9 @@ , List =       ./List/package.dhall sha256:108be3af5ebd465f7091039f2216c433e65ae5d25556a9a71786dd84d33ef49a     ? ./List/package.dhall+, Map =+      ./Map/package.dhall sha256:07cc274220c8bdb2c1a0c2d00d90bc1447e73e0ad2e1d72b89773e923f77e71e+    ? ./Map/package.dhall , Natural =       ./Natural/package.dhall sha256:fe08155c3a04500df847ca94d013ecd3dfc73ab5c136109b2414fce3ec42b63a     ? ./Natural/package.dhall@@ -20,9 +23,12 @@       ./Optional/package.dhall sha256:36a366af67a3c26cd5d196e095d3023f18953c5b5db3a03956fa554609e5442a     ? ./Optional/package.dhall , JSON =-      ./JSON/package.dhall sha256:7f0c25a292e5d34ddfbbf3f6d90505567382f95d822b04f5810745f81ab1ef35+      ./JSON/package.dhall sha256:34a613c89df3f314c606a813f592d1a09fedb3e5f5e63fcc0ae9c88245e8bdad     ? ./JSON/package.dhall , Text =-      ./Text/package.dhall sha256:c8bc93456397476051dc674c180ddd5db098546861c8df24bda8284511d3305e+      ./Text/package.dhall sha256:3b6ed813caf2388b91056d625c6b958b72009f85a6af262d4a7b935b18caf62b     ? ./Text/package.dhall+, XML =+      ./XML/package.dhall sha256:abace25be73c3ba823abfba92bb3742a0454d521804a5d19ab5dfbf966473a5d+    ? ./XML/package.dhall }
+ dhall-lang/tests/binary-decode/failure/unit/ApplyNoArgs.dhallb view

binary file changed (absent → 6 bytes)

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

binary file changed (absent → 6 bytes)

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

binary file changed (absent → 4 bytes)

+ dhall-lang/tests/binary-decode/failure/unit/NaturalNegativeOne.dhallb view
@@ -0,0 +1,1 @@+‚
+ dhall-lang/tests/binary-decode/failure/unit/OperatorOrTooFewArgs.dhallb view

binary file changed (absent → 4 bytes)

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

binary file changed (absent → 6 bytes)

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

binary file changed (absent → 5 bytes)

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

binary file changed (absent → 6 bytes)

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

binary file changed (absent → 4 bytes)

+ dhall-lang/tests/binary-decode/success/unit/AnnotationA.dhallb view
@@ -0,0 +1,1 @@+ƒ‚gNatural
+ dhall-lang/tests/binary-decode/success/unit/AnnotationB.dhall view
@@ -0,0 +1,1 @@+5 : Natural
+ dhall-lang/tests/binary-decode/success/unit/ApplicationA.dhallb view

binary file changed (absent → 16 bytes)

+ dhall-lang/tests/binary-decode/success/unit/ApplicationB.dhall view
@@ -0,0 +1,1 @@+Natural/show _
+ dhall-lang/tests/binary-decode/success/unit/ApplicationMultipleA.dhallb view

binary file changed (absent → 18 bytes)

+ dhall-lang/tests/binary-decode/success/unit/ApplicationMultipleB.dhall view
@@ -0,0 +1,1 @@+f x y z
+ dhall-lang/tests/binary-decode/success/unit/BoolFalseA.dhallb view
@@ -0,0 +1,1 @@+ô
+ dhall-lang/tests/binary-decode/success/unit/BoolFalseB.dhall view
@@ -0,0 +1,1 @@+False
+ dhall-lang/tests/binary-decode/success/unit/BoolIfA.dhallb view

binary file changed (absent → 11 bytes)

+ dhall-lang/tests/binary-decode/success/unit/BoolIfB.dhall view
@@ -0,0 +1,1 @@+if True then x else y
+ dhall-lang/tests/binary-decode/success/unit/BoolTrueA.dhallb view
@@ -0,0 +1,1 @@+õ
+ dhall-lang/tests/binary-decode/success/unit/BoolTrueB.dhall view
@@ -0,0 +1,1 @@+True
+ dhall-lang/tests/binary-decode/success/unit/BuiltinNaturalShowA.dhallb view
@@ -0,0 +1,1 @@+lNatural/show
+ dhall-lang/tests/binary-decode/success/unit/BuiltinNaturalShowB.dhall view
@@ -0,0 +1,1 @@+Natural/show
+ dhall-lang/tests/binary-decode/success/unit/DoubleDoubleA.dhallb view

binary file changed (absent → 9 bytes)

+ dhall-lang/tests/binary-decode/success/unit/DoubleDoubleB.dhall view
@@ -0,0 +1,6 @@+{-+The CBOR for this is an (oversized) double-precision number.  It could have been+stored as single- (or even half-) precision, but we require decoders to accept+it anyway.+-}+2.0
+ dhall-lang/tests/binary-decode/success/unit/DoubleHalfA.dhallb view

binary file changed (absent → 3 bytes)

+ dhall-lang/tests/binary-decode/success/unit/DoubleHalfB.dhall view
@@ -0,0 +1,7 @@+{-+The CBOR for this is a half-precision number.  Although dhall specifies that+encoders should only use half-precision for infinities and NaN, it also+specifies that decoders should tolerate floating point numbers with any+precision.+-}+1.0
+ dhall-lang/tests/binary-decode/success/unit/DoubleInfinityA.dhallb view

binary file changed (absent → 3 bytes)

+ dhall-lang/tests/binary-decode/success/unit/DoubleInfinityB.dhall view
@@ -0,0 +1,1 @@+Infinity
+ dhall-lang/tests/binary-decode/success/unit/DoubleNegativeInfinityA.dhallb view

binary file changed (absent → 3 bytes)

+ dhall-lang/tests/binary-decode/success/unit/DoubleNegativeInfinityB.dhall view
@@ -0,0 +1,1 @@+-Infinity
+ dhall-lang/tests/binary-decode/success/unit/DoubleSingleA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/DoubleSingleB.dhall view
@@ -0,0 +1,4 @@+{-+The CBOR for this is a single-precision number+-}+2.0
+ dhall-lang/tests/binary-decode/success/unit/IntegerNegativeOneA.dhallb view
@@ -0,0 +1,1 @@+‚
+ dhall-lang/tests/binary-decode/success/unit/IntegerNegativeOneB.dhall view
@@ -0,0 +1,1 @@+-1
+ dhall-lang/tests/binary-decode/success/unit/IntegerZeroA.dhallb view

binary file changed (absent → 3 bytes)

+ dhall-lang/tests/binary-decode/success/unit/IntegerZeroB.dhall view
@@ -0,0 +1,1 @@++0
+ dhall-lang/tests/binary-decode/success/unit/LambdaNamedXA.dhallb view

binary file changed (absent → 9 bytes)

+ dhall-lang/tests/binary-decode/success/unit/LambdaNamedXB.dhall view
@@ -0,0 +1,1 @@+λ(x : _) → x
+ dhall-lang/tests/binary-decode/success/unit/LambdaUnderscoreA.dhallb view

binary file changed (absent → 11 bytes)

+ dhall-lang/tests/binary-decode/success/unit/LambdaUnderscoreB.dhall view
@@ -0,0 +1,1 @@+λ(_ : Natural) → _
+ dhall-lang/tests/binary-decode/success/unit/LetMultipleA.dhallb view

binary file changed (absent → 26 bytes)

+ dhall-lang/tests/binary-decode/success/unit/LetMultipleB.dhall view
@@ -0,0 +1,1 @@+let x : Natural = 1 let y = 2 in x
+ dhall-lang/tests/binary-decode/success/unit/LetOneTypedA.dhallb view

binary file changed (absent → 20 bytes)

+ dhall-lang/tests/binary-decode/success/unit/LetOneTypedB.dhall view
@@ -0,0 +1,1 @@+let x : Natural = 1 in x
+ dhall-lang/tests/binary-decode/success/unit/LetOneUntypedA.dhallb view

binary file changed (absent → 13 bytes)

+ dhall-lang/tests/binary-decode/success/unit/LetOneUntypedB.dhall view
@@ -0,0 +1,1 @@+let x = 1 in x
+ dhall-lang/tests/binary-decode/success/unit/ListEmptyA.dhallb view
@@ -0,0 +1,1 @@+‚gNatural
+ dhall-lang/tests/binary-decode/success/unit/ListEmptyB.dhall view
@@ -0,0 +1,1 @@+[] : List Natural
+ dhall-lang/tests/binary-decode/success/unit/ListOneA.dhallb view

binary file changed (absent → 4 bytes)

+ dhall-lang/tests/binary-decode/success/unit/ListOneB.dhall view
@@ -0,0 +1,1 @@+[ _ ]
+ dhall-lang/tests/binary-decode/success/unit/MergeAnnotatedA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/MergeAnnotatedB.dhall view
@@ -0,0 +1,1 @@+merge _ _@1 : _@2
+ dhall-lang/tests/binary-decode/success/unit/MergeUnannotatedA.dhallb view

binary file changed (absent → 4 bytes)

+ dhall-lang/tests/binary-decode/success/unit/MergeUnannotatedB.dhall view
@@ -0,0 +1,1 @@+merge _ _@1
+ dhall-lang/tests/binary-decode/success/unit/NaturalTwentyFourA.dhallb view
@@ -0,0 +1,1 @@+‚
+ dhall-lang/tests/binary-decode/success/unit/NaturalTwentyFourB.dhall view
@@ -0,0 +1,5 @@+{-+24 is the first natural number that has a different CBOR encoding, hence the+separate test here.+-}+24
+ dhall-lang/tests/binary-decode/success/unit/NaturalZeroA.dhallb view

binary file changed (absent → 3 bytes)

+ dhall-lang/tests/binary-decode/success/unit/NaturalZeroB.dhall view
@@ -0,0 +1,1 @@+0
+ dhall-lang/tests/binary-decode/success/unit/OperatorAndA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorAndB.dhall view
@@ -0,0 +1,1 @@+_ && _@1
+ dhall-lang/tests/binary-decode/success/unit/OperatorCombineA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorCombineB.dhall view
@@ -0,0 +1,1 @@+_ ∧ _@1
+ dhall-lang/tests/binary-decode/success/unit/OperatorCombineTypesA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorCombineTypesB.dhall view
@@ -0,0 +1,1 @@+_ ⩓ _@1
+ dhall-lang/tests/binary-decode/success/unit/OperatorEqA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorEqB.dhall view
@@ -0,0 +1,1 @@+_ == _@1
+ dhall-lang/tests/binary-decode/success/unit/OperatorImportAltA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorImportAltB.dhall view
@@ -0,0 +1,1 @@+_ ? _@1
+ dhall-lang/tests/binary-decode/success/unit/OperatorListAppendA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorListAppendB.dhall view
@@ -0,0 +1,1 @@+_ # _@1
+ dhall-lang/tests/binary-decode/success/unit/OperatorNeqA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorNeqB.dhall view
@@ -0,0 +1,1 @@+_ != _@1
+ dhall-lang/tests/binary-decode/success/unit/OperatorOrA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorOrB.dhall view
@@ -0,0 +1,1 @@+_ || _@1
+ dhall-lang/tests/binary-decode/success/unit/OperatorPlusA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorPlusB.dhall view
@@ -0,0 +1,1 @@+_ + _@1
+ dhall-lang/tests/binary-decode/success/unit/OperatorPreferA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorPreferB.dhall view
@@ -0,0 +1,1 @@+_ ⫽ _@1
+ dhall-lang/tests/binary-decode/success/unit/OperatorTextAppendA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorTextAppendB.dhall view
@@ -0,0 +1,1 @@+_ ++ _@1
+ dhall-lang/tests/binary-decode/success/unit/OperatorTimesA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/OperatorTimesB.dhall view
@@ -0,0 +1,1 @@+_ * _@1
+ dhall-lang/tests/binary-decode/success/unit/PiNamedXA.dhallb view

binary file changed (absent → 13 bytes)

+ dhall-lang/tests/binary-decode/success/unit/PiNamedXB.dhall view
@@ -0,0 +1,1 @@+∀(x : Natural) → _
+ dhall-lang/tests/binary-decode/success/unit/PiUnderscoreA.dhallb view
@@ -0,0 +1,1 @@+ƒgNaturaldText
+ dhall-lang/tests/binary-decode/success/unit/PiUnderscoreB.dhall view
@@ -0,0 +1,1 @@+Natural → Text
+ dhall-lang/tests/binary-decode/success/unit/RecordFieldAccessA.dhallb view

binary file changed (absent → 5 bytes)

+ dhall-lang/tests/binary-decode/success/unit/RecordFieldAccessB.dhall view
@@ -0,0 +1,1 @@+_.x
+ dhall-lang/tests/binary-decode/success/unit/RecordLiteralA.dhallb view
@@ -0,0 +1,1 @@+‚¢axgNaturalaydBool
+ dhall-lang/tests/binary-decode/success/unit/RecordLiteralB.dhall view
@@ -0,0 +1,1 @@+{ x = Natural, y = Bool }
+ dhall-lang/tests/binary-decode/success/unit/RecordProjectFieldsA.dhallb view

binary file changed (absent → 12 bytes)

+ dhall-lang/tests/binary-decode/success/unit/RecordProjectFieldsB.dhall view
@@ -0,0 +1,1 @@+r.{ x, y, z }
+ dhall-lang/tests/binary-decode/success/unit/RecordTypeA.dhallb view
@@ -0,0 +1,1 @@+‚¢axgNaturalaydBool
+ dhall-lang/tests/binary-decode/success/unit/RecordTypeB.dhall view
@@ -0,0 +1,1 @@+{ x : Natural, y : Bool }
+ dhall-lang/tests/binary-decode/success/unit/SomeA.dhallb view

binary file changed (absent → 4 bytes)

+ dhall-lang/tests/binary-decode/success/unit/SomeB.dhall view
@@ -0,0 +1,1 @@+Some _
+ dhall-lang/tests/binary-decode/success/unit/TextInterpolatedA.dhallb view

binary file changed (absent → 11 bytes)

+ dhall-lang/tests/binary-decode/success/unit/TextInterpolatedB.dhall view
@@ -0,0 +1,1 @@+"foo${_}bar"
+ dhall-lang/tests/binary-decode/success/unit/TextSimpleA.dhallb view
@@ -0,0 +1,1 @@+‚cfoo
+ dhall-lang/tests/binary-decode/success/unit/TextSimpleB.dhall view
@@ -0,0 +1,1 @@+"foo"
+ dhall-lang/tests/binary-decode/success/unit/UnionTypeA.dhallb view
@@ -0,0 +1,1 @@+‚¢axgNaturalayö
+ dhall-lang/tests/binary-decode/success/unit/UnionTypeB.dhall view
@@ -0,0 +1,1 @@+< x : Natural | y >
+ dhall-lang/tests/binary-decode/success/unit/VariableNamedA.dhallb view
@@ -0,0 +1,1 @@+‚ax
+ dhall-lang/tests/binary-decode/success/unit/VariableNamedB.dhall view
@@ -0,0 +1,1 @@+x@1
+ dhall-lang/tests/binary-decode/success/unit/VariableNamedOversizedIntA.dhallb view

binary file changed (absent → 12 bytes)

+ dhall-lang/tests/binary-decode/success/unit/VariableNamedOversizedIntB.dhall view
@@ -0,0 +1,16 @@+{-++This file tests that a number encoded as a type larger than required is still+read successfully.  In this case, the .dhallb file has the bytes:++    8261 781b 0000 0000 0000 0001++which means the array ["x", uint64(1)].  This could have been stored in fewer+bytes as++    8261 7801++but decoders are required to allow the oversized representation.++-}+x@1
+ dhall-lang/tests/binary-decode/success/unit/VariableUnderscoreA.dhallb view
@@ -0,0 +1,1 @@+
+ dhall-lang/tests/binary-decode/success/unit/VariableUnderscoreB.dhall view
@@ -0,0 +1,1 @@+_@4
+ dhall-lang/tests/binary-decode/success/unit/VariableUnderscoreOversizedIntA.dhallb view

binary file changed (absent → 9 bytes)

+ dhall-lang/tests/binary-decode/success/unit/VariableUnderscoreOversizedIntB.dhall view
@@ -0,0 +1,13 @@+{-++This file tests that a number encoded as a type larger than required is still+read successfully.  In this case, the .dhallb file has the bytes:++    1b00 0000 0000 0000 01++which means a uint64 with value 1.  The number 1 could have been stored in a+single byte as 01, but decoders are required to allow the oversized+representation.++-}+_@1
+ dhall-lang/tests/binary-decode/success/unit/recordProjectionByExpressionA.dhallb view
@@ -0,0 +1,2 @@+ƒ+‚¢aa‚ab‚‚¡aagNatural
+ dhall-lang/tests/binary-decode/success/unit/recordProjectionByExpressionB.dhall view
@@ -0,0 +1,1 @@+{ a = 1, b = 2 }.({ a : Natural })
+ dhall-lang/tests/import/cache/dhall/1220efc43103e49b56c5bf089db8e0365bbfc455b8a2f0dc6ee5727a3586f85969fd view

binary file changed (absent → 49 bytes)

+ dhall-lang/tests/import/data/simpleLocation.dhall view
@@ -0,0 +1,1 @@+./simple.dhall as Location
+ dhall-lang/tests/import/success/asLocationA.dhall view
@@ -0,0 +1,8 @@+{ _1 = ./some/import.dhall as Location+, _2 = ../data/simpleLocation.dhall+, _3 = /absolute/import sha256:f9340badf94a684e652e0a384f64363293d8b632d971f3453f7ee22f10ab6e75 as Location+, _4 = https://prelude.dhall-lang.org/package.dhall as Location+, _5 = env:HOME as Location+, _6 = missing as Location+, _7 = (missing as Location) ? 42  -- `missing` fails as an import, but definitely resolves as Location+}
+ dhall-lang/tests/import/success/asLocationB.dhall view
@@ -0,0 +1,8 @@+{ _1 = < Local : Text | Remote : Text | Environment : Text | Missing >.Local "./some/import.dhall"+, _2 = < Local : Text | Remote : Text | Environment : Text | Missing >.Local "../data/simple.dhall"+, _3 = < Local : Text | Remote : Text | Environment : Text | Missing >.Local "/absolute/import"+, _4 = < Local : Text | Remote : Text | Environment : Text | Missing >.Remote "https://prelude.dhall-lang.org/package.dhall"+, _5 = < Local : Text | Remote : Text | Environment : Text | Missing >.Environment "env:HOME"+, _6 = < Local : Text | Remote : Text | Environment : Text | Missing >.Missing+, _7 = < Local : Text | Remote : Text | Environment : Text | Missing >.Missing+}
dhall-lang/tests/import/success/customHeadersA.dhall view
@@ -1,3 +1,3 @@ https://httpbin.org/user-agent-  using [ { header = "User-Agent", value = "Dhall" } ]+  using [ { mapKey = "User-Agent", mapValue = "Dhall" } ]   as Text
+ dhall-lang/tests/import/success/hashFromCacheA.dhall view
@@ -0,0 +1,11 @@+{-+An import with an integrity check MUST be fetched from the cache if possible.++If you have set XDG_CACHE_HOME as described in tests/README.md, this hash will+be available in the cache, so even though this is a `missing` import, it can be+resolved by its hash.++(If you're interested, the value is a fully-αβ-normalized copy of+Prelude/Optional/null at time of test creation)+-}+missing sha256:efc43103e49b56c5bf089db8e0365bbfc455b8a2f0dc6ee5727a3586f85969fd
+ dhall-lang/tests/import/success/hashFromCacheB.dhall view
@@ -0,0 +1,3 @@+  λ(_ : Type)+→ λ(_ : Optional _)+→ Optional/fold _@1 _ Bool (λ(_ : _@1) → False) True
dhall-lang/tests/import/success/headerForwardingA.dhall view
@@ -13,4 +13,4 @@    Prelude changes (sorry) -} https://test.dhall-lang.org/Bool/package.dhall-  using [ { header = "Test", value = "Example" } ]+  using [ { mapKey = "Test", mapValue = "Example" } ]
dhall-lang/tests/import/success/noHeaderForwardingA.dhall view
@@ -3,4 +3,4 @@    https://httpbin.org/user-agent -} https://raw.githubusercontent.com/dhall-lang/dhall-lang/master/tests/import/success/customHeadersA.dhall-  using [ { header = "User-Agent", value = "Secret" } ]+  using [ { mapKey = "User-Agent", mapValue = "Secret" } ]
+ dhall-lang/tests/normalization/success/simple/equalNoCommuteA.dhall view
@@ -0,0 +1,1 @@+λ(x : Bool) → x == False
+ dhall-lang/tests/normalization/success/simple/equalNoCommuteB.dhall view
@@ -0,0 +1,1 @@+λ(x : Bool) → x == False
+ dhall-lang/tests/normalization/success/simple/notEqualNoCommuteA.dhall view
@@ -0,0 +1,1 @@+λ(x : Bool) → x != True
+ dhall-lang/tests/normalization/success/simple/notEqualNoCommuteB.dhall view
@@ -0,0 +1,1 @@+λ(x : Bool) → x != True
+ dhall-lang/tests/normalization/success/simple/plusNoCommuteA.dhall view
@@ -0,0 +1,1 @@+λ(x : Natural) → x + 1
+ dhall-lang/tests/normalization/success/simple/plusNoCommuteB.dhall view
@@ -0,0 +1,1 @@+λ(x : Natural) → x + 1
+ dhall-lang/tests/normalization/success/simple/timesNoCommuteA.dhall view
@@ -0,0 +1,1 @@+λ(x : Natural) → x * 2
+ dhall-lang/tests/normalization/success/simple/timesNoCommuteB.dhall view
@@ -0,0 +1,1 @@+λ(x : Natural) → x * 2
+ dhall-lang/tests/normalization/success/unit/EmptyToMapA.dhall view
@@ -0,0 +1,1 @@+toMap {=} : List {mapKey : Text, mapValue : Natural}
+ dhall-lang/tests/normalization/success/unit/EmptyToMapB.dhall view
@@ -0,0 +1,1 @@+[] : List { mapKey : Text, mapValue : Natural }
dhall-lang/tests/normalization/success/unit/ListNormalizeTypeAnnotationA.dhall view
@@ -1,1 +1,1 @@-[] : List (if True then x else y)+[] : { x = List Bool }.x
dhall-lang/tests/normalization/success/unit/ListNormalizeTypeAnnotationB.dhall view
@@ -1,1 +1,1 @@-[] : List x+[] : List Bool
− dhall-lang/tests/normalization/success/unit/NoneNaturalA.dhall 
@@ -1,1 +0,0 @@-[] : Optional Natural
− dhall-lang/tests/normalization/success/unit/NoneNaturalB.dhall 
@@ -1,1 +0,0 @@-None Natural
+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeEmptyA.dhall view
@@ -0,0 +1,1 @@+{ a = 10, b = Some 10 }.({})
+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeEmptyB.dhall view
@@ -0,0 +1,1 @@+{=}
+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeNonEmptyA.dhall view
@@ -0,0 +1,1 @@+{ a = 10, b = Some 10, c = [ "text" ]}.({ a : Natural, b : Optional Natural })
+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeNonEmptyB.dhall view
@@ -0,0 +1,1 @@+{ a = 10, b = Some 10 }
+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeNormalizeProjectionA.dhall view
@@ -0,0 +1,1 @@+x.({ a : Natural, b : Natural })
+ dhall-lang/tests/normalization/success/unit/RecordProjectionByTypeNormalizeProjectionB.dhall view
@@ -0,0 +1,1 @@+x.{ a, b }
+ dhall-lang/tests/normalization/success/unit/RecordProjectionNormalizeFieldsA.dhall view
@@ -0,0 +1,1 @@+λ(x : { a : Bool, b : Bool, c : Bool }) → x.{ c, a }
+ dhall-lang/tests/normalization/success/unit/RecordProjectionNormalizeFieldsB.dhall view
@@ -0,0 +1,1 @@+λ(x : { a : Bool, b : Bool, c : Bool }) → x.{ a, c }
− dhall-lang/tests/normalization/success/unit/RecordProjectionTypeEmptyA.dhall 
@@ -1,1 +0,0 @@-{ a = 10, b = Some 10 }.({})
− dhall-lang/tests/normalization/success/unit/RecordProjectionTypeEmptyB.dhall 
@@ -1,1 +0,0 @@-{=}
− dhall-lang/tests/normalization/success/unit/RecordProjectionTypeNonEmptyA.dhall 
@@ -1,1 +0,0 @@-{ a = 10, b = Some 10, c = [ "text" ]}.({ a : Natural, b : Optional Natural })
− dhall-lang/tests/normalization/success/unit/RecordProjectionTypeNonEmptyB.dhall 
@@ -1,1 +0,0 @@-{ a = 10, b = Some 10 }
+ dhall-lang/tests/normalization/success/unit/ToMapA.dhall view
@@ -0,0 +1,1 @@+toMap { foo= 1, bar= 4, baz= 9 }
+ dhall-lang/tests/normalization/success/unit/ToMapB.dhall view
@@ -0,0 +1,4 @@+[ { mapKey = "bar", mapValue = 4 }+, { mapKey = "baz", mapValue = 9 }+, { mapKey = "foo", mapValue = 1 }+]
+ dhall-lang/tests/normalization/success/unit/ToMapWithTypeA.dhall view
@@ -0,0 +1,16 @@+{- This test verifies that the normalized result does not contain a type+   annotation if the input record is non-empty.++   The reason for this test is that implementations might need to store+   optional type annotations for both `toMap` invocations and empty list+   literals.  If an implementation does so, a common mistake is to take+   the optional type annotation and always pass it through as the optional+   type annotation for the list literal that `toMap` generates.++   However, the standard specifies that `toMap` should only generate a+   type annotation if the input record is empty.  If the input record is+   non-empty then the resulting normalized list is non-empty and therefore+   should not have a type annotation (since a non-empty list with a type+   annotation is not in normal form).+-}+toMap { foo= 1, bar= 4, baz= 9 } : List { mapKey : Text, mapValue : Natural }
+ dhall-lang/tests/normalization/success/unit/ToMapWithTypeB.dhall view
@@ -0,0 +1,4 @@+[ { mapKey = "bar", mapValue = 4 }+, { mapKey = "baz", mapValue = 9 }+, { mapKey = "foo", mapValue = 1 }+]
+ dhall-lang/tests/parser/failure/nonCharacter.dhall view
@@ -0,0 +1,1 @@+"\u{10FFFF}"
+ dhall-lang/tests/parser/failure/nonUtf8.dhall view
@@ -0,0 +1,4 @@+{- This test verifies that an implementation correctly rejects non-UTF8+   characters, such as this one: "í €"+-}+1
− dhall-lang/tests/parser/failure/urlWithoutPath.dhall 
@@ -1,2 +0,0 @@--- See issue #205 for why this is not permitted-http://example.com/
− dhall-lang/tests/parser/success/RecordProjectionByType.dhall 
@@ -1,15 +0,0 @@-let example1 = λ(A : Type) → λ(B : Type) → λ(C : { x : A, y : B }) → C.({ x : A }) : { x : A }--let example2 =-	  λ(A : Type)-	→ λ(B : Type)-	→ λ(C : { p : A, q : B })-	→ C.(let r = { p : A } in r) : { p : A }--let A = Natural--let B = Text--in--(example1 A B { x = 10, y = "Text" }) ∧ (example2 A B { p = 10, q = "Text" }) : { x : A, p : A }
dhall-lang/tests/parser/success/annotationsA.dhall view
@@ -1,4 +1,1 @@-{ 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 }+([] : List Natural) # [ 1, 2, 3 ] # ([ 1, 2, 3 ] : List Natural) : List Natural
dhall-lang/tests/parser/success/annotationsB.dhallb view

binary file changed (167 → 76 bytes)

+ dhall-lang/tests/parser/success/recordProjectionByExpressionA.dhall view
@@ -0,0 +1,15 @@+let example1 = λ(A : Type) → λ(B : Type) → λ(C : { x : A, y : B }) → C.({ x : A }) : { x : A }++let example2 =+	  λ(A : Type)+	→ λ(B : Type)+	→ λ(C : { p : A, q : B })+	→ C.(let r = { p : A } in r) : { p : A }++let A = Natural++let B = Text++in++(example1 A B { x = 10, y = "Text" }) ∧ (example2 A B { p = 10, q = "Text" }) : { x : A, p : A }
+ dhall-lang/tests/parser/success/recordProjectionByExpressionB.dhallb view

binary file changed (absent → 279 bytes)

dhall-lang/tests/parser/success/text/escapedDoubleQuotedStringA.dhall view
@@ -1,1 +1,1 @@-"\\\"\$\\\/\b\f\n\r\t \u2200(a : Type) \u2192 a"+"\\\"\$\\\/\b\f\n\r\t\u{1D11E} \u2200(a : Type) \u2192 a"
dhall-lang/tests/parser/success/text/escapedDoubleQuotedStringB.dhallb view
@@ -1,2 +1,2 @@-‚x\"$\/-
	 ∀(a : Type) → a+‚x"\"$\/+
	𝄞 ∀(a : Type) → a
+ dhall-lang/tests/parser/success/toMapA.dhall view
@@ -0,0 +1,1 @@+toMap { foo= 1, bar= 4, baz= 9 }
+ dhall-lang/tests/parser/success/toMapB.dhallb view
@@ -0,0 +1,1 @@+‚‚£cbar‚cbaz‚	cfoo‚
+ dhall-lang/tests/parser/success/unit/ListLitEmpty1A.dhall view
@@ -0,0 +1,1 @@+[] : List T
+ dhall-lang/tests/parser/success/unit/ListLitEmpty1B.dhallb view

binary file changed (absent → 6 bytes)

+ dhall-lang/tests/parser/success/unit/ListLitEmpty2A.dhall view
@@ -0,0 +1,1 @@+[] : T
+ dhall-lang/tests/parser/success/unit/ListLitEmpty2B.dhallb view

binary file changed (absent → 7 bytes)

− dhall-lang/tests/parser/success/unit/ListLitEmptyA.dhall 
@@ -1,1 +0,0 @@-[] : List T
− dhall-lang/tests/parser/success/unit/ListLitEmptyB.dhallb

binary file changed (6 → absent bytes)

+ dhall-lang/tests/parser/success/unit/ListLitEmptyPrecedenceA.dhall view
@@ -0,0 +1,1 @@+[] : List T U
+ dhall-lang/tests/parser/success/unit/ListLitEmptyPrecedenceB.dhallb view

binary file changed (absent → 18 bytes)

+ dhall-lang/tests/parser/success/unit/RecordFieldAccessA.dhall view
@@ -0,0 +1,1 @@+r.x
+ dhall-lang/tests/parser/success/unit/RecordFieldAccessB.dhallb view

binary file changed (absent → 8 bytes)

+ dhall-lang/tests/parser/success/unit/RecordProjectFieldsA.dhall view
@@ -0,0 +1,1 @@+r.{ x, y, z }
+ dhall-lang/tests/parser/success/unit/RecordProjectFieldsB.dhallb view

binary file changed (absent → 12 bytes)

+ dhall-lang/tests/parser/success/unit/RecordProjectionByTypeA.dhall view
@@ -0,0 +1,1 @@+{ a = 1, b = 2 }.({ a : Natural })
+ dhall-lang/tests/parser/success/unit/RecordProjectionByTypeB.dhallb view
@@ -0,0 +1,2 @@+ƒ+‚¢aa‚ab‚‚¡aagNatural
+ dhall-lang/tests/parser/success/unit/RecordProjectionByTypeEmptyA.dhall view
@@ -0,0 +1,1 @@+{ a = 1, b = 2 }.({})
+ dhall-lang/tests/parser/success/unit/RecordProjectionByTypeEmptyB.dhallb view
@@ -0,0 +1,2 @@+ƒ+‚¢aa‚ab‚‚ 
+ dhall-lang/tests/parser/success/unit/import/asLocationA.dhall view
@@ -0,0 +1,6 @@+{ _1 = ./some/import.dhall as Location+, _2 = /absolute/import sha256:f9340badf94a684e652e0a384f64363293d8b632d971f3453f7ee22f10ab6e75 as Location+, _3 = https://prelude.dhall-lang.org/package.dhall as Location+, _4 = env:HOME as Location+, _5 = missing as Location+}
+ dhall-lang/tests/parser/success/unit/import/asLocationB.dhallb view
@@ -0,0 +1,2 @@+‚¥b_1†ödsomelimport.dhallb_2†X" ù4­ùJhNe.+8Od62“ض2ÙqóE?~â/«nuhabsolutefimportb_3ˆöövprelude.dhall-lang.orgmpackage.dhallöb_4…ödHOMEb_5„ö
dhall-lang/tests/parser/success/unit/import/inlineUsingA.dhall view
@@ -8,7 +8,7 @@ -}  https://example.com/foo using-    [ { header = "Authorization"-      , value  = "token 5199831f4dd3b79e7c5b7e0ebe75d67aa66e79d4"+    [ { mapKey   = "Authorization"+      , mapValue = "token 5199831f4dd3b79e7c5b7e0ebe75d67aa66e79d4"       }     ]
dhall-lang/tests/parser/success/unit/import/inlineUsingB.dhallb view

binary file changed (108 → 111 bytes)

dhall-lang/tests/parser/success/unit/import/parenthesizeUsingB.dhallb view

binary file changed (241 → 194 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/basicHttpA.dhall view
@@ -0,0 +1,1 @@+http://example.com/someFile.dhall
+ dhall-lang/tests/parser/success/unit/import/urls/basicHttpB.dhallb view

binary file changed (absent → 35 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/basicHttpsA.dhall view
@@ -0,0 +1,1 @@+https://raw.githubusercontent.com/dhall-lang/dhall-haskell/18e4e9a18dc53271146df3ccf5b4177c3552236b/examples/True
+ dhall-lang/tests/parser/success/unit/import/urls/basicHttpsB.dhallb view

binary file changed (absent → 116 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/emptyPath0A.dhall view
@@ -0,0 +1,3 @@+-- the normal form for an empty path is a path of `/`+-- see RFC7230 section 2.7.3+https://example.com
+ dhall-lang/tests/parser/success/unit/import/urls/emptyPath0B.dhallb view

binary file changed (absent → 21 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/emptyPath1A.dhall view
@@ -0,0 +1,1 @@+https://example.com/
+ dhall-lang/tests/parser/success/unit/import/urls/emptyPath1B.dhallb view

binary file changed (absent → 21 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/emptyPathSegmentA.dhall view
@@ -0,0 +1,2 @@+-- empty path segments are not equivalent to missing path segments+https://example.com/foo//bar
+ dhall-lang/tests/parser/success/unit/import/urls/emptyPathSegmentB.dhallb view

binary file changed (absent → 29 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/emptyQueryA.dhall view
@@ -0,0 +1,3 @@+-- an empty query string is not the same as a missing one+-- see RFC 3986 section 6.2.3+https://example.com/foo?
+ dhall-lang/tests/parser/success/unit/import/urls/emptyQueryB.dhallb view

binary file changed (absent → 24 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/escapedPathA.dhall view
@@ -0,0 +1,1 @@+https://example.com/a%20b/c%2fd/e+f
+ dhall-lang/tests/parser/success/unit/import/urls/escapedPathB.dhallb view

binary file changed (absent → 32 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/escapedQueryA.dhall view
@@ -0,0 +1,2 @@+-- Unlike paths, query strings should *not* be decoded+https://example.com/foo?a%20b=c%2fd&e+f/?
+ dhall-lang/tests/parser/success/unit/import/urls/escapedQueryB.dhallb view

binary file changed (absent → 41 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/fragmentParsesAsListAppendA.dhall view
@@ -0,0 +1,11 @@+{- Fragment identifiers are not allowed in URLs because they serve no purpose+   for Dhall and they could lead to ambiguity if a parser interprets them as+   the list append operator (`#`)++   The following expression therefore only has one valid parse, which is to+   interpret the `#` as a list append.  In other words, the following expression+   is parsed as:++   (https://example.com/foo) # bar+-}+https://example.com/foo#bar
+ dhall-lang/tests/parser/success/unit/import/urls/fragmentParsesAsListAppendB.dhallb view

binary file changed (absent → 33 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/ipv4A.dhall view
@@ -0,0 +1,1 @@+https://127.0.0.1/index.dhall
+ dhall-lang/tests/parser/success/unit/import/urls/ipv4B.dhallb view

binary file changed (absent → 30 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6longA.dhall view
@@ -0,0 +1,1 @@+https://[2001:db8:85a3:0:0:8a2e:370:7334]/tutorial.dhall
+ dhall-lang/tests/parser/success/unit/import/urls/ipv6longB.dhallb view

binary file changed (absent → 58 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6mediumA.dhall view
@@ -0,0 +1,1 @@+https://[2001:db8:85a3::8a2e:370:7334]/tutorial.dhall
+ dhall-lang/tests/parser/success/unit/import/urls/ipv6mediumB.dhallb view

binary file changed (absent → 55 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6shortA.dhall view
@@ -0,0 +1,1 @@+https://[::]/index.dhall
+ dhall-lang/tests/parser/success/unit/import/urls/ipv6shortB.dhallb view

binary file changed (absent → 25 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/ipv6withipv4A.dhall view
@@ -0,0 +1,1 @@+https://[2001:db8:85a3::8a2e:3.112.115.52]/tutorial.dhall
+ dhall-lang/tests/parser/success/unit/import/urls/ipv6withipv4B.dhallb view

binary file changed (absent → 59 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/portA.dhall view
@@ -0,0 +1,1 @@+https://example.com:1234/foo
+ dhall-lang/tests/parser/success/unit/import/urls/portB.dhallb view

binary file changed (absent → 29 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/potPourriA.dhall view
@@ -0,0 +1,1 @@+https://-._~%2C!$&'*+;=:@0abc1--12a------a-a--a-0/foo?/-._~%2C!$&'*+;=:@/?
+ dhall-lang/tests/parser/success/unit/import/urls/potPourriB.dhallb view

binary file changed (absent → 75 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/quotedPathFakeUrlEncodeA.dhall view
@@ -0,0 +1,1 @@+https://example.com/"a%20b"/c
+ dhall-lang/tests/parser/success/unit/import/urls/quotedPathFakeUrlEncodeB.dhallb view

binary file changed (absent → 28 bytes)

+ dhall-lang/tests/parser/success/unit/import/urls/userinfoA.dhall view
@@ -0,0 +1,1 @@+https://john:doe@example.com/foo
+ dhall-lang/tests/parser/success/unit/import/urls/userinfoB.dhallb view

binary file changed (absent → 33 bytes)

+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/access/0A.dhall view
@@ -0,0 +1,1 @@+{ x = "foo" }.x
+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/access/0B.hash view
@@ -0,0 +1,1 @@+sha256:fd881e3d48cbc85b4044697bdce8167a77f3fb4665ff0b647a1210a17528818a
+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/access/1A.dhall view
@@ -0,0 +1,1 @@+< Foo : Text | Bar : Natural >.Foo
+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/access/1B.hash view
@@ -0,0 +1,1 @@+sha256:35ba8bddad36acfb29cc6f1700364544c145e96cf522f592f18f90c2f96e6e9c
+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/combineTypes/0A.dhall view
@@ -0,0 +1,1 @@+{ foo : { bar : Text } } ⩓ { foo : { baz : Bool }, qux : Integer }
+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/combineTypes/0B.hash view
@@ -0,0 +1,1 @@+sha256:4495bbf3fea6c579c65ee51463b225747803b94668013528b9ca0384304cb350
+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/combineTypes/1A.dhall view
@@ -0,0 +1,1 @@+{ foo : { bar : Text } } //\\ { foo : { baz : Bool }, qux : Integer }
+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/combineTypes/1B.hash view
@@ -0,0 +1,1 @@+sha256:4495bbf3fea6c579c65ee51463b225747803b94668013528b9ca0384304cb350
+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/prefer/0A.dhall view
@@ -0,0 +1,1 @@+{ foo = 1, bar = "ABC" } // { baz = True }
+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/prefer/0B.hash view
@@ -0,0 +1,1 @@+sha256:18fbad84131d28b6d412e6bc09d5ee8eaf432b639c6cc6f1bef1b4ef366642d7
+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/projection/0A.dhall view
@@ -0,0 +1,1 @@+{ x = 1, y = True, z = "ABC" }.{ x, y }
+ dhall-lang/tests/semantic-hash/success/haskell-tutorial/projection/0B.hash view
@@ -0,0 +1,1 @@+sha256:b7ae500723633be94b53b905384236fcd18cbce59314bb51044bb7d3f3939e6e
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/and/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/and [ True, False, True ]
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/and/0B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/and/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/and ([] : List Bool)
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/and/1B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/build/0A.dhall view
@@ -0,0 +1,2 @@+../../../../../../Prelude/Bool/build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → true)
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/build/0B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/build/1A.dhall view
@@ -0,0 +1,2 @@+../../../../../../Prelude/Bool/build +(λ(bool : Type) → λ(true : bool) → λ(false : bool) → false)
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/build/1B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even [ False, True, False ]
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/0B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even [ False, True ]
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/1B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even [ False ]
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/2B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/3A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/even ([] : List Bool)
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/even/3B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/fold/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/fold True Natural 0 1
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/fold/0B.hash view
@@ -0,0 +1,1 @@+sha256:d0a48d41dcc572839faa9499b6c316b8d0d7115efac2ac770f062cd5fd6d0181
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/fold/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/fold False Natural 0 1
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/fold/1B.hash view
@@ -0,0 +1,1 @@+sha256:d60d8415e36e86dae7f42933d3b0c4fe3ca238f057fba206c7e9fbf5d784fe15
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/not/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/not True
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/not/0B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/not/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/not False
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/not/1B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd [ True, False, True ]
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/0B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd [ True, False ]
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/1B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/2A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd [ True ]
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/2B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/3A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/odd ([] : List Bool)
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/odd/3B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/or/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/or [ True, False, True ]
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/or/0B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/or/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/or ([] : List Bool)
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/or/1B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/show/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/show True
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/show/0B.hash view
@@ -0,0 +1,1 @@+sha256:cdbb7fd982ba05e709fe67b23818fffb65ff9c0b8abde1abb5ac1a8245891a3f
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/show/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Bool/show False
+ dhall-lang/tests/semantic-hash/success/prelude/Bool/show/1B.hash view
@@ -0,0 +1,1 @@+sha256:2357bb42b56beb99180d967177c0490061bd3536a147dfe144d2630f983004e5
+ dhall-lang/tests/semantic-hash/success/prelude/Double/show/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Double/show -3.1
+ dhall-lang/tests/semantic-hash/success/prelude/Double/show/0B.hash view
@@ -0,0 +1,1 @@+sha256:d0b3cdb4f3cd5375495629450de676f445c0da6980a5ada251df199079d0ef89
+ dhall-lang/tests/semantic-hash/success/prelude/Double/show/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Double/show 0.4
+ dhall-lang/tests/semantic-hash/success/prelude/Double/show/1B.hash view
@@ -0,0 +1,1 @@+sha256:dd5e8756d06f12ef6e003dc769b6e1222e5aa0c8491579dc65b2dd6f4f0ec53d
+ dhall-lang/tests/semantic-hash/success/prelude/Integer/show/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/show -3
+ dhall-lang/tests/semantic-hash/success/prelude/Integer/show/0B.hash view
@@ -0,0 +1,1 @@+sha256:053de6c2b7f281dd82dd9b643cc848e64633b88c9c57082ec0ac41257c5592d7
+ dhall-lang/tests/semantic-hash/success/prelude/Integer/show/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/show +0
+ dhall-lang/tests/semantic-hash/success/prelude/Integer/show/1B.hash view
@@ -0,0 +1,1 @@+sha256:4ab1c5aa262f39cdbe1f4924accb69bb44e2a616b5a0ca39655eebd0cc863d33
+ dhall-lang/tests/semantic-hash/success/prelude/Integer/toDouble/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/toDouble -3
+ dhall-lang/tests/semantic-hash/success/prelude/Integer/toDouble/0B.hash view
@@ -0,0 +1,1 @@+sha256:17bf67209e1b636613b9f97ca5f2b8a59fab70eaab65a029be19129ec5f444ad
+ dhall-lang/tests/semantic-hash/success/prelude/Integer/toDouble/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Integer/toDouble +2
+ dhall-lang/tests/semantic-hash/success/prelude/Integer/toDouble/1B.hash view
@@ -0,0 +1,1 @@+sha256:d4b8848ff8a5d403469e4107f4a0cfdc42197bb3a9fcd2fa477b65dd252ce770
+ dhall-lang/tests/semantic-hash/success/prelude/List/all/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/all Natural Natural/even [ 2, 3, 5 ]
+ dhall-lang/tests/semantic-hash/success/prelude/List/all/0B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/List/all/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/all Natural Natural/even ([] : List Natural)
+ dhall-lang/tests/semantic-hash/success/prelude/List/all/1B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/List/any/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/any Natural Natural/even [ 2, 3, 5 ]
+ dhall-lang/tests/semantic-hash/success/prelude/List/any/0B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/List/any/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/any Natural Natural/even ([] : List Natural)
+ dhall-lang/tests/semantic-hash/success/prelude/List/any/1B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/List/build/0B.hash view
@@ -0,0 +1,1 @@+sha256:8a08646db7447b14cf03a497635242b6fb76365017fc1699b2a8807272a2ec58
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/List/build/1B.hash view
@@ -0,0 +1,1 @@+sha256:6da0c98142d1168ac9d6080b7853d2b59b97d42079e1b2f121daf449b3b2e449
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/List/concat/0B.hash view
@@ -0,0 +1,1 @@+sha256:ae3a399d05bafcee80c088ca6c740f0c61c2a4c6fce6d7e4f4fa26560eac083f
+ dhall-lang/tests/semantic-hash/success/prelude/List/concat/1A.dhall view
@@ -0,0 +1,5 @@+../../../../../../Prelude/List/concat Natural+[ [] : List Natural+, [] : List Natural+, [] : List Natural+]
+ dhall-lang/tests/semantic-hash/success/prelude/List/concat/1B.hash view
@@ -0,0 +1,1 @@+sha256:d79a2e0e14809ab2dbd2d180e60da8e129a5fb197bdd0caed57e3828402e48a9
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/List/concatMap/0B.hash view
@@ -0,0 +1,1 @@+sha256:ea1f5046bcba6efb41bde23738d9a3f3aa2cda3dc722999d9e4f477eb9d1b12d
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/List/concatMap/1B.hash view
@@ -0,0 +1,1 @@+sha256:d79a2e0e14809ab2dbd2d180e60da8e129a5fb197bdd0caed57e3828402e48a9
+ dhall-lang/tests/semantic-hash/success/prelude/List/filter/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/filter Natural Natural/even [ 2, 3, 5 ]
+ dhall-lang/tests/semantic-hash/success/prelude/List/filter/0B.hash view
@@ -0,0 +1,1 @@+sha256:988afbf26d86e95a4e6b78b0c344c9f987dcd5f7d7a7c541601bb1e9a01c9102
+ dhall-lang/tests/semantic-hash/success/prelude/List/filter/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/filter Natural Natural/odd [ 2, 3, 5 ]
+ dhall-lang/tests/semantic-hash/success/prelude/List/filter/1B.hash view
@@ -0,0 +1,1 @@+sha256:68248e1b69b249e6aeebcd36e7034f159b75d2931105fb4d41fc55d644b7ee8d
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/List/fold/0B.hash view
@@ -0,0 +1,1 @@+sha256:d4428061b6fd69b6b45574603ac71060f9756a5c9a1642df322812e3a7ea858b
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/List/fold/1B.hash view
@@ -0,0 +1,1 @@+sha256:3bd732ae873cb107c3dfef4ae953f6480af310b27fda6b678b43569841e1012b
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/List/fold/2B.hash view
@@ -0,0 +1,1 @@+sha256:186c485f65cbbf97aba127a1205a16ee1125ec279e727ff05d8f8ada624257c7
+ dhall-lang/tests/semantic-hash/success/prelude/List/generate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/generate 5 Bool Natural/even
+ dhall-lang/tests/semantic-hash/success/prelude/List/generate/0B.hash view
@@ -0,0 +1,1 @@+sha256:0860d18cdc28bc4e7b081bf8c9891ab07e303e4f72b3439bb3a92d7dedd7e8fa
+ dhall-lang/tests/semantic-hash/success/prelude/List/generate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/generate 0 Bool Natural/even
+ dhall-lang/tests/semantic-hash/success/prelude/List/generate/1B.hash view
@@ -0,0 +1,1 @@+sha256:fb7841e1b3b3e3511196b38df96e73ac7785edef663ea450f97b3c1322742d69
+ dhall-lang/tests/semantic-hash/success/prelude/List/head/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/head Natural [ 0, 1, 2 ]
+ dhall-lang/tests/semantic-hash/success/prelude/List/head/0B.hash view
@@ -0,0 +1,1 @@+sha256:7ac81b06d39113c93f17cc3d2aa55867453f68f35f58a4d577f5bacbb969225f
+ dhall-lang/tests/semantic-hash/success/prelude/List/head/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/head Natural ([] : List Natural)
+ dhall-lang/tests/semantic-hash/success/prelude/List/head/1B.hash view
@@ -0,0 +1,1 @@+sha256:bfdc295856e05e3610d202d9c12f56f7c423de81cd6069f590786ca176b94df3
+ dhall-lang/tests/semantic-hash/success/prelude/List/indexed/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/indexed Bool [ True, False, True ]
+ dhall-lang/tests/semantic-hash/success/prelude/List/indexed/0B.hash view
@@ -0,0 +1,1 @@+sha256:7225a557384940f3f2f7f40e5e3e36384be7892c08a24e5467d0f75cd0dda9e1
+ dhall-lang/tests/semantic-hash/success/prelude/List/indexed/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/indexed Bool ([] : List Bool)
+ dhall-lang/tests/semantic-hash/success/prelude/List/indexed/1B.hash view
@@ -0,0 +1,1 @@+sha256:ff10538dd6bf3bf736bf38f54575e1ddd251aa1d6aad7c6ff6f4159bfc87cc4a
+ dhall-lang/tests/semantic-hash/success/prelude/List/iterate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/iterate 10 Natural (λ(x : Natural) → x * 2) 1
+ dhall-lang/tests/semantic-hash/success/prelude/List/iterate/0B.hash view
@@ -0,0 +1,1 @@+sha256:577ea4905798b4fbd4803b3a7c82902594f0c3e5d84af46cec4514da9801760a
+ dhall-lang/tests/semantic-hash/success/prelude/List/iterate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/iterate 0 Natural (λ(x : Natural) → x * 2) 1
+ dhall-lang/tests/semantic-hash/success/prelude/List/iterate/1B.hash view
@@ -0,0 +1,1 @@+sha256:d79a2e0e14809ab2dbd2d180e60da8e129a5fb197bdd0caed57e3828402e48a9
+ dhall-lang/tests/semantic-hash/success/prelude/List/last/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/last Natural [ 0, 1, 2 ]
+ dhall-lang/tests/semantic-hash/success/prelude/List/last/0B.hash view
@@ -0,0 +1,1 @@+sha256:1400a0fa058e1c8fc58926856000d82d99fad204bf48e36f54dccaafc0acd3a0
+ dhall-lang/tests/semantic-hash/success/prelude/List/last/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/last Natural ([] : List Natural)
+ dhall-lang/tests/semantic-hash/success/prelude/List/last/1B.hash view
@@ -0,0 +1,1 @@+sha256:bfdc295856e05e3610d202d9c12f56f7c423de81cd6069f590786ca176b94df3
+ dhall-lang/tests/semantic-hash/success/prelude/List/length/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/length Natural [ 0, 1, 2 ]
+ dhall-lang/tests/semantic-hash/success/prelude/List/length/0B.hash view
@@ -0,0 +1,1 @@+sha256:15f52ecf91c94c1baac02d5a4964b2ed8fa401641a2c8a95e8306ec7c1e3b8d2
+ dhall-lang/tests/semantic-hash/success/prelude/List/length/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/length Natural ([] : List Natural)
+ dhall-lang/tests/semantic-hash/success/prelude/List/length/1B.hash view
@@ -0,0 +1,1 @@+sha256:d0a48d41dcc572839faa9499b6c316b8d0d7115efac2ac770f062cd5fd6d0181
+ dhall-lang/tests/semantic-hash/success/prelude/List/map/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/map Natural Bool Natural/even [ 2, 3, 5 ]
+ dhall-lang/tests/semantic-hash/success/prelude/List/map/0B.hash view
@@ -0,0 +1,1 @@+sha256:aaf20d96e69473f836397764ec61b64a65dc5084ee33692ecd8b85ca63962827
+ dhall-lang/tests/semantic-hash/success/prelude/List/map/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/map Natural Bool Natural/even ([] : List Natural)
+ dhall-lang/tests/semantic-hash/success/prelude/List/map/1B.hash view
@@ -0,0 +1,1 @@+sha256:fb7841e1b3b3e3511196b38df96e73ac7785edef663ea450f97b3c1322742d69
+ dhall-lang/tests/semantic-hash/success/prelude/List/null/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/null Natural [ 0, 1, 2 ]
+ dhall-lang/tests/semantic-hash/success/prelude/List/null/0B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/List/null/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/null Natural ([] : List Natural)
+ dhall-lang/tests/semantic-hash/success/prelude/List/null/1B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/List/replicate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/replicate 9 Natural 1
+ dhall-lang/tests/semantic-hash/success/prelude/List/replicate/0B.hash view
@@ -0,0 +1,1 @@+sha256:4241079fe7c8a46be37831a35dedb60645c3a86a2ab24778e03c27c820813cdc
+ dhall-lang/tests/semantic-hash/success/prelude/List/replicate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/replicate 0 Natural 1
+ dhall-lang/tests/semantic-hash/success/prelude/List/replicate/1B.hash view
@@ -0,0 +1,1 @@+sha256:d79a2e0e14809ab2dbd2d180e60da8e129a5fb197bdd0caed57e3828402e48a9
+ dhall-lang/tests/semantic-hash/success/prelude/List/reverse/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/reverse Natural [ 0, 1, 2 ]
+ dhall-lang/tests/semantic-hash/success/prelude/List/reverse/0B.hash view
@@ -0,0 +1,1 @@+sha256:ed586af4895ad8118e77976c6ee2fef5a39f69eb9378df32349c81fee2d61d4d
+ dhall-lang/tests/semantic-hash/success/prelude/List/reverse/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/reverse Natural ([] : List Natural)
+ dhall-lang/tests/semantic-hash/success/prelude/List/reverse/1B.hash view
@@ -0,0 +1,1 @@+sha256:d79a2e0e14809ab2dbd2d180e60da8e129a5fb197bdd0caed57e3828402e48a9
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/List/shifted/0B.hash view
@@ -0,0 +1,1 @@+sha256:e5c27411e9b0692ac96e6914420f17748eda33d3854067675c6a3b3780fb15a6
+ dhall-lang/tests/semantic-hash/success/prelude/List/shifted/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/shifted Bool ([] : List (List { index : Natural, value : Bool }))
+ dhall-lang/tests/semantic-hash/success/prelude/List/shifted/1B.hash view
@@ -0,0 +1,1 @@+sha256:ff10538dd6bf3bf736bf38f54575e1ddd251aa1d6aad7c6ff6f4159bfc87cc4a
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/List/unzip/0B.hash view
@@ -0,0 +1,1 @@+sha256:fffb0db166d08b99a1beb1650a3c9ee6e7bf6ce1054150bea4dae9b8ce5e4fbf
+ dhall-lang/tests/semantic-hash/success/prelude/List/unzip/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/List/unzip Text Bool ([] : List { _1 : Text, _2 : Bool })
+ dhall-lang/tests/semantic-hash/success/prelude/List/unzip/1B.hash view
@@ -0,0 +1,1 @@+sha256:c598ac5f10c7d20fe201f94ed5d9d18a847e89c65db9478492c930e5c42af710
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/Natural/build/0B.hash view
@@ -0,0 +1,1 @@+sha256:15f52ecf91c94c1baac02d5a4964b2ed8fa401641a2c8a95e8306ec7c1e3b8d2
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/Natural/build/1B.hash view
@@ -0,0 +1,1 @@+sha256:d0a48d41dcc572839faa9499b6c316b8d0d7115efac2ac770f062cd5fd6d0181
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/enumerate/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/enumerate 10
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/enumerate/0B.hash view
@@ -0,0 +1,1 @@+sha256:a7af1902b53cc68a9613b659ebf58d06c840072625d14f9fde7eefa0e0f2add0
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/enumerate/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/enumerate 0
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/enumerate/1B.hash view
@@ -0,0 +1,1 @@+sha256:d79a2e0e14809ab2dbd2d180e60da8e129a5fb197bdd0caed57e3828402e48a9
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/even/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/even 3
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/even/0B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/even/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/even 0
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/even/1B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/fold/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/fold 3 Natural (λ(x : Natural) → 5 * x) 1
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/fold/0B.hash view
@@ -0,0 +1,1 @@+sha256:39b0b6e0e0b616af4f20c7b06fefcd26dcdbd5be772d885fe73487574ec8b56b
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/Natural/fold/1B.hash view
@@ -0,0 +1,1 @@+sha256:c6ddb630f2abfcd78aa874079323ba2a9f80f548c5687346a0fcedff78d14f52
+ dhall-lang/tests/semantic-hash/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/semantic-hash/success/prelude/Natural/fold/2B.hash view
@@ -0,0 +1,1 @@+sha256:08681d6fb9b1bb78be37f5a976186daa8fc39d0d1d3f7dbb716dc33937a6746d
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/isZero/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/isZero 2
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/isZero/0B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/isZero/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/isZero 0
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/isZero/1B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/odd/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/odd 3
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/odd/0B.hash view
@@ -0,0 +1,1 @@+sha256:27abdeddfe8503496adeb623466caa47da5f63abd2bc6fa19f6cfcb73ecfed70
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/odd/1A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/odd 0
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/odd/1B.hash view
@@ -0,0 +1,1 @@+sha256:2017ff3461395672aa0aa4f64894fd2f95a4b120e2690e8951656d79adc2eed2
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/product/0A.dhall view
@@ -0,0 +1,1 @@+../../../../../../Prelude/Natural/product [ 2, 3, 5 ]
+ dhall-lang/tests/semantic-hash/success/prelude/Natural/product/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/product/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/product/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/show/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/show/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/show/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/show/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/sum/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/sum/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/sum/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/sum/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toDouble/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toDouble/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toDouble/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toDouble/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toInteger/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toInteger/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toInteger/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Natural/toInteger/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/all/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/all/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/all/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/all/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/any/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/any/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/any/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/any/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/build/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/build/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/build/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/build/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/2A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/concat/2B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/filter/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/filter/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/filter/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/filter/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/fold/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/fold/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/fold/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/fold/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/2A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/head/2B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/2A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/last/2B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/length/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/length/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/length/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/length/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/map/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/map/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/map/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/map/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/null/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/null/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/null/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/null/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/toList/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/toList/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/toList/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/toList/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/unzip/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/unzip/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/unzip/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Optional/unzip/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concat/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concat/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concat/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concat/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMap/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMap/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMap/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMap/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMapSep/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMapSep/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMapSep/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatMapSep/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatSep/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatSep/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatSep/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/concatSep/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/show/0A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/show/0B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/show/1A.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/prelude/Text/show/1B.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/remoteSystemsA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/remoteSystemsB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/doubleShowA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/doubleShowB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/enumA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/enumB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/integerShowA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/integerShowB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/integerToDoubleA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/integerToDoubleB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/letletA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/letletB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/listBuildA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/listBuildB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/multiLineA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/multiLineB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalBuildA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalBuildB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalPlusA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalPlusB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalShowA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalShowB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalToIntegerA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/naturalToIntegerB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/optionalBuildA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/optionalBuildB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/optionalBuildFoldA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/optionalBuildFoldB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/optionalFoldA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/optionalFoldB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/sortOperatorA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simple/sortOperatorB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/andA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/andB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/eqA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/eqB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/ifThenElseA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/ifThenElseB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/neA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/neB.hash view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/orA.dhall view

file too large to diff

+ dhall-lang/tests/semantic-hash/success/simplifications/orB.hash view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/alternativesAreTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/alternativesAreTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/kindParameterA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/simple/kindParameterB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/BoolA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/BoolB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleShowA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/DoubleShowB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FalseA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FalseB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionApplicationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionApplicationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionNamedArgA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionNamedArgB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindTermA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindTermB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeKindTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTermTermA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTermTermB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTypeTermA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTypeTermB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTypeTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeTypeTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeUsingArgumentA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/FunctionTypeUsingArgumentB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IfNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerShowA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerShowB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerToDoubleA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/IntegerToDoubleB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/KindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/KindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetNestedTypeSynonymA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetNestedTypeSynonymB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetTypeSynonymA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetTypeSynonymB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetWithAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/LetWithAnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListBuildA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListBuildB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListFoldA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListFoldB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListHeadA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListHeadB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListIndexedA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListIndexedB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLastA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLastB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLengthA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLengthB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralEmptyNormalizeAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralEmptyNormalizeAnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralOneA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListLiteralOneB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListReverseA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ListReverseB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeEmptyUnionA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeEmptyUnionB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneWithAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/MergeOneWithAnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalBuildA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalBuildB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalEvenA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalEvenB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalFoldA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalFoldB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalIsZeroA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalIsZeroB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalOddA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalOddB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalShowA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalShowB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalToIntegerA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NaturalToIntegerB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NoneA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/NoneB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorAndA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorAndB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorAndNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorAndNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorEqualA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorEqualB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorEqualNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorEqualNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorListConcatenateA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorListConcatenateB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorListConcatenateNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorListConcatenateNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorNotEqualA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorNotEqualB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorNotEqualNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorNotEqualNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorOrA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorOrB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorOrNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorOrNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorPlusA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorPlusB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorPlusNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorPlusNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTextConcatenateA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTextConcatenateB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTextConcatenateNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTextConcatenateNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTimesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTimesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTimesNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OperatorTimesNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OptionalA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OptionalB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OptionalBuildA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OptionalBuildB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OptionalFoldA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/OptionalFoldB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedKindLikeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedKindLikeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedTypeLikeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordNestedTypeLikeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneValueA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordOneValueB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeJudgmentalEqualityA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionByTypeJudgmentalEqualityB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionValueA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordProjectionValueB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionValueA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordSelectionValueB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeKindLikeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeKindLikeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeNestedKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeNestedKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeNestedKindLikeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeNestedKindLikeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecordTypeTypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeLhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeLhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRecursivelyTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeRhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordMergeTwoTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRecursivelyTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeRhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RecursiveRecordTypeMergeTwoTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeRhsEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeRhsEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoDifferentA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoDifferentB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoKindsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoKindsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoTypesA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/RightBiasedRecordMergeTwoTypesB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/SomeTrueA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/SomeTrueB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralNormalizeArgumentsA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralNormalizeArgumentsB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralWithInterpolationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextLiteralWithInterpolationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextShowA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TextShowB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ToMapA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/ToMapB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TrueA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TrueB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationSortA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeAnnotationSortB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/TypeB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionConstructorEmptyFieldA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionConstructorEmptyFieldB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionConstructorFieldA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionConstructorFieldB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionLiteralOneA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionLiteralOneB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeEmptyA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeEmptyB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeKindA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeKindB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeOneA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeOneB.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeTypeA.dhall view

file too large to diff

+ dhall-lang/tests/type-inference/success/unit/UnionTypeTypeB.dhall view

file too large to diff

dhall-lang/tests/typecheck/failure/customHeadersUsingBoundVariable.dhall view

file too large to diff

dhall.cabal view

file too large to diff

src/Dhall.hs view

file too large to diff

src/Dhall/Binary.hs view

file too large to diff

src/Dhall/Context.hs view

file too large to diff

src/Dhall/Core.hs view

file too large to diff

src/Dhall/Diff.hs view

file too large to diff

src/Dhall/Eval.hs view

file too large to diff

src/Dhall/Freeze.hs view

file too large to diff

src/Dhall/Import.hs view

file too large to diff

src/Dhall/Import/HTTP.hs view

file too large to diff

src/Dhall/Import/Types.hs view

file too large to diff

src/Dhall/Lint.hs view

file too large to diff

src/Dhall/Main.hs view

file too large to diff

src/Dhall/Map.hs view

file too large to diff

src/Dhall/Parser/Combinators.hs view

file too large to diff

src/Dhall/Parser/Expression.hs view

file too large to diff

src/Dhall/Parser/Token.hs view

file too large to diff

src/Dhall/Pretty/Internal.hs view

file too large to diff

src/Dhall/Set.hs view

file too large to diff

src/Dhall/Src.hs view

file too large to diff

src/Dhall/Tutorial.hs view

file too large to diff

src/Dhall/TypeCheck.hs view

file too large to diff

+ src/Dhall/X.hs view

file too large to diff

tests/Dhall/Test/Dhall.hs view

file too large to diff

+ tests/Dhall/Test/Diff.hs view

file too large to diff

tests/Dhall/Test/Import.hs view

file too large to diff

tests/Dhall/Test/Main.hs view

file too large to diff

tests/Dhall/Test/Normalization.hs view

file too large to diff

tests/Dhall/Test/Parser.hs view

file too large to diff

tests/Dhall/Test/QuickCheck.hs view

file too large to diff

tests/Dhall/Test/Regression.hs view

file too large to diff

+ tests/Dhall/Test/SemanticHash.hs view

file too large to diff

tests/Dhall/Test/TypeCheck.hs view

file too large to diff

+ tests/Dhall/Test/TypeInference.hs view

file too large to diff

tests/Dhall/Test/Util.hs view

file too large to diff

+ tests/diff/appList.txt view

file too large to diff

+ tests/diff/appListA.dhall view

file too large to diff

+ tests/diff/appListB.dhall view

file too large to diff

tests/format/escapeSingleQuotedOpenInterpolationB.dhall view

file too large to diff

+ tests/format/innerMultilineA.dhall view

file too large to diff

+ tests/format/innerMultilineB.dhall view

file too large to diff

tests/format/multilineB.dhall view

file too large to diff

tests/format/unicodeA.dhall view

file too large to diff

tests/format/unicodeB.dhall view

file too large to diff

tests/regression/issue151a.dhall view

file too large to diff

tests/regression/issue151b.dhall view

file too large to diff