!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe3&A  (Context a) associates  labels with values of type a . Each 1 label can correspond to multiple values of type aThe  is used for type-checking when  (a = Expr X) You create a  using  and You transform a  using You consume a  using   and  The difference between a  and a    is that a ^ lets you have multiple ordered occurrences of the same key and you can query for the nth occurrence of a given key.(An empty context with no key-value pairsAdd a key-value pair to the "Pattern match" on a  Jmatch (insert k v ctx) = Just (k, v, ctx) match empty = Nothing Look up a key by name and index lookup _ _ empty = Nothing lookup k 0 (insert k v c) = Just v lookup k n (insert k v c) = lookup k (n - 1) c lookup k n (insert j v c) = lookup k n c -- k /= j +Return all key-value associations as a list JtoList empty = [] toList (insert k v ctx) = (k, v) : toList ctx  None "#345BQVҝ] Syntax tree for expressions Label for a bound variableThe % field is the variable's name (i.e. "x").The ! field disambiguates variables with the same name if there are multiple bound variables of the same name in scope. Zero refers to the nearest bound variable and the index increases by one for each bound variable of the same name going outward. The following diagram may help: p % %%refers to%%% % % v % (x : Type) ! (y : Type) ! (x : Type) ! x@0 % %%%%%%%%%%%%%%%%%refers to%%%%%%%%%%%%%%%%%% % % v % (x : Type) ! (y : Type) ! (x : Type) ! x@1This _ behaves like a De Bruijn index in the special case where all variables have the same name.+You can optionally omit the index if it is 0:  % %refers to%% % % v % (x : Type) ! (y : Type) ! (x : Type) ! x.Zero indices are omitted when pretty-printing  6s and non-zero indices appear as a numeric suffix. Constants for a pure type systemThe only axiom is:  " Type : Kind!... and the valid rule pairs are: " Type ! Type : Type -- Functions from terms to terms (ordinary functions) " Kind ! Type : Type -- Functions from types to terms (polymorphic functions) " Kind ! Kind : Kind -- Functions from types to types (type constructors)*These are the same rule pairs as System FzNote that Dhall does not support functions from terms to types and therefore Dhall is not a dependently typed language-Use this to wrap you embedded functions (see w0) to make them polymorphic enough to be used.The body of an interpolated Text literal -Const c ~ c ]Var (V x 0) ~ x Var (V x n) ~ x@n 9Lam x A b ~ (x : A) -> b sPi "_" A B ~ A -> B Pi x A B ~ "(x : A) -> B /App f a ~ f a }Let x Nothing r e ~ let x = r in e Let x (Just t) r e ~ let x : t = r in e 1Annot x t ~ x : t 0Bool ~ Bool -BoolLit b ~ b 2BoolAnd x y ~ x && y 2BoolOr x y ~ x || y! 2BoolEQ x y ~ x == y" 2BoolNE x y ~ x != y# >BoolIf x y z ~ if x then y else z$ 3Natural ~ Natural% -NaturalLit n ~ n& 8NaturalFold ~ Natural/fold' 9NaturalBuild ~ Natural/build( :NaturalIsZero ~ Natural/isZero) 8NaturalEven ~ Natural/even* 7NaturalOdd ~ Natural/odd+ =NaturalToInteger ~ Natural/toInteger, 8NaturalShow ~ Natural/show- 1NaturalPlus x y ~ x + y. 1NaturalTimes x y ~ x * y/ 3Integer ~ Integer0 .IntegerLit n ~ n1 8IntegerShow ~ Integer/show2 2Double ~ Double3 -DoubleLit n ~ n4 7DoubleShow ~ Double/show5 0Text ~ Text6 >TextLit (Chunks [(t1, e1), (t2, e2)] t3) ~ "t1${e1}t2${e2}t3"7 2TextAppend x y ~ x ++ y8 0List ~ List9 tListLit (Just t ) [x, y, z] ~ [x, y, z] : List t ListLit Nothing [x, y, z] ~ [x, y, z]: 1ListAppend x y ~ x # y; 6ListBuild ~ List/build< 5ListFold ~ List/fold= 7ListLength ~ List/length> 5ListHead ~ List/head? 5ListLast ~ List/last@ 8ListIndexed ~ List/indexedA 8ListReverse ~ List/reverseB 4Optional ~ OptionalC yOptionalLit t (Just e) ~ [e] : Optional t OptionalLit t Nothing ~ [] : Optional tD 9OptionalFold ~ Optional/foldE :OptionalBuild ~ Optional/buildF @Record [(k1, t1), (k2, t2)] ~ { k1 : t1, k2 : t1 }G @RecordLit [(k1, v1), (k2, v2)] ~ { k1 = v1, k2 = v2 }H AUnion [(k1, t1), (k2, t2)] ~ < k1 : t1 | k2 : t2 >I IUnionLit k v [(k1, t1), (k2, t2)] ~ < k = v | k1 : t1 | k2 : t2 >J 1Combine x y ~ x "' yK 1CombineTypes x y ~ x *S yL 1CombineRight x y ~ x * yM oMerge x y (Just t ) ~ merge x y : t Merge x y Nothing ~ merge x yN :Constructors e ~ constructors eO /Field e x ~ e.xP 4Project e xs ~ e.{ xs }Q -Note s x ~ eR 2Embed import ~ importTType synonym for U&, provided for backwards compatibilityU!Reference to an external resourceYA `= extended with an optional hash for semantic integrity checks]GHow to interpret the import's contents (i.e. as Dhall code or raw text)`:The type of import (i.e. local vs. remote vs. environment)a Local pathb?URL of remote resource and optional headers stored in an importcEnvironment variablee Absolute pathfPath relative to .gPath relative to ..hPath relative to ~iA i is a k@ followed by one additional path component representing the l namem[Internal representation of a directory that stores the path components in reverse orderIn other words, the directory foobar/baz is encoded as 2Directory { components = [ "baz", "bar", "foo" ] }rrk is used by both normalization and type-checking to avoid variable capture by shifting variable indicesIFor example, suppose that you were to normalize the following expression: 4(a : Type) ! (x : a) ! ((y : a) ! (x : a) ! y) xIf you were to substitute y with x^ without shifting any variable indices, then you would get the following incorrect result: C(a : Type) ! (x : a) ! (x : a) ! x -- Incorrect normalized formIn order to substitute x in place of y we need to r x by 13 in order to avoid being misinterpreted as the x8 bound by the innermost lambda. If we perform that r then we get the correct result: '(a : Type) ! (x : a) ! (x : a) ! x@1ZAs a more worked example, suppose that you were to normalize the following expression: [ (a : Type) ! (f : a ! a ! a) ! (x : a) ! (x : a) ! ((x : a) ! f x x@1) x@1'The correct normalized result would be: J (a : Type) ! (f : a ! a ! a) ! (x : a) ! (x : a) ! f x@1 xuThe above example illustrates how we need to both increase and decrease variable indices as part of substitution:+We need to increase the index of the outer x@1 to x@2 before we substitute it into the body of the innermost lambda expression in order to avoid variable capture. This substitution changes the body of the lambda expression to  (f x@2 x@1)UWe then remove the innermost lambda and therefore decrease the indices of both xs in  (f x@2 x@1) to  (f x@1 x)) in order to reflect that one less x( variable is now bound within that scope Formally, (shift d (V x n) e) modifies the expression e by adding d+ to the indices of all variables named x$ whose indices are greater than (n + m), where mH is the number of bound variables of the same name within that scope In practice, d is always 1 or -1 because we either:increment variables by 1. to avoid variable capture during substitutiondecrement variables by 1) when deleting lambdas after substitutionn starts off at 0 when substitution begins and increments every time we descend into a lambda or let expression that binds a variable of the same name in order to avoid shifting the bound variables by mistake.s;Substitute all occurrences of a variable with an expression subst x C B ~ B[x := C]t7-normalize an expression by renaming all variables to "_"4 and using De Bruijn indices to distinguish themuBReduce an expression to its normal form, performing beta reductionu does not type-check the expression. You may want to type-check expressions before normalizing them since normalization can convert an ill-typed expression into a well-typed expression. However, ug will not fail if the expression is ill-typed and will leave ill-typed sub-expressions unevaluated.6This function is used to determine whether folds like  Natural/fold or  List/foldW should be lazy or strict in their accumulator based on the type of the accumulatorIf this function returns , then they will be strict in their accumulator since we can guarantee an upper bound on the amount of work to normalize the accumulator on each step of the loop. If this function returns k then they will be lazy in their accumulator and only normalize the final result at the end of the foldv Remove all Q constructors from an   (i.e. de-Q)wkReduce an expression to its normal form, performing beta reduction and applying any custom definitions.w& is designed to be used with function typeWith. The typeWithV function allows typing of Dhall functions in a custom typing context whereas w9 allows evaluating Dhall expressions in a custom context.To be more precise wi applies the given normalizer when it finds an application term that it cannot reduce by other means.Note that the context used in normalization will determine the properties of normalization. That is, if the functions in custom context are not total then the Dhall language, evaluated with those functions is not total either.xReturns > if two expressions are -equivalent and -equivalent and  otherwiseyTCheck if an expression is in a normal form given a context of evaluation. Unlike z@, this will fully normalize and traverse through the expression.!It is much more efficient to use z.z0Quickly check if an expression is in normal form{Utility function used to throw internal errors that should never happen (in theory) but that are not enforced by the type system|6The set of reserved identifiers for the Dhall language-Generates a syntactically valid Dhall programo 2/$5O8HF !"#%&'()*+,-.0134679:;<=>?@ABCDEGIJKLMNPQR SpqTUVWXYZ[\]^_`cabdefghijklmnorstuvwxyz{|opqmnoijkldefghUVWXYZ[\]^_`abcT S  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRtuwxsrzyv{| = !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR SpqUVWXYZ[\]^_`abcdefghijklmnoNone"#1KA parsing errorA ! that is almost identical to Text.Megaparsec.9 except treating Haskell-style comments as whitespaceSource code extract Similar to   except that this doesn't bother to render interpolated expressions to avoid a `Buildable a` constraint. The interpolated contents are not necessary for computing how much to dedent a multi-line stringjThis also doesn't include the surrounding quotes since they would interfere with the whitespace detection'Parser for a top-level Dhall expressionParser for a top-level Dhall expression. The expression is parameterized over any parseable type, allowing the language to be extended as needed.Parse an expression from  containing a Dhall programLike u but also returns the leading comments and whitespace (i.e. header) up to the last newline before the code begins5In other words, if you have a Dhall file of the form: -- Comment 1 2Then this will preserve  Comment 1 , but not  Comment 2This is used by  dhall-format, to preserve leading comments and whitespace  None)[7fAnnotation type used to tag elements in a pretty-printed document for syntax highlighting purposes Escape a % literal using Dhall's escaping rules8Note that the result does not include surrounding quotesPretty-print a valueBuilder corresponding to the double token in  Dhall.ParserBuilder corresponding to the number token in  Dhall.ParserBuilder corresponding to the natural token in  Dhall.ParserPretty print an expressionBuilder corresponding to the expr parser in  Dhall.ParserBuilder corresponding to the var parser in  Dhall.ParserBuilder corresponding to the const parser in  Dhall.ParserUsed for syntactic keywords:Syntax punctuation such as commas, parenthesis, and braces Record labels%Literals such as integers and stringsBuiltin types and values OperatorsUConvert annotations to their corresponding color for syntax highlighting purposesZInternal utility for pretty-printing, used when generating element lists to supply to  or z. This utility indicates that the compact represent is the same as the multi-line representation for each elementPretty-print a list%Pretty-print union types and literals&Pretty-print record types and literals3Pretty-print anonymous functions and function typescFormat an expression that holds a variable number of elements, such as a list, record, or unionmFormat an expression that holds a variable number of elements without a trailing document such as nested `let`, nested lambdas, or nested sBuilder corresponding to the label token in  Dhall.ParserBuilder corresponding to the text token in  Dhall.Parser Escape a ; literal using Dhall's escaping rules for single-quoted TextBuilder corresponding to the exprA parser in  Dhall.ParserBuilder corresponding to the exprB parser in  Dhall.ParserBuilder corresponding to the exprC parser in  Dhall.ParserBuilder corresponding to the exprC0 parser in  Dhall.ParserBuilder corresponding to the exprC1 parser in  Dhall.ParserBuilder corresponding to the exprC2 parser in  Dhall.ParserBuilder corresponding to the exprC3 parser in  Dhall.ParserBuilder corresponding to the exprC4 parser in  Dhall.ParserBuilder corresponding to the exprC5 parser in  Dhall.ParserBuilder corresponding to the exprC6 parser in  Dhall.ParserBuilder corresponding to the exprC7 parser in  Dhall.ParserBuilder corresponding to the exprC8 parser in  Dhall.ParserBuilder corresponding to the exprC9 parser in  Dhall.ParserBuilder corresponding to the exprC10 parser in  Dhall.ParserBuilder corresponding to the exprD parser in  Dhall.ParserBuilder corresponding to the exprE parser in  Dhall.ParserBuilder corresponding to the exprF parser in  Dhall.ParserBuilder corresponding to the elems parser in  Dhall.ParserBuilder corresponding to the  recordLit parser in  Dhall.ParserBuilder corresponding to the  fieldValues parser in  Dhall.ParserBuilder corresponding to the  fieldValue parser in  Dhall.ParserBuilder corresponding to the record parser in  Dhall.ParserBuilder corresponding to the  fieldTypes parser in  Dhall.ParserBuilder corresponding to the  fieldType parser in  Dhall.ParserBuilder corresponding to the union parser in  Dhall.ParserBuilder corresponding to the alternativeTypes parser in  Dhall.ParserBuilder corresponding to the alternativeType parser in  Dhall.ParserBuilder corresponding to the unionLit parser in  Dhall.Parser-Beginning document for compact representation0Beginning document for multi-line representation$Separator for compact representation'Separator for multi-line representation*Ending document for compact representation-Ending document for multi-line representation-Elements to format, each of which is a pair: (compact, multi-line)-Beginning document for compact representation0Beginning document for multi-line representation$Separator for compact representation'Separator for multi-line representation-Elements to format, each of which is a pair: (compact, multi-line),     None*a  None"#,@Render the difference between the normal form of two expressions-Render the difference between two expressions !None"#1QV? oNewtype used to wrap error messages so that they render with a more detailed explanation of what went wrong-A structured type error that includes context"6Default succinct 1-line explanation of what went wrong#1Longer and more detailed explanation of the errorThe specific type errorLike  %, except with a shorter inferred type!+Function that converts the value inside an R& constructor into a new expression"zType-check an expression and return the expression's type if type-checking succeeds or an error if type-checking fails" does not necessarily normalize the type since full normalization is not necessary for just type-checking. If you actually care about the returned type then you may want to u it afterwards.#Generalization of " that allows type-checking the R" constructor with custom logic$$ is the same as " with an empty context, meaning that the expression must be closed (i.e. no free variables), otherwise type-checking will fail.%cThis function verifies that a custom context is well-formed so that type-checking will not loop Note that " already calls % for you on the  that you supplyB      !"#$%B"$#%!      $%"#2      None "#$1QVq&.Exception thrown when an integrity check fails'fThis exception indicates that there was an internal error in Dhall's import-related logic the expected type then the extractB function must succeed. If not, then this exception is thrown)This exception indicates that an invalid Type was provided to the  function( .canonicalize (canonicalize x) = canonicalize x1,State threaded throughout the import process3 Stack of U@s that we've imported along the way to get to the current point4lCache of imported expressions in order to avoid importing the same expression twice with different values5Cache for the ) so that we only acquire it once68Exception thrown when an environment variable is missing91Exception thrown when an imported file is missing;Newtype used to wrap *s with a prettier + instance=6Extend another exception with the current import stack?)Imports resolved so far, in reverse order@The nested exceptionADhall tries to ensure that all expressions hosted on network endpoints are weakly referentially transparent, meaning roughly that any two clients will compile the exact same result given the same URL.To be precise, a strong interpretaton of referential transparency means that if you compiled a URL you could replace the expression hosted at that URL with the compiled result. Let's call this "static linking". Dhall (very intentionally) does not satisfy this stronger interpretation of referential transparency since "statically linking" an expression (i.e. permanently resolving all imports) means that the expression will no longer update if its dependencies change.`In general, either interpretation of referential transparency is not enforceable in a networked context since one can easily violate referential transparency with a custom DNS, but Dhall can still try to guard against common unintentional violations. To do this, Dhall enforces that a non-local import may not reference a local import.Local imports are defined as:A fileA URL with a host of  localhost or  127.0.0.1-All other imports are defined to be non-localCThe offending opaque importD7An import failed because of a cycle in the import graphFThe offending cyclic importGDefault starting 1HParse an expression from a U containing a Dhall program,Load an U: as a "dynamic" expression (without resolving any imports)ILResolve all imports within an expression using a custom typing context and U!-resolving callback in arbitrary - monad.JGResolve all imports within an expression using a custom typing context. *load = loadWithContext Dhall.Context.emptyK(Resolve all imports within an expressionL Hash a fully resolved expressionMiConvenience utility to hash a fully resolved expression and return the base-16 encoded hash with the sha256: prefix{In other words, the output of this function can be pasted into Dhall source code to add an integrity check to an import123456789:;<=>?@ABCDEFGHIJKLMHKIJLM12345GDEFABC=>?@;<9:678 &./0'1(2123456789:;<=>?@ABCDEFNone"#0367;<=KQSTVK'cThe c+ applicative functor allows you to build a u parser from a Dhall record.8For example, let's take the following Haskell data type: mdata Project = Project { projectName :: Text , projectDescription :: Text , projectStars :: Natural }XAnd assume that we have the following Dhall record that we would like to parse as a Project: w{ name = "dhall-haskell" , description = "A configuration language guaranteed to terminate" , stars = 289 }Our parser has type u Project=, but we can't build that out of any smaller parsers, as u$s cannot be combined (they are only 3s). However, we can use a c to build a u for Project: project :: Type Project project = record ( Project <$> field "name" string <*> field "description" string <*> field "stars" natural )e-This is the underlying class that powers the sH class's support for automatically deriving a generic implementationgThis class is used by s instance for functions: 6instance (Inject a, Interpret b) => Interpret (a -> b)You can convert Dhall functions with "simple" inputs (i.e. instances of this class) into Haskell functions. This works by:QMarshaling the input to the Haskell function into a Dhall expression (i.e. x :: Expr Src X)"Applying the Dhall function (i.e. f :: Expr Src X!) to the Dhall input (i.e. App f x)"Normalizing the syntax tree (i.e. normalize (App f x))CMarshaling the resulting Dhall expression back into a Haskell valueiAn  (InputType a)- represents a way to marshal a value of type 'a' from Haskell into Dhallk,Embeds a Haskell value as a Dhall expressionlDhall type of the Haskell valuem-This is the underlying class that powers the sH class's support for automatically deriving a generic implementationoMUse these options to tweak how Dhall derives a generic implementation of sq\Function used to transform Haskell field names into their corresponding Dhall field namesrhFunction used to transform Haskell constructor names into their corresponding Dhall alternative namessAny value that implements sG can be automatically decoded based on the inferred return type of {-input auto "[1, 2, 3]" :: IO (Vector Natural)[1,2,3]RThis class auto-generates a default implementation for records that implement C. This does not auto-generate an instance for recursive types.uA (Type a)- represents a way to marshal a value of type 'a' from Dhall into HaskellYou can produce us either explicitly: 3example :: Type (Vector Text) example = vector text... or implicitly using : ,example :: Type (Vector Text) example = autoYou can consume u s using the { function: input :: Type a -> Text -> IO aw0Extracts Haskell value from the Dhall expressionxDhall type of the Haskell valueyEvery uI must obey the contract that if an expression's type matches the the x type then the wB function must succeed. If not, then this exception is thrown)This exception indicates that an invalid u was provided to the { function{IType-check and evaluate a Dhall program, decoding the result into Haskell@The first argument determines the type of value that you decode:input integer "+2"2"input (vector double) "[1.0, 2.0]" [1.0,2.0]Use T to automatically select which type to decode based on the inferred return type:input auto "True" :: IO BoolTrue|Extend {8 with a custom typing context and normalization process.}Use this function to extract Haskell values directly from Dhall AST. The intended use case is to allow easy extraction of Dhall values for making the function w easier to use.For other use cases, use { from Dhall; module. It will give you a much better user experience.~0Use this to provide more detailed error messages {> input auto "True" :: IO Integer *** Exception: Error: Expression doesn't match annotation True : Integer (input):1:1  > detailed (input auto "True") :: IO Integer *** Exception: Error: Expression doesn't match annotation Explanation: You can annotate an expression with its type or kind using the 'p:'q symbol, like this: % %%%%%%%% % x : t % 'px'q is an expression and 'pt'q is the annotated type or kind of 'px'q %%%%%%%%% The type checker verifies that the expression's type or kind matches the provided annotation For example, all of the following are valid annotations that the type checker accepts: % %%%%%%%%%%%%%% % 1 : Natural % 'p1'q is an expression that has type 'pNatural'q, so the type %%%%%%%%%%%%%%% checker accepts the annotation % %%%%%%%%%%%%%%%%%%%%%%%% % Natural/even 2 : Bool % 'pNatural/even 2'q has type 'pBool'q, so the type %%%%%%%%%%%%%%%%%%%%%%%%% checker accepts the annotation % %%%%%%%%%%%%%%%%%%%%% % List : Type ! Type % 'pList'q is an expression that has kind 'pType ! Type'q, %%%%%%%%%%%%%%%%%%%%%% so the type checker accepts the annotation % %%%%%%%%%%%%%%%%%%% % List Text : Type % 'pList Text'q is an expression that has kind 'pType'q, so %%%%%%%%%%%%%%%%%%%% the type checker accepts the annotation However, the following annotations are not valid and the type checker will reject them: % %%%%%%%%%%% % 1 : Text % The type checker rejects this because 'p1'q does not have type %%%%%%%%%%%% 'pText'q % %%%%%%%%%%%%%% % List : Type % 'pList'q does not have kind 'pType'q %%%%%%%%%%%%%%% You or the interpreter annotated this expression: ! True ... with this type or kind: ! Integer ... but the inferred type or kind of the expression is actually: ! Bool Some common reasons why you might get this error: % The Haskell Dhall interpreter implicitly inserts a top-level annotation matching the expected type For example, if you run the following Haskell code: % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % >>> input auto "1" :: IO Text % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ... then the interpreter will actually type check the following annotated expression: % %%%%%%%%%%% % 1 : Text % %%%%%%%%%%%% ... and then type-checking will fail %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% True : Integer (input):1:1 Decode a 4input bool "True"True Decode a input natural "42"42 Decode an 5input integer "+42"42 Decode a 6input scientific "1e1000000000"1.0e1000000000 Decode a 7input double "42.0"42.0 Decode lazy input lazyText "\"Test\"""Test"Decode strict input strictText "\"Test\"""Test" Decode a 8.input (maybe natural) "[1] : Optional Natural"Just 1 Decode a = - >>> input (sequence natural) "[1, 2, 3]" fromList [1,2,3] Decode a list input (list natural) "[1, 2, 3]"[1,2,3] Decode a "input (vector natural) "[1, 2, 3]"[1,2,3]!Decode `()` from an empty record.?input unit "{=}" -- GHC doesn't print the result if it is @()@ Decode a 9input string "\"ABC\"""ABC""Given a pair of u,s, decode a tuple-record into their pairing.3input (pair natural bool) "{ _1 = 42, _2 = False }" (42,False)=Use the default options for interpreting a configuration file 'auto = autoWith defaultInterpretOptions# is the default implementation for  if you derive s&. The difference is that you can use - without having to explicitly provide an s5 instance for a type as long as the type derives FDefault interpret options, which you can tweak or override, like this: \autoWith (defaultInterpretOptions { fieldModifier = Data.Text.Lazy.dropWhile (== '_') })-Use the default options for injecting a value 'inject = inject defaultInterpretOptionsRun a c parser to build a u parser.!Parse a single field of a record.{1The type of value to decode from Dhall to HaskellThe Dhall programThe decoded value in Haskell|1The type of value to decode from Dhall to Haskell&The starting context for type-checkingThe Dhall programThe decoded value in Haskell}1The type of value to decode from Dhall to HaskellAa closed form Dhall program, which evaluates to the expected typeThe decoded value in Haskell5cdefghijklmnopqrstuvwxyz{|}~7{|~uvwxcdijklsttyzopqrmnefghh} cdefghhijklmnopqrsttuvwxyzNone: !"#$%&' ( ) * +,--'&./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiijkllmnopqrstuvwxyz{{|}~~             !"#$%&'())*+,-./0123456789:;;<=>??@AABBCCDEFFGHHIJKLMNOPQRSTUVWXYZ[\]^_`abcdeffghijkklmnoppqrstuvwwxyz{|}~                                                                        !!"#$%&'%&()*+,-."/0#12334D567G89:!dhall-1.14.0-XK1NBatV51ORwjePXL7VDhall Dhall.Context Dhall.Core Dhall.Pretty Dhall.Parser Dhall.DiffDhall.TypeCheck Dhall.ImportData.MapMap buildChunksDhall.Pretty.Internal Data.VoidVoidDhall.Tutorialbase GHC.GenericsGeneric GHC.NaturalNatural#text-1.2.2.2-EakMpasry3jA6OIwSZhq9MData.Text.Internal.LazyTextcontainers-0.5.10.2Data.Sequence.InternalSeq&vector-0.12.0.1-LflPw1fguMb6as60UrZpxN Data.VectorVectorContextemptyinsertmatchlookuptoList$fFunctorContextExprVarConstAnn escapeTextpretty prettyExpr NormalizerChunksLamPiAppLetAnnotBoolBoolLitBoolAndBoolOrBoolEQBoolNEBoolIf NaturalLit NaturalFold NaturalBuild NaturalIsZero NaturalEven NaturalOddNaturalToInteger NaturalShow NaturalPlus NaturalTimesInteger IntegerLit IntegerShowDouble DoubleLit DoubleShowTextLit TextAppendListListLit ListAppend ListBuildListFold ListLengthListHeadListLast ListIndexed ListReverseOptional OptionalLit OptionalFold OptionalBuildRecord RecordLitUnionUnionLitCombine CombineTypesPreferMerge ConstructorsFieldProjectNoteEmbedVPathImport importHashed importMode ImportHashedhash importType ImportModeCodeRawText ImportTypeLocalURLEnv FilePrefixAbsoluteHereParentHomeFile directoryfile Directory componentsTypeKindshiftsubstalphaNormalize normalizedenote normalizeWithjudgmentallyEqualisNormalizedWith isNormalized internalErrorreservedIdentifiers$fBuildableConst$fBuildableDirectory$fSemigroupDirectory$fSemigroupFile$fBuildableFile$fBuildableFilePrefix$fBuildableImportHashed$fSemigroupImportHashed$fBuildableImportType$fSemigroupImportType$fPrettyImport$fBuildableImport$fSemigroupImport$fBuildableVar $fIsStringVar $fPrettyExpr$fBuildableExpr$fIsStringChunks$fMonoidChunks$fSemigroupChunks$fIsStringExpr$fBifunctorExpr $fMonadExpr$fApplicativeExpr $fShowConst $fEqConst$fBoundedConst $fEnumConst $fEqDirectory$fOrdDirectory$fShowDirectory$fEqFile $fOrdFile $fShowFile$fEqFilePrefix$fOrdFilePrefix$fShowFilePrefix$fEqImportMode$fOrdImportMode$fShowImportMode$fEqImportHashed$fOrdImportHashed$fShowImportHashed$fEqImportType$fOrdImportType$fShowImportType $fEqImport $fOrdImport $fShowImport$fEqVar $fShowVar$fFunctorChunks$fFoldableChunks$fTraversableChunks $fShowChunks $fEqChunks $fFunctorExpr$fFoldableExpr$fTraversableExpr $fShowExpr$fEqExpr ParseErrorunwrapinputParserunParserSrcexprexprA exprFromTextexprAndHeaderFromText$fBuildableSrc$fTokenParsingParser$fCharParsingParser$fParsingParser$fIsStringParser$fMonoidParser$fSemigroupParser$fExceptionParseError$fShowParseError$fEqSrc $fShowSrc$fFunctorParser$fApplicativeParser $fMonadParser$fAlternativeParser$fMonadPlusParser$fMonadParsecParserKeywordSyntaxLabelLiteralBuiltinOperatorannToAnsiStylediffNormalizeddiff$fIsStringDiff $fMonoidDiff$fSemigroupDiffDetailedTypeError TypeErrorcontextcurrent typeMessage TypeMessageUnboundVariableInvalidInputTypeInvalidOutputType NotAFunction TypeMismatch AnnotMismatchUntypedMissingListTypeMismatchedListElementsInvalidListElementInvalidListTypeInvalidOptionalElementInvalidOptionalTypeInvalidPredicateIfBranchMismatchIfBranchMustBeTerm InvalidFieldInvalidFieldTypeFieldAnnotationMismatch FieldMismatchInvalidAlternativeInvalidAlternativeTypeListAppendMismatchDuplicateAlternativeMustCombineARecordCombineTypesRequiresRecordTypeRecordTypeMismatchFieldCollisionMustMergeARecordMustMergeUnion UnusedHandlerMissingHandlerHandlerInputTypeMismatchHandlerOutputTypeMismatchInvalidHandlerOutputTypeMissingMergeTypeHandlerNotAFunctionConstructorsRequiresAUnionType NotARecord MissingFieldCantAndCantOrCantEQCantNECantInterpolateCantTextAppendCantListAppendCantAdd CantMultiplyNoDependentTypesXabsurdTypertypeWith typeWithAtypeOf checkContext $fPrettyX $fBuildableX$fEqX$fShowX$fBuildableTypeError$fExceptionTypeError$fShowTypeError$fBuildableDetailedTypeError$fExceptionDetailedTypeError$fShowDetailedTypeError$fShowTypeMessageStatus_stack_cache_managerMissingEnvironmentVariablename MissingFilePrettyHttpExceptionImported importStacknestedReferentiallyOpaque opaqueImportCycle cyclicImport emptyStatusexprFromImportloadWithloadWithContextloadhashExpressionhashExpressionToCode $fShowCycle$fExceptionCycle$fShowReferentiallyOpaque$fExceptionReferentiallyOpaque$fShowImported$fExceptionImported$fShowPrettyHttpException$fExceptionPrettyHttpException$fShowMissingFile$fExceptionMissingFile $fShowMissingEnvironmentVariable%$fExceptionMissingEnvironmentVariable$fCanonicalizeImport$fCanonicalizeImportHashed$fCanonicalizeImportType$fCanonicalizeFile$fCanonicalizeDirectory$fExceptionInternalError$fShowInternalError$fShowHashMismatch$fExceptionHashMismatch RecordType GenericInjectgenericInjectWithInject injectWith InputTypeembeddeclaredGenericInterpretgenericAutoWithInterpretOptions fieldModifierconstructorModifier InterpretautoWithextractexpected InvalidType inputWithrawInputdetailedboolnaturalinteger scientificdoublelazyText strictTextmaybesequencelistvectorunitstringpairauto genericAutodefaultInterpretOptionsinjectrecordfield$fExceptionInvalidType$fShowInvalidType$fGenericInterpret:*:$fGenericInterpretU1$fGenericInterpretM1$fGenericInterpret:+:$fGenericInterpret:+:0$fGenericInterpret:+:1$fGenericInterpret:+:2$fGenericInterpretV1$fGenericInterpretM10$fGenericInterpretM11$fInterpret(,)$fInterpretVector $fInterpret[]$fInterpretSeq$fInterpretMaybe$fInterpretText$fInterpretText0$fInterpret[]0$fInterpretDouble$fInterpretScientific$fInterpretInteger$fInterpretNatural$fInterpretBool$fContravariantInputType$fGenericInjectU1$fGenericInject:*:$fGenericInject:+:$fGenericInject:+:0$fGenericInject:+:1$fGenericInject:+:2$fGenericInjectM1$fGenericInjectM10$fGenericInjectM11 $fInject(,) $fInjectSet$fInjectVector $fInject[] $fInjectSeq $fInjectMaybe $fInject()$fInjectDouble$fInjectScientific$fInjectWord64$fInjectWord32$fInjectWord16 $fInjectWord8 $fInjectInt$fInjectInteger$fInjectNatural $fInjectText $fInjectText0 $fInjectBool$fInterpret(->) $fFunctorType$fFunctorRecordType$fApplicativeRecordTypeGHC.Basefmap getContextghc-prim GHC.TypesInt boundedTypeTrueFalse&megaparsec-6.5.0-1j1Pq3EX3Lmy68pRo470XText.MegaparsecParsecData.Text.Internal.BuilderBuilderbuildScientific buildNumber buildNatural buildExprbuildVar buildConst duplicateencloseenclose'anglesbracesarrowsforall buildLabelescapeSingleQuotedText buildExprA buildExprB buildExprC buildExprC0 buildExprC1 buildExprC2 buildExprC3 buildExprC4 buildExprC5 buildExprC6 buildExprC7 buildExprC8 buildExprC9 buildExprC10 buildExprD buildExprE buildExprF buildElemsbuildRecordLitbuildFieldValuesbuildFieldValue buildRecordbuildFieldTypesbuildFieldType buildUnionbuildAlternativeTypesbuildAlternativeType buildUnionLitkeywordlabelliteralbuiltinoperatorcommalbracketrbracketlangleranglelbracerbracelparenrparenpiperarrowcolonlambdaequalsdot prettyLabel prettyLabels prettyNumber prettyNaturalprettyScientific prettyConstDiffsamedocshortlong ErrorMessages HashMismatch InternalError Canonicalize*http-client-0.5.12.1-KnBIdM9at9cXxAKgZxCG1Network.HTTP.Client.TypesManager HttpExceptionGHC.ShowShow loadDynamic(exceptions-0.10.0-BUU8s9pCscREfUFAryYPyWControl.Monad.Catch MonadCatch expectedHash actualHash canonicalizeFunctor integer-gmpGHC.Integer.Type'scientific-0.3.5.2-HPE8LSeKW1DmhBXwWvUQData.Scientific ScientificMaybeString