!/      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ `abcdefghijklmnopqrstuvwxyz{|}~ Safe3'dhallA  (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.dhall(An empty context with no key-value pairsdhallAdd a key-value pair to the dhall"Pattern match" on a  Jmatch (insert k v ctx) = Just (k, v, ctx) match empty = Nothing dhallLook 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 dhall+Return all key-value associations as a list JtoList empty = [] toList (insert k v ctx) = (k, v) : toList ctx  None"#1K*vdhallA ! that is almost identical to Text.Megaparsec.9 except treating Haskell-style comments as whitespacedhallSource code extract None "#1345BQV}_ dhallSyntax tree for expressions dhallLabel 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.dhall 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 languagedhall-Use this to wrap you embedded functions (see ~0) to make them polymorphic enough to be used.dhallThe body of an interpolated Text literaldhall -Const c ~ cdhall ]Var (V x 0) ~ x Var (V x n) ~ x@ndhall 9Lam x A b ~ (x : A) -> bdhall sPi "_" A B ~ A -> B Pi x A B ~ "(x : A) -> Bdhall /App f a ~ f a dhall }Let x Nothing r e ~ let x = r in e Let x (Just t) r e ~ let x : t = r in e!dhall 1Annot x t ~ x : t"dhall 0Bool ~ Bool#dhall -BoolLit b ~ b$dhall 2BoolAnd x y ~ x && y%dhall 2BoolOr x y ~ x || y&dhall 2BoolEQ x y ~ x == y'dhall 2BoolNE x y ~ x != y(dhall >BoolIf x y z ~ if x then y else z)dhall 3Natural ~ Natural*dhall -NaturalLit n ~ n+dhall 8NaturalFold ~ Natural/fold,dhall 9NaturalBuild ~ Natural/build-dhall :NaturalIsZero ~ Natural/isZero.dhall 8NaturalEven ~ Natural/even/dhall 7NaturalOdd ~ Natural/odd0dhall =NaturalToInteger ~ Natural/toInteger1dhall 8NaturalShow ~ Natural/show2dhall 1NaturalPlus x y ~ x + y3dhall 1NaturalTimes x y ~ x * y4dhall 3Integer ~ Integer5dhall .IntegerLit n ~ n6dhall 8IntegerShow ~ Integer/show7dhall <IntegerToDouble ~ Integer/toDouble8dhall 2Double ~ Double9dhall -DoubleLit n ~ n:dhall 7DoubleShow ~ Double/show;dhall 0Text ~ Text<dhall >TextLit (Chunks [(t1, e1), (t2, e2)] t3) ~ "t1${e1}t2${e2}t3"=dhall 2TextAppend x y ~ x ++ y>dhall 0List ~ List?dhall tListLit (Just t ) [x, y, z] ~ [x, y, z] : List t ListLit Nothing [x, y, z] ~ [x, y, z]@dhall 1ListAppend x y ~ x # yAdhall 6ListBuild ~ List/buildBdhall 5ListFold ~ List/foldCdhall 7ListLength ~ List/lengthDdhall 5ListHead ~ List/headEdhall 5ListLast ~ List/lastFdhall 8ListIndexed ~ List/indexedGdhall 8ListReverse ~ List/reverseHdhall 4Optional ~ OptionalIdhall yOptionalLit t (Just e) ~ [e] : Optional t OptionalLit t Nothing ~ [] : Optional tJdhall 9OptionalFold ~ Optional/foldKdhall :OptionalBuild ~ Optional/buildLdhall @Record [(k1, t1), (k2, t2)] ~ { k1 : t1, k2 : t1 }Mdhall @RecordLit [(k1, v1), (k2, v2)] ~ { k1 = v1, k2 = v2 }Ndhall AUnion [(k1, t1), (k2, t2)] ~ < k1 : t1 | k2 : t2 >Odhall IUnionLit k v [(k1, t1), (k2, t2)] ~ < k = v | k1 : t1 | k2 : t2 >Pdhall 1Combine x y ~ x "' yQdhall 1CombineTypes x y ~ x *S yRdhall 1CombineRight x y ~ x * ySdhall oMerge x y (Just t ) ~ merge x y : t Merge x y Nothing ~ merge x yTdhall :Constructors e ~ constructors eUdhall /Field e x ~ e.xVdhall 4Project e xs ~ e.{ xs }Wdhall -Note s x ~ eXdhall 3ImportAlt ~ e1 ? e2Ydhall 2Embed import ~ import[dhallType synonym for \&, provided for backwards compatibility\dhall!Reference to an external resource`dhallA g= extended with an optional hash for semantic integrity checksddhallGHow to interpret the import's contents (i.e. as Dhall code or raw text)gdhall:The type of import (i.e. local vs. remote vs. environment)hdhall Local pathidhall?URL of remote resource and optional headers stored in an importjdhallEnvironment variablemdhall Absolute pathndhallPath relative to .odhallPath relative to ~pdhallA p is a r@ followed by one additional path component representing the s nametdhall[Internal representation of a directory that stores the path components in reverse orderIn other words, the directory  /foo/bar/baz is encoded as 2Directory { components = [ "baz", "bar", "foo" ] }ydhallyk 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 y x by 13 in order to avoid being misinterpreted as the x8 bound by the innermost lambda. If we perform that y 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.zdhall;Substitute all occurrences of a variable with an expression subst x C B ~ B[x := C]{dhall7-normalize an expression by renaming all variables to "_"4 and using De Bruijn indices to distinguish them|dhallBReduce an expression to its normal form, performing beta reduction| 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, |g will not fail if the expression is ill-typed and will leave ill-typed sub-expressions unevaluated.dhall6This 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 fold}dhall Remove all W constructors from an   (i.e. de-W)~dhallkReduce an expression to its normal form, performing beta reduction and applying any custom definitions.~& is designed to be used with function typeWith. The typeWithV function allows typing of Dhall functions in a custom typing context whereas ~9 allows evaluating Dhall expressions in a custom context.To be more precise ~i 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.dhallReturns > if two expressions are -equivalent and -equivalent and  otherwisedhallTCheck if an expression is in a normal form given a context of evaluation. Unlike @, this will fully normalize and traverse through the expression.!It is much more efficient to use .dhall0Quickly check if an expression is in normal formdhall@Detect if the given variable is free within the given expression"x" `freeIn` "x"True"x" `freeIn` "y"False%"x" `freeIn` Lam "x" (Const Type) "x"FalsedhallUtility function used to throw internal errors that should never happen (in theory) but that are not enforced by the type systemdhall6The set of reserved identifiers for the Dhall languagedhall-Generates a syntactically valid Dhall programr "84);NU>L !#$%&'(*+,-./01235679:<=?@ABCDEFGHIJKMOPQRSTVWXY Zwx[\]^_`abcdefgjhiklmonpqrstuvyz{|}~rwxtuvpqrslmon\]^_`abcdefgjhik[ Z "84);NU>L !#$%&'(*+,-./01235679:<=?@ABCDEFGHIJKMOPQRSTVWXY{|~zy}None"#[r      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUNone"#Vdhall 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,WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~VNone"#EdhallA parsing errordhall'Parser for a top-level Dhall expressiondhallParser for a top-level Dhall expression. The expression is parameterized over any parseable type, allowing the language to be extended as needed.dhallParse an expression from  containing a Dhall programdhallLike 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 whitespacedhallUUser-friendly name describing the input expression, used in parsing error messagesdhallInput expression to parsedhallUUser-friendly name describing the input expression, used in parsing error messagesdhallInput expression to parse  None&dhallfAnnotation type used to tag elements in a pretty-printed document for syntax highlighting purposesdhall Escape a % literal using Dhall's escaping rules8Note that the result does not include surrounding quotesdhallPretty-print a valuedhallPretty print an expressiondhallUsed for syntactic keywordsdhall:Syntax punctuation such as commas, parenthesis, and bracesdhall Record labelsdhall%Literals such as integers and stringsdhallBuiltin types and valuesdhall OperatorsdhallUConvert annotations to their corresponding color for syntax highlighting purposesdhallZInternal 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 elementdhallPretty-print a listdhall%Pretty-print union types and literalsdhall&Pretty-print record types and literalsdhall3Pretty-print anonymous functions and function typesdhallcFormat an expression that holds a variable number of elements, such as a list, record, or uniondhallmFormat an expression that holds a variable number of elements without a trailing document such as nested `let`, nested lambdas, or nested sdhall Escape a ; literal using Dhall's escaping rules for single-quoted Textdhall-Beginning document for compact representationdhall0Beginning document for multi-line representationdhall$Separator for compact representationdhall'Separator for multi-line representationdhall*Ending document for compact representationdhall-Ending document for multi-line representationdhall-Elements to format, each of which is a pair: (compact, multi-line)dhall-Beginning document for compact representationdhall0Beginning document for multi-line representationdhall$Separator for compact representationdhall'Separator for multi-line representationdhall-Elements to format, each of which is a pair: (compact, multi-line)*None  NoneNone"#dhall@Render the difference between the normal form of two expressionsdhall-Render the difference between two expressionsNone"#1QV5\ dhalloNewtype used to wrap error messages so that they render with a more detailed explanation of what went wrongdhall-A structured type error that includes contextdhall6Default succinct 1-line explanation of what went wrongdhall1Longer and more detailed explanation of the errordhallThe specific type errordhallLike %, except with a shorter inferred typedhall+Function that converts the value inside an Y& constructor into a new expressiondhallzType-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 | it afterwards. The supplied h records the types of the names in scope. If these are ill-typed, the return value may be ill-typed.dhallGeneralization of  that allows type-checking the Y" constructor with custom logicdhall 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.dhallcThis 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     None7((NoneE)dhallWrapper around  HttpExceptions with a prettier  instance.8In order to keep the library API constant even when the  with-httpP Cabal flag is disabled the pretty error message is pre-rendered and the real  HttpExcepion is stored in a dhallfThis 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 input function+dhall,State threaded throughout the import process-dhall Stack of \@s that we've imported along the way to get to the current point.dhalllCache of imported expressions in order to avoid importing the same expression twice with different values/dhallCache for the HTTP Manager so that we only acquire it once0dhallDefault starting + )*+,/.-0None"#FG None "#$1QVqdhall.Exception thrown when an integrity check failsdhall .canonicalize (canonicalize x) = canonicalize xdhallNException thrown when a HTTP url is imported but dhall was built without the  with-http Cabal flag.1dhallCList of Exceptions we encounter while resolving Import Alternatives3dhall8Exception thrown when an environment variable is missing6dhall1Exception thrown when an imported file is missing8dhall6Extend another exception with the current import stack:dhall)Imports resolved so far, in reverse order;dhallThe nested exception<dhallDhall 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-local>dhallThe offending opaque import?dhall7An import failed because of a cycle in the import graphAdhallThe offending cyclic importBdhallParse an expression from a \ containing a Dhall programCdhallLResolve all imports within an expression using a custom typing context and \!-resolving callback in arbitrary  monad.DdhallGResolve all imports within an expression using a custom typing context. *load = loadWithContext Dhall.Context.emptydhallEThis loads a "static" expression (i.e. an expression free of imports)Edhall(Resolve all imports within an expressionFdhall Hash a fully resolved expressionGdhalliConvenience 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 importZdhall3canonicalize (Directory {components = ["..",".."]})$Directory {components = ["..",".."]})*+,-./0123456789:;<=>?@ABCDEFGBECDFG+,-./0?@A<=>89:;)*6734512 Noner9]^^] Noner__None"#0367;<=KQSTV>*`dhallThe `+ applicative functor allows you to build a r 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 r Project=, but we can't build that out of any smaller parsers, as r$s cannot be combined (they are only s). However, we can use a ` to build a r for Project: project :: Type Project project = record ( Project <$> field "name" string <*> field "description" string <*> field "stars" natural )bdhall-This is the underlying class that powers the pH class's support for automatically deriving a generic implementationddhallThis class is used by p 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 valuefdhallAn  (InputType a)- represents a way to marshal a value of type 'a' from Haskell into Dhallhdhall,Embeds a Haskell value as a Dhall expressionidhallDhall type of the Haskell valuejdhall-This is the underlying class that powers the pH class's support for automatically deriving a generic implementationldhallMUse these options to tweak how Dhall derives a generic implementation of pndhall\Function used to transform Haskell field names into their corresponding Dhall field namesodhallhFunction used to transform Haskell constructor names into their corresponding Dhall alternative namespdhallAny value that implements pG can be automatically decoded based on the inferred return type of x-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.rdhallA (Type a)- represents a way to marshal a value of type 'a' from Dhall into HaskellYou can produce rs either explicitly: 3example :: Type (Vector Text) example = vector text... or implicitly using : ,example :: Type (Vector Text) example = autoYou can consume r s using the x function: input :: Type a -> Text -> IO atdhall0Extracts Haskell value from the Dhall expressionudhallDhall type of the Haskell valuevdhallEvery rI must obey the contract that if an expression's type matches the the u type then the tB function must succeed. If not, then this exception is thrown)This exception indicates that an invalid r was provided to the x functionxdhallIType-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 BoolTruezdhallExtend x8 with a custom typing context and normalization process.{dhallExtend y8 with a custom typing context and normalization process.|dhall Similar to x%, but without interpreting the Dhall   into a Haskell type.}dhallExtend |8 with a custom typing context and normalization process.~dhallUse 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 ~ easier to use.For other use cases, use x from Dhall; module. It will give you a much better user experience.dhall0Use 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:1dhall Decode a input bool "True"Truedhall Decode a input natural "42"42dhall Decode an input integer "+42"42dhall Decode a input scientific "1e1000000000"1.0e1000000000dhall Decode a input double "42.0"42.0dhall Decode lazy input lazyText "\"Test\"""Test"dhallDecode strict input strictText "\"Test\"""Test"dhall Decode a .input (maybe natural) "[1] : Optional Natural"Just 1dhall Decode a = - >>> input (sequence natural) "[1, 2, 3]" fromList [1,2,3]dhall Decode a list input (list natural) "[1, 2, 3]"[1,2,3]dhall Decode a "input (vector natural) "[1, 2, 3]"[1,2,3]dhall!Decode `()` from an empty record.?input unit "{=}" -- GHC doesn't print the result if it is @()@dhall Decode a input string "\"ABC\"""ABC""dhallGiven a pair of r,s, decode a tuple-record into their pairing.3input (pair natural bool) "{ _1 = 42, _2 = False }" (42,False)dhall=Use the default options for interpreting a configuration file 'auto = autoWith defaultInterpretOptionsdhall# is the default implementation for  if you derive p&. The difference is that you can use - without having to explicitly provide an p5 instance for a type as long as the type derives dhallFDefault interpret options, which you can tweak or override, like this: \autoWith (defaultInterpretOptions { fieldModifier = Data.Text.Lazy.dropWhile (== '_') })dhall-Use the default options for injecting a value 'inject = inject defaultInterpretOptionsdhallRun a ` parser to build a r parser.dhall!Parse a single field of a record.xdhall1The type of value to decode from Dhall to HaskelldhallThe Dhall programdhallThe decoded value in HaskellydhallEThe source file to report locations from; only used in error messagesdhall1The type of value to decode from Dhall to HaskelldhallThe Dhall programdhallThe decoded value in Haskellzdhall1The type of value to decode from Dhall to Haskelldhall&The starting context for type-checkingdhallThe Dhall programdhallThe decoded value in Haskell{dhallEThe source file to report locations from; only used in error messagesdhall1The type of value to decode from Dhall to Haskelldhall&The starting context for type-checkingdhallThe Dhall programdhallThe decoded value in Haskell|dhallThe Dhall programdhallThe fully normalized AST}dhall&The starting context for type-checkingdhallThe Dhall programdhallThe fully normalized AST~dhall1The type of value to decode from Dhall to HaskelldhallAa closed form Dhall program, which evaluates to the expected typedhallThe decoded value in Haskell9`abcdefghijklmnopqrstuvwxyz{|}~9xyz{|}rstu`afghipqvwlmnojkbcde~None< NoneLdhallkThis fully resolves, type checks, and normalizes the expression, so the resulting AST is self-contained.None$<SafeNone"#8_ !"#$%&'()*+,-./012345567789:;<==43>?@ABCDEFGHI!JKLMNOPQRSTUVWXYZ$[\]^_`abcdefghijklmnopqrstuvwxyz{{|}~~      !"#$%&'()*+,--./0123456789:;<=> ?@@AABCDE F F G G H I I J J K L M M N O O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m nnopqrsstuvwxxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    CTX#dhall-1.15.0-E4TJA4qySDw9NZ2k9WpHqMDhall Dhall.Context Dhall.Core Dhall.Parser Dhall.Pretty Dhall.Format Dhall.DiffDhall.TypeCheck Dhall.Lint Dhall.Import Dhall.Freeze Dhall.HashDhall.TH Dhall.Repl Dhall.MainData.MapMapDhall.Parser.CombinatorsDhall.Parser.TokenDhall.Parser.Expression renderChunksDhall.Pretty.Internal Data.VoidVoidDhall.Import.TypesDhall.Import.HTTPDhall.Tutorial Paths_dhallbase GHC.GenericsGeneric GHC.NaturalNatural text-1.2.3.0Data.Text.InternalTextcontainers-0.5.11.0Data.Sequence.InternalSeq&vector-0.12.0.1-GC2xzdMF0QQGz7ZCcRBJRL Data.VectorVectorContextemptyinsertmatchlookuptoList$fFunctorContextExprVarConstParserunParserSrcAnn escapeTextpretty prettyExpr NormalizerChunksLamPiAppLetAnnotBoolBoolLitBoolAndBoolOrBoolEQBoolNEBoolIf NaturalLit NaturalFold NaturalBuild NaturalIsZero NaturalEven NaturalOddNaturalToInteger NaturalShow NaturalPlus NaturalTimesInteger IntegerLit IntegerShowIntegerToDoubleDouble DoubleLit DoubleShowTextLit TextAppendListListLit ListAppend ListBuildListFold ListLengthListHeadListLast ListIndexed ListReverseOptional OptionalLit OptionalFold OptionalBuildRecord RecordLitUnionUnionLitCombine CombineTypesPreferMerge ConstructorsFieldProjectNote ImportAltEmbedVPathImport importHashed importMode ImportHashedhash importType ImportModeCodeRawText ImportTypeLocalURLEnvMissing FilePrefixAbsoluteHereHomeFile directoryfile Directory componentsTypeKindshiftsubstalphaNormalize normalizedenote normalizeWithjudgmentallyEqualisNormalizedWith isNormalizedfreeIn internalErrorreservedIdentifiers $fPrettyConst$fPrettyDirectory$fSemigroupDirectory$fSemigroupFile $fPrettyFile$fPrettyFilePrefix$fPrettyImportHashed$fSemigroupImportHashed$fPrettyImportType$fSemigroupImportType$fPrettyImport$fSemigroupImport $fPrettyVar $fIsStringVar $fPrettyExpr$fIsStringChunks$fMonoidChunks$fSemigroupChunks$fIsStringExpr$fBifunctorExpr $fMonadExpr$fApplicativeExpr $fShowConst $fEqConst $fDataConst$fBoundedConst $fEnumConst $fEqDirectory$fOrdDirectory$fShowDirectory$fEqFile $fOrdFile $fShowFile$fEqFilePrefix$fOrdFilePrefix$fShowFilePrefix$fEqImportMode$fOrdImportMode$fShowImportMode$fEqImportHashed$fOrdImportHashed$fShowImportHashed$fEqImportType$fOrdImportType$fShowImportType $fEqImport $fOrdImport $fShowImport $fDataVar$fEqVar $fShowVar$fFunctorChunks$fFoldableChunks$fTraversableChunks $fShowChunks $fEqChunks $fDataChunks $fFunctorExpr$fFoldableExpr$fTraversableExpr $fShowExpr$fEqExpr $fDataExpr ParseErrorunwrapinputexprexprA exprFromTextexprAndHeaderFromText$fExceptionParseError$fShowParseErrorKeywordSyntaxLabelLiteralBuiltinOperatorannToAnsiStyleformatdiffNormalizeddiff$fIsStringDiff $fMonoidDiff$fSemigroupDiffDetailedTypeError TypeErrorcontextcurrent typeMessage TypeMessageUnboundVariableInvalidInputTypeInvalidOutputType NotAFunction TypeMismatch AnnotMismatchUntypedMissingListTypeMismatchedListElementsInvalidListElementInvalidListTypeInvalidOptionalElementInvalidOptionalTypeInvalidPredicateIfBranchMismatchIfBranchMustBeTerm InvalidFieldInvalidFieldTypeFieldAnnotationMismatch FieldMismatchInvalidAlternativeInvalidAlternativeTypeListAppendMismatchDuplicateAlternativeMustCombineARecordCombineTypesRequiresRecordTypeRecordTypeMismatchFieldCollisionMustMergeARecordMustMergeUnion UnusedHandlerMissingHandlerHandlerInputTypeMismatchHandlerOutputTypeMismatchInvalidHandlerOutputTypeMissingMergeTypeHandlerNotAFunctionConstructorsRequiresAUnionType NotARecord MissingFieldCantAndCantOrCantEQCantNECantInterpolateCantTextAppendCantListAppendCantAdd CantMultiplyNoDependentTypesXabsurdTypertypeWith typeWithAtypeOf checkContext $fPrettyX$fDataX$fEqX$fShowX$fPrettyTypeError$fExceptionTypeError$fShowTypeError$fPrettyDetailedTypeError$fExceptionDetailedTypeError$fShowDetailedTypeError$fShowTypeMessagelintPrettyHttpExceptionStatus_stack_cache_manager emptyStatusMissingImportsMissingEnvironmentVariablename MissingFileImported importStacknestedReferentiallyOpaque opaqueImportCycle cyclicImportexprFromImportloadWithloadWithContextloadhashExpressionhashExpressionToCode $fShowCycle$fExceptionCycle$fShowReferentiallyOpaque$fExceptionReferentiallyOpaque$fShowImported$fExceptionImported$fShowMissingFile$fExceptionMissingFile $fShowMissingEnvironmentVariable%$fExceptionMissingEnvironmentVariable$fShowMissingImports$fExceptionMissingImports$fShowCannotImportHTTPURL$fExceptionCannotImportHTTPURL$fCanonicalizeImport$fCanonicalizeImportHashed$fCanonicalizeImportType$fCanonicalizeFile$fCanonicalizeDirectory$fShowHashMismatch$fExceptionHashMismatch hashImportfreeze RecordType GenericInjectgenericInjectWithInject injectWith InputTypeembeddeclaredGenericInterpretgenericAutoWithInterpretOptions fieldModifierconstructorModifier InterpretautoWithextractexpected InvalidType inputFrom inputWith inputFromWith inputExpr inputExprWithrawInputdetailedboolnaturalinteger 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$fApplicativeRecordTypestaticDhallExpressionrepl parseOptionsparserInfoOptionscommandmain$fShowImportResolutionDisabled#$fExceptionImportResolutionDisabledGHC.Basefmap'megaparsec-6.5.0-4VKBtSFJhna3iLscGKIZAPText.MegaparsecParseccountrangeoptionstarplussatisfy noDuplicatestoMapghc-prim GHC.TypesInt boundedTypeTrueFalse whitespacealphadigithexdig doubleLiteralintegerLiteralnaturalLiteral identifierwhitespaceChunk hexNumber lineComment blockCommentblockCommentChunkblockCommentContinue simpleLabel backtickLabellabelslabelbashEnvironmentVariableposixEnvironmentVariable!posixEnvironmentVariableCharacter pathCharacter pathComponentfile_schemehttpRaw authorityuserinfohostport ipLiteral ipVFuture ipV6Addressh16ls32 ipV4AddressdecOctetregNamepcharqueryfragment pctEncoded subDelims unreservedreserved_if_then_else_let_in_as_using_merge _constructors _NaturalFold _NaturalBuild_NaturalIsZero _NaturalEven _NaturalOdd_NaturalToInteger _NaturalShow _IntegerShow_IntegerToDouble _DoubleShow _ListBuild _ListFold _ListLength _ListHead _ListLast _ListIndexed _ListReverse _OptionalFold_OptionalBuild_Bool _Optional_Natural_Integer_Double_Text_List_True_False_Type_Kind_equal_or_plus _textAppend _listAppend_and_times _doubleEqual _notEqual_dot _openBrace _closeBrace _openBracket _closeBracket _openAngle _closeAngle_bar_comma _openParens _closeParens_colon_at_missing _importAlt_combine _combineTypes_prefer_lambda_forall_arrownoted expressionannotatedExpressionemptyCollectionnonEmptyOptionaloperatorExpressionmakeOperatorExpressionimportAltExpression orExpressionplusExpressiontextAppendExpressionlistAppendExpression andExpressioncombineExpressionpreferExpressioncombineTypesExpressiontimesExpressionequalExpressionnotEqualExpressionapplicationExpressionimportExpressionselectorExpressionprimitiveExpressiondoubleQuotedChunkdoubleQuotedLiteralsingleQuoteContinuesingleQuoteLiteral textLiteralrecordTypeOrLiteralnonEmptyRecordTypeOrLiteralunionTypeOrLiteralnonEmptyUnionTypeOrLiteralnonEmptyListLiteralcompleteExpressionenvlocalRawlocalhttpmissing importType_ importHashed_import_dedent duplicateencloseenclose'anglesbracesarrowsforallescapeSingleQuotedText prettyConst prettyVarkeywordliteralbuiltinoperatorcommalbracketrbracketlangleranglelbracerbracelparenrparenpiperarrowcolonlambdaequalsdot prettyLabel prettyLabels prettyNumber prettyNaturalprettyScientificprettyToStringdocToStrictTextprettyToStrictTextshortlongGHC.ShowShow Data.DynamicDynamic InternalErrorstackcachemanagermkPrettyHttpExceptionrenderPrettyHttpException needManagerfetchFromHttpUrl HashMismatch CanonicalizeCannotImportHTTPURL(exceptions-0.10.0-DmsI5QMvE6e6QgVkMINEKbControl.Monad.Catch MonadCatchloadStaticWithFunctor integer-gmpGHC.Integer.Type)scientific-0.3.6.2-6iSmt8nz6tU2FDxmPZmwKNData.Scientific ScientificMaybeStringversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName