!Xg      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH I J K L M N 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 n o p q r s t u v w x y z { | } ~                    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Safe45EdhallA  (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 "#2456HVYdhallA - that remembers the original ordering of keys?This is primarily used so that formatting preserves field order0This is done primarily to avoid a dependency on insert-ordered-containers$ and also to improve performancedhall Create a  from a single key-value pairsingleton "A" 1fromList [("A",1)]dhall Create a  from a list of key-value pairs FfromList empty = mempty fromList (x <|> y) = fromList x <> fromList y6fromList [("B",1),("A",2)] -- The map preserves orderfromList [("B",1),("A",2)]KfromList [("A",1),("A",2)] -- For duplicates, later values take precedencefromList [("A",2)]dhallRemove duplicates from a listnubOrd [1,2,3][1,2,3]nubOrd [1,1,3][1,3]dhallSort the keys of a ", forgetting the original ordering sort (sort x) = sort x!sort (fromList [("B",1),("A",2)])fromList [("A",2),("B",1)]dhallCheck if the keys of a  are already sorted isSorted (sort m) = TrueJisSorted (fromList [("B",1),("A",2)]) -- Sortedness is based only on keysFalse%isSorted (fromList [("A",2),("B",1)])TruedhallInsert a key-value pair into a N, overriding any previous value stored underneath the same key, if present insert = insertWith (\v _ -> v)Iinsert "C" 1 (fromList [("B",2),("A",3)]) -- Values are inserted on left"fromList [("C",1),("B",2),("A",3)]Hinsert "C" 1 (fromList [("C",2),("A",3)]) -- New value takes precedencefromList [("C",1),("A",3)]dhallInsert a key-value pair into a q, using the supplied function to combine the new value with any old value underneath the same key, if presentBinsertWith (+) "C" 1 (fromList [("B",2),("A",3)]) -- No collision"fromList [("C",1),("B",2),("A",3)]?insertWith (+) "C" 1 (fromList [("C",2),("A",3)]) -- CollisionfromList [("C",3),("A",3)]dhallDelete a key from a + if present, otherwise return the original /delete "B" (fromList [("C",1),("B",2),("A",3)])fromList [("C",1),("A",3)]/delete "D" (fromList [("C",1),("B",2),("A",3)])"fromList [("C",1),("B",2),("A",3)]dhall0Keep all values that satisfy the given predicate0filter even (fromList [("C",3),("B",2),("A",1)])fromList [("B",2)]/filter odd (fromList [("C",3),("B",2),("A",1)])fromList [("C",3),("A",1)]dhallTransform all values in a K using the supplied function, deleting the key if the function returns ImapMaybe Data.Maybe.listToMaybe (fromList [("C",[1]),("B",[]),("A",[3])])fromList [("C",1),("A",3)]dhallRetrieve a key from a  Flookup k mempty = empty lookup k (x <> y) = lookup k y <|> lookup k x'lookup "A" (fromList [("B",1),("A",2)])Just 2'lookup "C" (fromList [("B",1),("A",2)])Nothingdhall%Retrieve the first key, value of the 5, if present, and also returning the rest of the . >uncons mempty = empty uncons (singleton k v) = (k, v, mempty)+uncons (fromList [("C",1),("B",2),("A",3)])'Just ("C",1,fromList [("B",2),("A",3)])uncons (fromList [])NothingdhallCheck if a key belongs to a  Emember k mempty = False member k (x <> y) = member k x || member k y'member "A" (fromList [("B",1),("A",2)])True'member "C" (fromList [("B",1),("A",2)])Falsedhall Combine two "s, preferring keys from the first  union = unionWith (\v _ -> v)?union (fromList [("D",1),("C",2)]) (fromList [("B",3),("A",4)])*fromList [("D",1),("C",2),("B",3),("A",4)]?union (fromList [("D",1),("C",2)]) (fromList [("C",3),("A",4)])"fromList [("D",1),("C",2),("A",4)] dhall Combine two /s using a combining function for colliding keysGunionWith (+) (fromList [("D",1),("C",2)]) (fromList [("B",3),("A",4)])*fromList [("D",1),("C",2),("B",3),("A",4)]GunionWith (+) (fromList [("D",1),("C",2)]) (fromList [("C",3),("A",4)])"fromList [("D",1),("C",5),("A",4)]!dhall Combine two < on their shared keys, keeping the value from the first  +intersection = intersectionWith (\v _ -> v)Fintersection (fromList [("C",1),("B",2)]) (fromList [("B",3),("A",4)])fromList [("B",2)]"dhall Combine two ds on their shared keys, using the supplied function to combine values from the first and second NintersectionWith (+) (fromList [("C",1),("B",2)]) (fromList [("B",3),("A",4)])fromList [("B",5)]#dhallCompute the difference of two .s by subtracting all keys from the second  from the first Ddifference (fromList [("C",1),("B",2)]) (fromList [("B",3),("A",4)])fromList [("C",1)]$dhall%Fold all of the key-value pairs in a , in their original order3foldMapWithKey (,) (fromList [("B",[1]),("A",[2])]) ("BA",[1,2])%dhallTransform the values of a  using their corresponding key TmapWithKey (pure id) = id mapWithKey (liftA2 (.) f g) = mapWithKey f . mapWithKey g VmapWithKey f mempty = mempty mapWithKey f (x <> y) = mapWithKey f x <> mapWithKey f y+mapWithKey (,) (fromList [("B",1),("A",2)])&fromList [("B",("B",1)),("A",("A",2))]&dhall)Traverse all of the key-value pairs in a , in their original order0traverseWithKey (,) (fromList [("B",1),("A",2)])!("BA",fromList [("B",1),("A",2)])'dhall)Traverse all of the key-value pairs in a S, in their original order where the result of the computation can be forgotten.DtraverseWithKey_ (\k v -> print (k, v)) (fromList [("B",1),("A",2)])("B",1)("A",2)(dhall(Travese all of the key-value pairs in a `, not preserving their original order, where the result of the computation can be forgotten.'Note that this is an optimisation over '> since we do not care in what order we traverse the pairs.)dhall Convert a ; to a list of key-value pairs in the original order of keys#toList (fromList [("B",1),("A",2)])[("B",1),("A",2)]*dhall Convert a  Dhall.Map. to a Data.Map.CtoMap (fromList [("B",1),("A",2)]) -- Order is lost upon conversionfromList [("A",2),("B",1)]+dhallReturn the keys from a  in their original order!keys (fromList [("B",1),("A",2)]) ["B","A"] !"#$%&'()*+ !"#%&'($)*+SafeW6dhall Identical to  Control.Lens.7dhall Identical to  Control.Lens.8dhall Identical to  Control.Lens.9dhall Identical to  Control.Lens.:dhall Identical to  Control.Lens.6789:6789:Safe277GdhallReturns, in order, all elements of the first Set not present in the second. (It doesn't matter in what order the elements appear in the second Set.) ?@ABCDEFG ?@CABDEFGNone277NdhallSource code extractNONONone "#24567DSXa-g dhall!Reference to an external resourcedhallSyntax tree for expressionsdhallLabel 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 axioms are: " Type : Kind " Kind : Sort!... and the valid rule pairs are: " Type ! Type : Type -- Functions from terms to terms (ordinary functions) " Kind ! Type : Type -- Functions from types to terms (type-polymorphic functions) " Sort ! Type : Type -- Functions from kinds to terms " Kind ! Kind : Kind -- Functions from types to types (type-level functions) " Sort ! Kind : Sort -- Functions from kinds to types (kind-polymorphic functions) " Sort ! Sort : Sort -- Functions from kinds to kinds (kind-level functions)zNote that Dhall does not support functions from terms to types and therefore Dhall is not a dependently typed languagedhall Remove all  constructors from an  (i.e. de-)Vdhall A reified YU, which can be stored in structures without running into impredicative polymorphism.Zdhall-Use this to wrap you embedded functions (see 0) to make them polymorphic enough to be used.[dhallThe body of an interpolated Text literalbdhall -Const c ~ ccdhall ]Var (V x 0) ~ x Var (V x n) ~ x@nddhall 9Lam x A b ~ (x : A) -> bedhall sPi "_" A B ~ A -> B Pi x A B ~ "(x : A) -> Bfdhall /App f a ~ f agdhall }Let [Binding x Nothing r] e ~ let x = r in e Let [Binding x (Just t) r] e ~ let x : t = r in ehdhall 1Annot x t ~ x : tidhall 0Bool ~ Booljdhall -BoolLit b ~ bkdhall 2BoolAnd x y ~ x && yldhall 2BoolOr x y ~ x || ymdhall 2BoolEQ x y ~ x == yndhall 2BoolNE x y ~ x != yodhall >BoolIf x y z ~ if x then y else zpdhall 3Natural ~ Naturalqdhall -NaturalLit n ~ nrdhall 8NaturalFold ~ Natural/foldsdhall 9NaturalBuild ~ Natural/buildtdhall :NaturalIsZero ~ Natural/isZeroudhall 8NaturalEven ~ Natural/evenvdhall 7NaturalOdd ~ Natural/oddwdhall =NaturalToInteger ~ Natural/toIntegerxdhall 8NaturalShow ~ Natural/showydhall 1NaturalPlus x y ~ x + yzdhall 1NaturalTimes x y ~ x * y{dhall 3Integer ~ Integer|dhall .IntegerLit n ~ n}dhall 8IntegerShow ~ Integer/show~dhall <IntegerToDouble ~ Integer/toDoubledhall 2Double ~ Doubledhall -DoubleLit n ~ ndhall 7DoubleShow ~ Double/showdhall 0Text ~ Textdhall >TextLit (Chunks [(t1, e1), (t2, e2)] t3) ~ "t1${e1}t2${e2}t3"dhall 2TextAppend x y ~ x ++ ydhall 5TextShow ~ Text/showdhall 0List ~ Listdhall tListLit (Just t ) [x, y, z] ~ [x, y, z] : List t ListLit Nothing [x, y, z] ~ [x, y, z]dhall 1ListAppend x y ~ x # ydhall 6ListBuild ~ List/builddhall 5ListFold ~ List/folddhall 7ListLength ~ List/lengthdhall 5ListHead ~ List/headdhall 5ListLast ~ List/lastdhall 8ListIndexed ~ List/indexeddhall 8ListReverse ~ List/reversedhall 4Optional ~ Optionaldhall yOptionalLit t (Just e) ~ [e] : Optional t OptionalLit t Nothing ~ [] : Optional tdhall 2Some e ~ Some edhall 0None ~ Nonedhall 9OptionalFold ~ Optional/folddhall :OptionalBuild ~ Optional/builddhall @Record [(k1, t1), (k2, t2)] ~ { k1 : t1, k2 : t1 }dhall @RecordLit [(k1, v1), (k2, v2)] ~ { k1 = v1, k2 = v2 }dhall ?Union [(k1, Just t1), (k2, Nothing)] ~ < k1 : t1 | k2 >dhall GUnionLit k v [(k1, Just t1), (k2, Nothing)] ~ < k = v | k1 : t1 | k2 >dhall 1Combine x y ~ x "' ydhall 1CombineTypes x y ~ x *S ydhall 1Prefer x y ~ x * ydhall oMerge x y (Just t ) ~ merge x y : t Merge x y Nothing ~ merge x ydhall /Field e x ~ e.xdhall 4Project e (Left xs) ~ e.{ xs }5| > Project e (Right t) ~ e.(t)dhall -Note s x ~ edhall 3ImportAlt ~ e1 ? e2dhall 2Embed import ~ importdhallA = extended with an optional hash for semantic integrity checksdhallGHow to interpret the import's contents (i.e. as Dhall code or raw text)dhall:The type of import (i.e. local vs. remote vs. environment)dhall Local pathdhall?URL of remote resource and optional headers stored in an importdhallEnvironment variabledhallEThe beginning of a file path which anchors subsequent path componentsdhall Absolute pathdhallPath relative to .dhallPath relative to ..dhallPath relative to ~dhallA  is a @ followed by one additional path component representing the  namedhall[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" ] }dhallk 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  x by 13 in order to avoid being misinterpreted as the x8 bound by the innermost lambda. If we perform that  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.dhall;Substitute all occurrences of a variable with an expression subst x C B ~ B[x := C]dhall=-normalize an expression by renaming all bound variables to "_"4 and using De Bruijn indices to distinguish them\alphaNormalize (Lam "a" (Const Type) (Lam "b" (Const Type) (Lam "x" "a" (Lam "y" "b" "x"))))oLam "_" (Const Type) (Lam "_" (Const Type) (Lam "_" (Var (V "_" 1)) (Lam "_" (Var (V "_" 1)) (Var (V "_" 1)))))/-normalization does not affect free variables:alphaNormalize "x" Var (V "x" 0)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 folddhallkReduce 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@A traversal over the immediate sub-expressions of an expression.dhall2A traversal over the immediate sub-expressions in [.dhallReturns  if the given / is valid within an unquoted path component&This is exported for reuse within the Dhall.Parser.Token moduledhall#Convenience utility for converting -based exceptions to -based exceptionsdhall-Generates a syntactically valid Dhall program ci{pbfdeghjklmnoqrstuvwxyz|}~<=VWXYZ[\]^a_`ۍ ]^a_`[\ci{pbfdeghjklmnoqrstuvwxyz|}~YZVWX=<None;dhallfAnnotation type used to tag elements in a pretty-printed document for syntax highlighting purposes<dhall Escape a % literal using Dhall's escaping rules8Note that the result does not include surrounding quotes=dhallPretty-print a value>dhallPretty print an expression?dhallUsed for syntactic keywords@dhall:Syntax punctuation such as commas, parenthesis, and bracesAdhall Record labelsBdhall%Literals such as integers and stringsCdhallBuiltin types and valuesDdhall OperatorsEdhallUConvert 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)/;BAD@?C<=><=>E     FNonewGdhallDefault layout options;BAD@?C><=>EFG;BAD@?CE><=>FGNone9@AHdhallA H! that is almost identical to Text.Megaparsec.9 except treating Haskell-style comments as whitespacedhallDoesn't force the  partHIJKL !"None"#>\#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None "#$X]dhall 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 None"#MdhallA parsing errorQdhall'Parser for a top-level Dhall expressionRdhallParser for a top-level Dhall expression. The expression is parameterized over any parseable type, allowing the language to be extended as needed.SdhallParse an expression from  containing a Dhall programTdhallLike Su 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 whitespaceSdhallUUser-friendly name describing the input expression, used in parsing error messagesdhallInput expression to parseTdhallUUser-friendly name describing the input expression, used in parsing error messagesdhallInput expression to parseNOHIJKLMNPOQRSTSTQRNOKLMNPOHIJ NoneuWdhall(Automatically improve a Dhall expressionCurrently this:removes unused let bindings with X.consolidates nested let bindings to use a multiple-let binding with Y.switches legacy List-like Optional literals to use Some / None instead with ZWXYZWXYZ None"#9{[dhallThe d subcommand can either \ its input or simply ]( that the input is already formatted^dhall5Modify file in-place if present, otherwise read from stdin and write to stdout_dhall9Read from the given file if present, otherwise read from stdin`dhallArguments to the d subcommandddhallImplementation of the  dhall format subcommand []\_^`abcd `abc[]\_^d None"#I idhall&Types that can be decoded from a CBOR kdhall$Types that can be encoded as a CBOR mdhallSupported version stringsndhallNo version stringodhallVersion "5.0.0"pdhallVersion "4.0.0"qdhallVersion "3.0.0"rdhallVersion "2.0.0"sdhallVersion "1.0.0"dhallcConvert a function applied to multiple arguments to the base function and the list of argumentswdhall$Encode a Dhall expression as a CBOR xdhall&Decode a Dhall expression from a CBOR ghijklmnopqrstuvwxmnopqrstuvklijwxgh"None %PSX_gdhallRename all binders to "_".dhall0Normalize an expression in an empty environment.dhall$Quote a value into beta-normal form.dhallNormalize an expression in an environment of values. Any variable pointing out of the environment is treated as opaque free variable.U None"#Jdhall@Render the difference between the normal form of two expressionsdhall-Render the difference between two expressions#None dhall>Utility function to cut out the interior of a large text blockdhallLike  , but for sNote that this has to be opinionated and render ANSI color codes, but that should be fine because we don't use this in a non-interactive contextdhall/Function to insert an aligned pretty expressiondhallPrefix used for error messagesNone"#2SX֎ 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 & 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 " 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 supplyGG&None"# 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 functiondhall,State threaded throughout the import processdhall Stack of  @s that we've imported along the way to get to the current pointdhall'Graph of all the imports visited so fardhall4Next node id to be used for the dot graph generationdhallCache of imported expressions with their node id in order to avoid importing the same expression twice with different valuesdhallCache for the HTTP Manager so that we only acquire it oncedhall.Expression with its immediate imports resolveddhallTNew import to use in place of the original import for chaining downstream importsdhallDefault starting ! that is polymorphic in the base    'None"#    None "#$29SXcdhall A call to  - failed because there was at least one importdhall.Exception thrown when an integrity check failsdhall *canonicalize . canonicalize = canonicalize 8canonicalize (a <> b) = canonicalize a <> canonicalize bdhallNException thrown when a HTTP url is imported but dhall was built without the  with-http Cabal flag.dhallCList of Exceptions we encounter while resolving Import Alternativesdhall8Exception thrown when an environment variable is missingdhall1Exception thrown when an imported file is missingdhall6Extend another exception with the current import stackdhall)Imports resolved so far, in reverse orderdhallThe nested exceptiondhallDhall 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-localdhallThe offending opaque importdhall7An import failed because of a cycle in the import graphdhallThe offending cyclic importdhallParse an expression from a   containing a Dhall programdhall$Save an expression to the specified  Currently this only works for cached imports and ignores other types of imports, but could conceivably work for uncached imports in the futureDThe main reason for this more general type is for symmetry with  and to support doing more clever things in the future, like doing "the right thing" for uncached imports (i.e. exporting environment variables or creating files)dhallDefault starting ,, importing relative to the given directory.dhallGeneralized version of ;You can configure the desired behavior through the initial  that you supplydhall(Resolve all imports within an expressiondhall Hash a fully resolved expressiondhalliConvenience 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 import dhall(Assert than an expression is import-freedhall3canonicalize (Directory {components = ["..",".."]})$Directory {components = ["..",".."]}dhall( means to encode without the version tag* * None!!dhallImplementation of the  dhall hash subcommand!!None"#1# "dhall5Specifies why we are adding semantic integrity checks#dhallsProtect imports with an integrity check without a fallback so that import resolution fails if the import changes$dhallProtect imports with an integrity check and also add a fallback import import without an integrity check. This is useful if you only want to cache imports when possible but still gracefully degrade to resolving them if the semantic integrity check has changed.%dhall!Specifies which imports to freeze&dhall&Freeze only remote imports (i.e. URLs)'dhall>Freeze all imports (including paths and environment variables)(dhall Retrieve an  1 and update the hash to match the latest contents)dhall)Freeze an import only if the import is a  import*dhallImplementation of the  dhall freeze subcommand(dhallCurrent working directory)dhallCurrent working directory*dhall5Modify file in-place if present, otherwise read from stdin and write to stdout "#$%&'()* *()%&'"#$None"#1478=>?MPSUVX`=+dhallThe +# monoid allows you to build an 7 injector for a Dhall record.8For example, let's take the following Haskell data type::{data Status = Queued Natural | Result Text | Errored Text:}WAnd assume that we have the following Dhall union that we would like to parse as a Status: E< Result = "Finish succesfully" | Queued : Natural | Errored : Text >Our injector has type 7 Status?, but we can't build that out of any smaller injectors, as 71s cannot be combined. However, we can use an + to build an 7 for Status::{ injectStatus :: InputType Status#injectStatus = adapt >$< inputUnion+ ( inputConstructorWith "Queued" inject+ >|< inputConstructorWith "Result" inject+ >|< inputConstructorWith "Errored" inject ) where adapt (Queued n) = Left n& adapt (Result t) = Right (Left t)' adapt (Errored e) = Right (Right e):}"Or, since we are simply using the 5/ instance to inject each branch, we could write:{ injectStatus :: InputType Status#injectStatus = adapt >$< inputUnion ( inputConstructor "Queued" >|< inputConstructor "Result" >|< inputConstructor "Errored" ) where adapt (Queued n) = Left n& adapt (Result t) = Right (Left t)' adapt (Errored e) = Right (Right e):}/dhallThe / monoid allows you to build a D parser from a Dhall union8For example, let's take the following Haskell data type::{data Status = Queued Natural | Result Text | Errored Text:}WAnd assume that we have the following Dhall union that we would like to parse as a Status: E< Result = "Finish succesfully" | Queued : Natural | Errored : Text >Our parser has type D Status=, but we can't build that out of any smaller parsers, as D$s cannot be combined (they are only s). However, we can use a / to build a D for Status::{status :: Type Statusstatus = union2 ( ( Queued <$> constructor "Queued" natural )5 <> ( Result <$> constructor "Result" strictText )5 <> ( Errored <$> constructor "Errored" strictText ) ):}1dhallThe 1+ applicative functor allows you to build a D parser from a Dhall record.8For example, let's take the following Haskell data type::{data 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 D Project=, but we can't build that out of any smaller parsers, as D$s cannot be combined (they are only s). However, we can use a 1 to build a D for Project::{project :: Type Project project = record) ( Project <$> field "name" strictText0 <*> field "description" strictText' <*> field "stars" natural ):}3dhall-This is the underlying class that powers the BH class's support for automatically deriving a generic implementation5dhallThis class is used by B 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 value7dhallAn  (InputType a)- represents a way to marshal a value of type 'a' from Haskell into Dhall9dhall,Embeds a Haskell value as a Dhall expression:dhallDhall type of the Haskell value;dhall-This is the underlying class that powers the BH class's support for automatically deriving a generic implementation=dhallMUse these options to tweak how Dhall derives a generic implementation of B?dhall\Function used to transform Haskell field names into their corresponding Dhall field names@dhallhFunction used to transform Haskell constructor names into their corresponding Dhall alternative namesAdhallThis is only used by the Bz instance for functions in order to normalize the function input before marshaling the input into a Dhall expressionBdhallAny value that implements BG can be automatically decoded based on the inferred return type of V-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.DdhallA (Type a)- represents a way to marshal a value of type 'a' from Dhall into HaskellYou can produce Ds either explicitly: 3example :: Type (Vector Text) example = vector text... or implicitly using l: ,example :: Type (Vector Text) example = autoYou can consume D s using the V function: input :: Type a -> Text -> IO aFdhall0Extracts Haskell value from the Dhall expressionGdhallDhall type of the Haskell valueHdhallIdhallJdhallKdhallEvery DI must obey the contract that if an expression's type matches the the G type then the FB function must succeed. If not, then this exception is thrown)This exception indicates that an invalid D was provided to the V functionOdhall5Default input settings: resolves imports relative to .@ (the current working directory), report errors as coming from (input)(, and default evaluation settings from R.Pdhall4Access the directory to resolve imports relative to.QdhallAccess the name of the source to report locations from; this is only used in error messages, so it's okay if this is a best guess or something symbolic.RdhallkDefault evaluation settings: no extra entries in the initial context, and no special normalizer behaviour.SdhallBAccess the starting context used for evaluation and type-checking.TdhallAccess the custom normalizer.Udhall}Access the standard version (used primarily when encoding or decoding Dhall expressions to and from a binary representation)VdhallIType-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 lT to automatically select which type to decode based on the inferred return type:input auto "True" :: IO BoolTrueThis uses the settings from O.WdhallExtend V with a root directory to resolve imports relative to, a file to mention in errors as the source, a custom typing context, and a custom normalization process.XdhallNType-check and evaluate a Dhall program that is read from the file-system.This uses the settings from R.YdhallExtend XE with a custom typing context and a custom normalization process.Zdhall Similar to V%, but without interpreting the Dhall  into a Haskell type.Uses the settings from O.[dhallExtend Z with a root directory to resolve imports relative to, a file to mention in errors as the source, a custom typing context, and a custom 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 V 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:1^dhall Decode a input bool "True"True_dhall Decode a input natural "42"42`dhall Decode an input integer "+42"42adhall Decode a input scientific "1e100"1.0e100bdhall Decode a input double "42.0"42.0cdhall Decode lazy input lazyText "\"Test\"""Test"ddhallDecode strict input strictText "\"Test\"""Test"edhall Decode a input (maybe natural) "Some 1"Just 1fdhall Decode a $input (sequence natural) "[1, 2, 3]"fromList [1,2,3]gdhall Decode a list input (list natural) "[1, 2, 3]"[1,2,3]hdhall Decode a "input (vector natural) "[1, 2, 3]"[1,2,3]idhallDecode () from an empty record.=input unit "{=}" -- GHC doesn't print the result if it is ()jdhall Decode a input string "\"ABC\"""ABC"kdhallGiven a pair of D,s, decode a tuple-record into their pairing.3input (pair natural bool) "{ _1 = 42, _2 = False }" (42,False)ldhall=Use the default options for interpreting a configuration file 'auto = autoWith defaultInterpretOptionsmdhallm# is the default implementation for l if you derive B&. The difference is that you can use m- without having to explicitly provide an B5 instance for a type as long as the type derives ndhallFDefault interpret options, which you can tweak or override, like this: \autoWith (defaultInterpretOptions { fieldModifier = Data.Text.Lazy.dropWhile (== '_') })odhall-Use the default options for injecting a value 'inject = inject defaultInterpretOptionspdhallYUse the default options for injecting a value, whose structure is determined generically.&This can be used when you want to use 5= on types that you don't want to define orphan instances for.qdhallRun a 1 parser to build a D parser.rdhall!Parse a single field of a record.sdhallRun a / parser to build a D parser.tdhall%Parse a single constructor of a unionudhallThe -> divisible (contravariant) functor allows you to build an 7 injector for a Dhall record.8For example, let's take the following Haskell data type::{data 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 injector has type 7 Project?, but we can't build that out of any smaller injectors, as 7$s cannot be combined (they are only s). However, we can use an InputRecordType to build an 7 for Project::{ "injectProject :: InputType ProjectinjectProject = inputRecord, ( adapt >$< inputFieldWith "name" inject3 >*< inputFieldWith "description" inject- >*< inputFieldWith "stars" inject ) whereK adapt (Project{..}) = (projectName, (projectDescription, projectStars)):}"Or, since we are simply using the 5. instance to inject each field, we could write:{ "injectProject :: InputType ProjectinjectProject = inputRecord! ( adapt >$< inputField "name"( >*< inputField "description"" >*< inputField "stars" ) whereK adapt (Project{..}) = (projectName, (projectDescription, projectStars)):}Infix ydhall Combines two + values. See + for usage notes.Ideally, this matches (); however, this allows + to not need a  2 instance itself (since no instance is possible).Vdhall1The type of value to decode from Dhall to HaskelldhallThe Dhall programdhallThe decoded value in HaskellWdhall1The type of value to decode from Dhall to HaskelldhallThe Dhall programdhallThe decoded value in HaskellXdhall1The type of value to decode from Dhall to HaskelldhallThe path to the Dhall program.dhallThe decoded value in Haskell.Ydhall1The type of value to decode from Dhall to HaskelldhallThe path to the Dhall program.dhallThe decoded value in Haskell.ZdhallThe Dhall programdhallThe fully normalized AST[dhallThe 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 HaskellX+,-./0123456789:;<=>A?@BCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|XVWXYZ[PQSTUOJRIH]DEFG12/0789:BCKLMNlm=>A?@n^_`abcdefghijkqrst;<3456op-.vwx+,{|zy\uu5y5*NoneNone dhallkThis fully resolves, type checks, and normalizes the expression, so the resulting AST is self-contained.None"#$>dhallImplementation of the  dhall repl subcommand!dhall7Find the index for the current _active_ dhall save file"dhall6Find the name for the current _active_ dhall save file#dhall*Find the name for the next dhall save file+Safe?$%&'()*+None"#$9CdhallThe subcommands for the dhall executabledhallTop-level program optionsdhall, for the  typedhall- for the  typedhall!Run the command specified by the  typedhallEntry point for the dhall executable$$.,-.,/0123,456789:;<=>?@ABCDEFGHIJK>LMNO@PQRSTUVWXYZ[A\]^_`abcdefghijkllmnAIo=Vpqrstuvvwxyz{|}}~FE03C      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abccdee f f g h i j k l m n o p q r s t u v w w x y z { | } ~                                   &&&&&&&&&&&       !"#$%&'()*+,-./01233445566789:;;<=>?@@ABCDEFGHIJKKLMNOPQhRSTUVWXYZ[\]^_`abcdefghijklmRnopqrstuvwxyz{|}~wyv,,6,b     \ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs ! t u v w x y z { | } ~           """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""%"""""""###>#,,&&&_&&&&&&,&&&&&&&&&&&&'''''''''''',   , , ,4((++++++++c #dhall-1.24.0-BSu3VQgk2clCRg35zzojYZDhall Dhall.Context Dhall.Core Dhall.Map Dhall.Optics Dhall.Pretty Dhall.Set Dhall.Src Dhall.Parser Dhall.Lint Dhall.Format Dhall.Binary Dhall.DiffDhall.TypeCheck Dhall.Import Dhall.Hash Dhall.FreezeDhall.TH Dhall.Repl Dhall.MainData.MapMap Control.Lens rewriteOf transformOf rewriteMOf transformMOfmapMOfDhall.Pretty.InternalDhall.Parser.CombinatorsDhall.Parser.TokenDhall.Parser.Expression renderChunks Dhall.Eval Dhall.Util Data.VoidVoidDhall.Import.TypesDhall.Import.HTTP$Data.Functor.Contravariant.DivisiblechosenDhall.Tutorial Paths_dhallbase GHC.GenericsGeneric GHC.NaturalNatural text-1.2.3.1Data.Text.InternalTextData.Functor.Contravariant>$<containers-0.6.0.1Data.Sequence.InternalSeq&vector-0.12.0.3-9DBmbAxwjsI3C7OopRSK19 Data.VectorVectorContextemptyinsertmatchlookuptoList$fFunctorContextImportExprVarConstdenote singletonfromListsortisSorted insertWithdeletefiltermapMaybeunconsmemberunion unionWith intersectionintersectionWith differencefoldMapWithKey mapWithKeytraverseWithKeytraverseWithKey_unorderedTraverseWithKey_toMapkeys $fIsListMap $fShowMap $fMonoidMap$fSemigroupMap$fTraversableMap $fFoldableMap $fFunctorMap$fOrdMap$fEqMap $fDataMapAnn escapeTextpretty prettyExprSettoSettoSeqappend $fFoldableSet$fEqSet $fGenericSet$fOrdSet $fShowSet $fDataSetSrc $fPrettySrc $fDataSrc$fEqSrc $fGenericSrc$fOrdSrc $fShowSrcReifiedNormalizergetReifiedNormalizer Normalizer NormalizerMChunksBindingvariable annotationvalueLamPiAppLetAnnotBoolBoolLitBoolAndBoolOrBoolEQBoolNEBoolIf NaturalLit NaturalFold NaturalBuild NaturalIsZero NaturalEven NaturalOddNaturalToInteger NaturalShow NaturalPlus NaturalTimesInteger IntegerLit IntegerShowIntegerToDoubleDouble DoubleLit DoubleShowTextLit TextAppendTextShowListListLit ListAppend ListBuildListFold ListLengthListHeadListLast ListIndexed ListReverseOptional OptionalLitSomeNone OptionalFold OptionalBuildRecord RecordLitUnionUnionLitCombine CombineTypesPreferMergeFieldProjectNote ImportAltEmbedV importHashed importMode ImportHashedhash importType ImportModeCodeRawText ImportTypeLocalRemoteEnvMissingURLscheme authoritypathqueryheadersSchemeHTTPHTTPS FilePrefixAbsoluteHereParentHomeFile directoryfile Directory componentsTypeKindSortshiftsubstalphaNormalize normalize normalizeWithnormalizeWithMjudgmentallyEqualisNormalizedWith isNormalizedfreeIn internalErrorreservedIdentifierssubExpressions chunkExprs pathCharacterthrows $fPrettyConst$fPrettyDirectory$fSemigroupDirectory$fSemigroupFile $fPrettyFile$fPrettyFilePrefix $fPrettyVar $fIsStringVar $fPrettyExpr$fIsStringChunks$fMonoidChunks$fSemigroupChunks$fBifunctorBinding$fIsStringExpr$fBifunctorExpr $fMonadExpr$fApplicativeExpr $fFunctorExpr$fPrettyImport$fSemigroupImport$fPrettyImportHashed$fSemigroupImportHashed$fPrettyImportType$fSemigroupImportType $fPrettyURL $fShowConst $fEqConst $fOrdConst $fDataConst$fBoundedConst $fEnumConst$fGenericConst $fEqDirectory$fGenericDirectory$fOrdDirectory$fShowDirectory$fEqFile $fGenericFile $fOrdFile $fShowFile$fEqFilePrefix$fGenericFilePrefix$fOrdFilePrefix$fShowFilePrefix $fEqScheme$fGenericScheme $fOrdScheme $fShowScheme$fEqImportMode$fGenericImportMode$fOrdImportMode$fShowImportMode $fDataVar $fGenericVar$fEqVar$fOrdVar $fShowVar$fFunctorChunks$fFoldableChunks$fGenericChunks$fTraversableChunks $fShowChunks $fEqChunks $fOrdChunks $fDataChunks$fEqExpr $fOrdExpr$fFoldableExpr $fGenericExpr$fTraversableExpr $fShowExpr $fDataExpr$fFunctorBinding$fFoldableBinding$fGenericBinding$fTraversableBinding $fShowBinding $fEqBinding $fOrdBinding $fDataBinding$fEqURL $fGenericURL$fOrdURL $fShowURL $fEqImport$fGenericImport $fOrdImport $fShowImport$fEqImportHashed$fGenericImportHashed$fOrdImportHashed$fShowImportHashed$fEqImportType$fGenericImportType$fOrdImportType$fShowImportType CharacterSetASCIIUnicodeKeywordSyntaxLabelLiteralBuiltinOperatorannToAnsiStyleprettyCharacterSet layoutOptsParserunParserSourcedException ParseErrorunwrapinputexprexprA exprFromTextexprAndHeaderFromText$fExceptionParseError$fShowParseErrorlintremoveLetInLetremoveUnusedBindingsoptionalLitToSomeNone FormatModeModifyCheckinplaceFormat characterSet formatModeformat$fShowNotFormatted$fExceptionNotFormattedDecodingFailureCBORIsNotDhallFromTermdecodeToTermencodeStandardVersion NoVersionV_5_0_0V_4_0_0V_3_0_0V_2_0_0V_1_0_0defaultStandardVersionparseStandardVersionrenderStandardVersionencodeExpressiondecodeExpression$fToTermImport $fToTermExpr$fFromTermImport$fFromTermExpr$fShowDecodingFailure$fExceptionDecodingFailure$fEnumStandardVersion$fBoundedStandardVersion$fEqDecodingFailureDiffsamedocdiffNormalizeddiffdiffExpression$fIsStringDiff $fMonoidDiff$fSemigroupDiffDetailedTypeError TypeErrorcontextcurrent typeMessage TypeMessageUnboundVariableInvalidInputTypeInvalidOutputType NotAFunction TypeMismatch AnnotMismatchUntypedMissingListTypeMismatchedListElementsInvalidListElementInvalidListTypeInvalidOptionalElementInvalidOptionalType InvalidSomeInvalidPredicateIfBranchMismatchIfBranchMustBeTerm InvalidFieldInvalidFieldTypeFieldAnnotationMismatch FieldMismatchInvalidAlternativeInvalidAlternativeTypeAlternativeAnnotationMismatchListAppendMismatchDuplicateAlternativeMustCombineARecordRecordMismatchCombineTypesRequiresRecordTypeRecordTypeMismatchFieldCollisionMustMergeARecordMustMergeUnion UnusedHandlerMissingHandlerHandlerInputTypeMismatchHandlerOutputTypeMismatchInvalidHandlerOutputTypeMissingMergeTypeHandlerNotAFunctionConstructorsRequiresAUnionType CantAccess CantProjectCantProjectByExpression MissingFieldCantAndCantOrCantEQCantNECantInterpolateCantTextAppendCantListAppendCantAdd CantMultiplyNoDependentTypesXabsurdTypertypeWith typeWithAtypeOf checkContext $fToTermX $fFromTermX $fPrettyX$fDataX$fEqX$fShowX$fPrettyTypeError$fExceptionTypeError$fShowTypeError$fPrettyDetailedTypeError$fExceptionDetailedTypeError$fShowDetailedTypeError$fShowTypeMessagePrettyHttpExceptionStatusstackcachemanagerstandardVersion normalizerstartingContextresolvercacherImportResolutionDisabled HashMismatch expectedHash actualHashMissingImportsMissingEnvironmentVariablename MissingFileImported importStacknestedReferentiallyOpaque opaqueImportCycle cyclicImportexprFromImport exprToImport emptyStatusloadWithloadhashExpressionhashExpressionToCodeassertNoImports $fShowCycle$fExceptionCycle$fShowReferentiallyOpaque$fExceptionReferentiallyOpaque$fShowImported$fExceptionImported$fShowMissingFile$fExceptionMissingFile $fShowMissingEnvironmentVariable%$fExceptionMissingEnvironmentVariable$fShowMissingImports$fExceptionMissingImports$fShowCannotImportHTTPURL$fExceptionCannotImportHTTPURL$fCanonicalizeImport$fCanonicalizeImportHashed$fCanonicalizeImportType$fCanonicalizeFile$fCanonicalizeDirectory$fShowHashMismatch$fExceptionHashMismatch$fShowImportResolutionDisabled#$fExceptionImportResolutionDisabledIntentSecureCacheScopeOnlyRemoteImports AllImports freezeImportfreezeRemoteImportfreezeUnionInputTypeRecordInputType UnionType RecordType GenericInjectgenericInjectWithInject injectWith InputTypeembeddeclaredGenericInterpretgenericAutoWithInterpretOptions fieldModifierconstructorModifierinputNormalizer InterpretautoWithextractexpectedHasEvaluateSettingsEvaluateSettings InputSettings InvalidTypeinvalidTypeExpectedinvalidTypeExpressiondefaultInputSettings rootDirectory sourceNamedefaultEvaluateSettingsinputWithSettings inputFileinputFileWithSettings inputExprinputExprWithSettingsrawInputdetailedboolnaturalinteger scientificdoublelazyText strictTextmaybesequencelistvectorunitstringpairauto genericAutodefaultInterpretOptionsinject genericInjectrecordfield constructor>*<inputFieldWith inputField inputRecord>|< inputUnioninputConstructorWithinputConstructor$fExceptionInvalidType$fShowInvalidType%$fHasEvaluateSettingsEvaluateSettings"$fHasEvaluateSettingsInputSettings$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$fInjectWord64$fInjectWord32$fInjectWord16 $fInjectWord8 $fInjectInt$fInjectInteger$fInjectNatural $fInjectText $fInjectText0 $fInjectBool $fInterpret->$fMonoidUnionType$fSemigroupUnionType$fDivisibleRecordInputType$fContravariantRecordInputType $fFunctorType$fFunctorRecordType$fApplicativeRecordType$fFunctorUnionType$fContravariantUnionInputTypestaticDhallExpressionreplModeDefaultVersionResolve NormalizeReplFreezeHashLintEncodeDecodeannotatealpha resolveModeall_expr1expr2jsonOptionsmodeexplainplainascii parseOptionsparserInfoOptionscommandmainGHC.BasefmapnubOrd GHC.MaybeNothingData.Map.Internalghc-prim GHC.TypesInt boundedTypeTrueFalseChar Data.EitherEitherIO duplicateencloseenclose'anglesbracesarrowsforallescapeSingleQuotedText prettyConst prettyVarkeywordlabelliteralbuiltinoperatorcommalbracketrbracketlangleranglelbracerbracelparenrparenpipecolonequalsdotlambdararrow prettyLabelprettyAnyLabel prettyLabels prettyNumber prettyNatural prettyDoubleprettyToStringdocToStrictTextprettyToStrictText'megaparsec-7.0.5-2OujkZ1S4CT7ueU3DJTkUVText.MegaparsecParseclaxSrcEqcountrangeoptionstarplussatisfy takeWhile takeWhile1 noDuplicates ComponentType URLComponent FileComponent whitespacehexdig doubleLiteraldoubleInfinityintegerLiteralnaturalLiteral identifier hexNumberlabelsanyLabelbashEnvironmentVariableposixEnvironmentVariablefile_httpRaw_if_then_else_let_in_as_using_merge _constructors_Some_None _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 _TextShow_List_True_False_NaN_Type_Kind_Sort_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_arrow getSourcePos getOffset setOffsetnoted shallowDenotecompleteExpressionenvlocalRawlocalhttpmissing importType_ importHashed_import_splitOn linesLiteralunlinesLiteral emptyLine leadingSpaces dropLiteraltoDoubleQuoted$cborg-0.2.1.0-16Pwfyh0wqlIA0DwVQ0H41Codec.CBOR.TermTermunApplynfEmptyquotenf convEmptyNamesNEmptyNBindValVHLamVConstVVarVPrimVarVAppVLamVPiVHPiVBoolVBoolLitVBoolAndVBoolOrVBoolEQVBoolNEVBoolIfVNatural VNaturalLit VNaturalFold VNaturalBuildVNaturalIsZero VNaturalEven VNaturalOddVNaturalToInteger VNaturalShow VNaturalPlus VNaturalTimesVInteger VIntegerLit VIntegerShowVIntegerToDoubleVDouble VDoubleLit VDoubleShowVTextVTextLit VTextAppend VTextShowVListVListLit VListAppend VListBuild VListFold VListLength VListHead VListLast VListIndexed VListReverse VOptionalVSomeVNone VOptionalFoldVOptionalBuildVRecord VRecordLitVUnion VUnionLitVCombine VCombineTypesVPreferVMergeVFieldVInjectVProjectVEmbedVChunksClosureClEmptySkipExtendinstevalconvsnipsnipDoc*prettyprinter-1.2.1-JPC8f5cJn5SAkoQXDSGO7Z"Data.Text.Prettyprint.Doc.InternalDoc_ERRORshortlongGHC.ShowShow Data.DynamicDynamic InternalError_stack _nextNodeId_cache_managerresolvedExpression newImportemptyStatusWithMonad_cacher _resolver_startingContext _normalizer_standardVersionResolved importNode nextNodeIdNotCORSCompliant actualOriginexpectedOriginsmkPrettyHttpExceptionrenderPrettyHttpException needManager corsCompliantrenderComponent renderQuery renderURLfetchFromHttpUrl CanonicalizeCannotImportHTTPURLFunctor)scientific-0.3.6.2-Fz4FF7y1I96CszaLXZ1UDqData.Scientific ScientificMaybeString Contravariant*contravariant-1.5.2-1ZQM8SswnWXJmdlHRX0Vigdivided DivisiblecurrentSaveFileIndexcurrentSaveFile nextSaveFileversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName4optparse-applicative-0.14.3.0-3EnnKmQgyld6fzz2tqYmBLOptions.Applicative.Types ParserInfo