!)C      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmn o p q r s t u v w x y z { | } ~             ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = >?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&Safe4AdhallA  (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 pairs dhallAdd 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  None7MDdhallA SHA256 digestdhallAttempt to interpret a  as a , returning  if the conversion failsdhallHash a  and return the hash as a NoneDNone "#245679HV)dhallA - 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 performancedhallCreate an empty dhall Create a  from a single key-value pairsingleton "A" 1fromList [("A",1)]dhall Create a  from a list of key-value pairs6fromList [("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)]1Note that this handling of duplicates means that  is not a monoid homomorphism:-fromList [(1, True)] <> fromList [(1, False)]fromList [(1,True)]&fromList ([(1, True)] <> [(1, False)])fromList [(1,False)]dhall Create a : from a list of key-value pairs with a combining function.NfromListWithKey (\k v1 v2 -> k ++ v1 ++ v2) [("B","v1"),("A","v2"),("B","v3")]#fromList [("B","Bv3v1"),("A","v2")]dhallRemove duplicates from a listnubOrd [1,2,3][1,2,3]nubOrd [1,1,3][1,3]dhall Create a  from a single key-value pair.IAny further operations on this map will not retain the order of the keys.unorderedSingleton "A" 1fromList [("A",1)]dhall Create a  from a list of key-value pairsIAny further operations on this map will not retain the order of the keys.unorderedFromList [] fromList []HunorderedFromList [("B",1),("A",2)] -- The map /doesn't/ preserve orderfromList [("A",2),("B",1)]TunorderedFromList [("A",1),("A",2)] -- For duplicates, later values take precedencefromList [("A",2)] 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)])True"dhallInsert 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)]&dhall Restrict a  to only those keys found in a Data.Set.Set.CrestrictKeys (fromList [("A",1),("B",2)]) (Data.Set.fromList ["A"])fromList [("A",1)]'dhallRemove all keys in a Data.Set.Set from a BwithoutKeys (fromList [("A",1),("B",2)]) (Data.Set.fromList ["A"])fromList [("B",2)](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)])Nothing*dhall%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 [])Nothing+dhallCheck 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)])False,dhallsize (fromList [("A",1)])1-dhall 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)]/dhallA generalised ..^outerJoin Left Left (\k a b -> Right (k, a, b)) (fromList [("A",1),("B",2)]) (singleton "A" 3)-fromList [("A",Right ("A",1,3)),("B",Left 2)]&This function is much inspired by the Data.Semialign.Semialign class.0dhall 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)]1dhall 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)]2dhallCompute 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)]3dhall%Fold all of the key-value pairs in a , in their original order3foldMapWithKey (,) (fromList [("B",[1]),("A",[2])]) ("BA",[1,2])4dhallTransform 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))]5dhall)Traverse all of the key-value pairs in a , in their original order0traverseWithKey (,) (fromList [("B",1),("A",2)])!("BA",fromList [("B",1),("A",2)])6dhallSame as 5[, except that the order of effects is not necessarily the same as the order of the keys7dhall)Traverse 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 a strict traversal, fully traversing the map even when the Applicative is lazy in the remaining elements.8dhall 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)]9dhall Convert a 8 to a list of key-value pairs in ascending order of keys: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"]<dhallReturn the values from a  in their original order."elems (fromList [("B",1),("A",2)])[1,2]=dhall Return the Data.Set.Set of the keys$keysSet (fromList [("B",1),("A",2)])fromList ["A","B"]Adhall'\x -> x <> mempty == (x :: Map Int Int)'\x -> mempty <> x == (x :: Map Int Int)Bdhall9\x y z -> x <> (y <> z) == (x <> y) <> (z :: Map Int Int)Fdhall7fromList [("A",1),("B",2)] < fromList [("B",1),("A",0)]True% !"#$%&'()*+,-./0123456789:;<=% !"#$%&'()+*,-./0124567389:;=<Safe>Odhall Identical to  Control.Lens. Pdhall Identical to  Control.Lens.!Qdhall Identical to  Control.Lens."Rdhall Identical to  Control.Lens.#Sdhall Identical to  Control.Lens.$OPQRSOPQRSNone279ϪTdhallThis is a variation on Data.Set.z that remembers the original order of elements. This ensures that ordering is not lost when formatting Dhall codeVdhallConvert to an unordered Data.Set.WdhallConvert to an ordered Xdhall Convert a T9 to a list, preserving the original order of the elementsYdhall Convert a T to a list of ascending elementsZdhallConvert a list to a T, remembering the element order[dhall Convert a Data.Set. to a sorted T\dhall"Append an element to the end of a T]dhall The empty T^dhallReturns, 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.)_dhall:Sort the set elements, forgetting their original ordering.)sort (fromList [2, 1]) == fromList [1, 2]True`dhallisSorted (fromList [2, 1])FalseisSorted (fromList [1, 2])Trueadhallnull (fromList [1])Falsenull (fromList [])Truebdhallsize (fromList [1])1TUVWXYZ[\]^_`abTUXYVWZ[\]^_`ab None279qdhallSource code extractqrstuqrstu%None"#1245679DSX_ukdhallSyntax tree for expressionsThe s< type parameter is used to track the presence or absence of q spans:If s = q then the code may contains q spans (either in a Noted> constructor or inline within another constructor, like )If s =  then the code has no q spansThe aC type parameter is used to track the presence or absence of importsIf a = ~& then the code may contain unresolved ~sIf a =  then the code has no ~sldhall 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 languagemdhallLabel for a bound variableThe k% 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 m6s and non-zero indices appear as a numeric suffix.~dhall!Reference to an external resourcedhallA = 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 variabledhall9This type stores all of the components of a remote importdhallThe URI schemedhallEThe 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" ] }dhall&This type represents 1 or more nested H bindings that have been coalesced together for ease of manipulationdhall -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 adhall }Let (Binding _ x _ Nothing _ r) e ~ let x = r in e Let (Binding _ x _ (Just t ) _ r) e ~ let x : t = r in eThe difference between let x = a let y = b in eand let x = a in let y = b in eis only an additional  around  "y" & in the second example.See O for a representation of let-blocks that mirrors the source code more closely.dhall 1Annot x t ~ x : tdhall 0Bool ~ Booldhall -BoolLit b ~ bdhall 2BoolAnd x y ~ x && ydhall 2BoolOr x y ~ x || ydhall 2BoolEQ x y ~ x == ydhall 2BoolNE x y ~ x != ydhall >BoolIf x y z ~ if x then y else zdhall 3Natural ~ Naturaldhall -NaturalLit n ~ ndhall 8NaturalFold ~ Natural/folddhall 9NaturalBuild ~ Natural/builddhall :NaturalIsZero ~ Natural/isZerodhall 8NaturalEven ~ Natural/evendhall 7NaturalOdd ~ Natural/odddhall =NaturalToInteger ~ Natural/toIntegerdhall 8NaturalShow ~ Natural/showdhall <NaturalSubtract ~ Natural/subtractdhall 1NaturalPlus x y ~ x + ydhall 1NaturalTimes x y ~ x * ydhall 3Integer ~ Integerdhall .IntegerLit n ~ ndhall;IntegerClamp ~ Integer/clampdhall<IntegerNegate ~ Integer/negatedhall 8IntegerShow ~ Integer/showdhall <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 hListLit (Just t ) [] ~ [] : t ListLit Nothing [x, y, z] ~ [x, y, z]@Invariant: A non-empty list literal is always represented as ListLit Nothing xs.LWhen an annotated, non-empty list literal is parsed, it is represented as 8Annot (ListLit Nothing [x, y, z]) t ~ [x, y, z] : tdhall 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 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 1Combine Nothing x y ~ x "' yThe first field is a  when the K operator is introduced as a result of desugaring duplicate record fields: ;RecordLit [ (k, Combine (Just k) x y) ] ~ { k = x, k = y }dhall 1CombineTypes x y ~ x *S ydhall 1Prefer x y ~ x * ydhall 0RecordCompletion x y ~ x::ydhall oMerge x y (Just t ) ~ merge x y : t Merge x y Nothing ~ merge x ydhall kToMap x (Just t) ~ toMap x : t ToMap x Nothing ~ toMap xdhall /Field e x ~ e.xdhall 4Project e (Left xs) ~ e.{ xs }5| > Project e (Right t) ~ e.(t)dhall 6Assert e ~ assert : edhall 1Equivalent x y ~ x "a ydhall -Note s x ~ edhall 3ImportAlt ~ e1 ? e2dhall 2Embed import ~ importdhallThe body of an interpolated Text literaldhallThis wrapper around  exists for its = instance which is defined via the binary encoding of Dhall Doubles.dhallRecord the binding part of a let expression.LFor example, > let x : Bool = True in x will be instantiated as follows: bindingSrc0 corresponds to the A comment.variable is "x" bindingSrc1 corresponds to the B comment. annotation is  a pair, corresponding to the C comment and Bool. bindingSrc2 corresponds to the D comment.value corresponds to True.dhall Construct a 3 with no source information and no type annotation.dhall Generate a  from the contents of a .In the resulting  bs e, e is guaranteed not to be a , but it might be a ( & ( &)).Given parser output,  consolidates let5s that formed a let-block in the original source.dhall Wrap let- s around an k.% can be understood as an inverse for : @let MultiLet bs e1 = multiLet b e0 wrapInLets bs e1 == Let b e0dhall@A traversal over the immediate sub-expressions of an expression.dhallTraverse over the immediate k children in a .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 Remove all  constructors from an k (i.e. de-)dhallThe "opposite" of , like  first absurd but fasterdhallRemove any outermost  constructors>This is typically used when you want to get the outermost non-+ constructor without removing internal  constructorsdhall6The set of reserved identifiers for the Dhall languagedhallSame as Data.Text.splitOn, except always returning a  resultdhallSplit  by linesdhallFlatten several  back into a single  by inserting newlinesdhallReturns  if the  represents a blank linedhall$Return the leading whitespace for a  literaldhallbCompute the longest shared whitespace prefix for the purposes of stripping leading indentationdhallDrop the first n characters for a  literaldhallConvert a single-quoted - literal to the equivalent double-quoted  literaldhallThis instance relies on the  instance for # but cannot satisfy the customary  laws when NaN is involved.dhall*This instance satisfies all the customary  laws except substitutivity.In particular:nan = DhallDouble (0/0) nan == nanTrueHThis instance is also consistent with with the binary encoding of Dhall Doubles:KtoBytes n = Dhall.Binary.encodeExpression (DoubleLit n :: Expr Void Import),\a b -> (a == b) == (toBytes a == toBytes b)dhall-Generates a syntactically valid Dhall programdhallNote that this  instance inherits  's defects.dhall^This instance encodes what the Dhall standard calls an "exact match" between two expressions. Note thatnan = DhallDouble (0/0)DoubleLit nan == DoubleLit nanTrueklm~&None"#S'None%1>PSX_gdhallSome information is lost when  converts a % or a built-in function from the k type to a  of the  type and B needs that information in order to reconstruct an equivalent k. This O type holds that extra information necessary to perform that reconstructiondhallDon't store any informationdhall>Store the original name and type of the variable bound by the dhallThe original function was a Natural/subtract 07. We need to preserve this information in case the Natural/subtract` ends up not being fully saturated, in which case we need to recover the unsaturated built-in dhallUtility that powers the  Text/show built-indhall$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.dhall For use with Text.Show.Functions.Z      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS TUVWXYS5(NoneSX dhall A reified  U, which can be stored in structures without running into impredicative polymorphism. dhallAn variation on  for pure normalizersdhall-Use this to wrap you embedded functions (see 0) to make them polymorphic enough to be used.dhallReturns > if two expressions are -equivalent and -equivalent and Z otherwise can fail with an [) if you compare ill-typed expressionsdhallk 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]\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 Zk then they will be lazy in their accumulator and only normalize the final result at the end of the folddhall=-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. can also fail with [- if you normalize an ill-typed expressiondhallkReduce 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. can fail with an [- if you normalize an ill-typed expressiondhallThis function generalizes ; by allowing the custom normalizer to use an arbitrary ] can fail with an [- if you normalize an ill-typed expressiondhallTCheck 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 . can fail with an [' if you check an ill-typed expressiondhall0Quickly check if an expression is in normal formGiven a well-typed expression e,  e is equivalent to e ==  e.Given an ill-typed expression, > may fail with an error, or evaluate to either False or True!dhall@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"False     NonedhallRSubstitutions map variables to arbitrary Dhall expressions. Note that we use  Dhall.Map.Map> as an underlying structure. Hence we respect insertion order.dhallAn empty substitution map.dhallsubstitute expr s replaces all variables in expri (or its subexpression) with their substitute. For example, if the substitution map maps the variable Foo& to the text "Foo" all occurrences of Foo with the text "Foo".XThe substitutions will be done in the order they are inserted into the substitution map: {-# LANGUAGE OverloadedStrings #-} substitute (Dhall.Core.Var "Foo") (Dhall.Map.fromList [("Foo", Dhall.Core.Var "Bar"), ("Bar", Dhall.Core.Var "Baz")]) results in Dhall.Core.Var "Baz"^ since we first substitute "Foo" with "Bar" and then the resulting "Bar" with the final "Baz". None"#=>?v dhall)This indicates that a given CBOR-encoded ^3 did not correspond to a valid Dhall expressiondhallSupported version stringsThis exists primarily for backwards compatibility for expressions encoded before Dhall removed version tags from the binary encodingdhallNo version string dhallVersion "5.0.0"!dhallVersion "4.0.0""dhallVersion "3.0.0"#dhallVersion "2.0.0"$dhallVersion "1.0.0"%dhall Render a  as k_dhallcConvert a function applied to multiple arguments to the base function and the list of arguments&dhall,Encode a Dhall expression as a CBOR-encoded ^'dhall&Decode a Dhall expression from a CBOR Term  !"#$%&'  !"#$%&')None"#_\jndhallfAnnotation type used to tag elements in a pretty-printed document for syntax highlighting purposesodhallPretty print an expression/dhall/This type determines whether to render code as 0 or 12dhallUsed for syntactic keywords3dhall:Syntax punctuation such as commas, parenthesis, and braces4dhall Record labels5dhall%Literals such as integers and strings6dhallBuiltin types and values7dhall Operators8dhallUConvert annotations to their corresponding color for syntax highlighting purposes`dhallZInternal utility for pretty-printing, used when generating element lists to supply to a or bz. This utility indicates that the compact represent is the same as the multi-line representation for each elementcdhallUsed to render inline q# spans preserved by the syntax treeflet unusedSourcePos = Text.Megaparsec.SourcePos "" (Text.Megaparsec.mkPos 1) (Text.Megaparsec.mkPos 1)Plet nonEmptySrc = Src unusedSourcePos unusedSourcePos "-- Documentation for x\n"?"let" <> " " <> renderSrc id (Just nonEmptySrc) <> "x = 1 in x"let -- Documentation for x x = 1 in x;let emptySrc = Src unusedSourcePos unusedSourcePos " "<"let" <> " " <> renderSrc id (Just emptySrc) <> "x = 1 in x"let x = 1 in x4"let" <> " " <> renderSrc id Nothing <> "x = 1 in x"let x = 1 in xddhallPretty-print a listedhall%Pretty-print union types and literalsfdhall&Pretty-print record types and literalsgdhall3Pretty-print anonymous functions and function typesadhallcFormat an expression that holds a variable number of elements, such as a list, record, or unionbdhallmFormat an expression that holds a variable number of elements without a trailing document such as nested `let`, nested lambdas, or nested hs9dhall/Escape a label if it is not valid when unquoted:dhallGEscape an environment variable if not a valid Bash environment variable;dhallPretty-print an k using the given /.; largely ignores s. 1s do however matter for the layout of let-blocks:klet inner = Let (Binding Nothing "x" Nothing Nothing Nothing (NaturalLit 1)) (Var (V "x" 0)) :: Expr Src ()aprettyCharacterSet ASCII (Let (Binding Nothing "y" Nothing Nothing Nothing (NaturalLit 2)) inner)let y = 2 let x = 1 in xprettyCharacterSet ASCII (Let (Binding Nothing "y" Nothing Nothing Nothing (NaturalLit 2)) (Note (Src unusedSourcePos unusedSourcePos "") inner))let y = 2 in let x = 1 in x;This means the structure of parsed let-blocks is preserved.idhallPrepare a for multi-line formatting by escaping problematic character sequences via string interpolations$multilineChunks (Chunks [] "\n \tx")-Chunks [("\n",TextLit (Chunks [] " \t"))] "x"*multilineChunks (Chunks [] "\n\NUL\b\f\t")3Chunks [("\n",TextLit (Chunks [] "\NUL\b\f"))] "\t"jdhall1Escape any leading whitespace shared by all linesGThis ensures that significant shared leading whitespace is not stripped1escapeSharedWhitespacePrefix (Chunks [] "\n \tx")-Chunks [("\n",TextLit (Chunks [] " \t"))] "x"@escapeSharedWhitespacePrefix (Chunks [("\n",Var (V "x" 0))] " ")!Chunks [("\n",Var (V "x" 0))] " "@escapeSharedWhitespacePrefix (Chunks [("\n ",Var (V "x" 0))] "")=Chunks [("\n",TextLit (Chunks [] " ")),("",Var (V "x" 0))] ""BescapeSharedWhitespacePrefix (Chunks [("\n ",Var (V "x" 0))] "\n")#Chunks [("\n ",Var (V "x" 0))] "\n",escapeSharedWhitespacePrefix (Chunks [] " ")(Chunks [("",TextLit (Chunks [] " "))] ""kdhallCEscape control characters by moving them into string interpolations2escapeControlCharacters (Chunks [] "\n\NUL\b\f\t")3Chunks [("\n",TextLit (Chunks [] "\NUL\b\f"))] "\t"ldhallSplit k= on a predicate, preserving all parts of the original string.splitOnPredicate (== 'x') ""([],"") splitOnPredicate (== 'x') " xx "([(" ","xx")]," ")splitOnPredicate (== 'x') "xx"([("","xx")],"")l\(Fun _ p) s -> let {t = Text.pack s; (as, b) = splitOnPredicate p t} in foldMap (uncurry (<>)) as <> b == tmdhallGEscape a trailing single quote by moving it into a string interpolation.Otherwise the multiline-string would end with '''', which would be parsed as an escaped ''.+escapeTrailingSingleQuote (Chunks [] "\n'")*Chunks [("\n",TextLit (Chunks [] "'"))] ""ndhallPretty-print a valueodhall Escape a k; literal using Dhall's escaping rules for single-quoted Textpdhall Escape a k% literal using Dhall's escaping rules8Note that the result does not include surrounding quotes<dhall Layout using =/Tries hard to fit the document into 80 columns.-This also removes trailing space characters (' ') unless% they are enclosed in an annotation.=dhallDefault layout optionscdhall@Used to preprocess the comment string (e.g. to strip whitespace)dhall"Source span to render (if present)adhall-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)bdhall-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)6n547326qors/018tuvwxyz{|}~h9:;np<= None]yn547326o/0189:;<=n5473268o/01;<=:9None"#a>dhallThis type is a  enriched with a @= flag to efficiently track if any difference was detectedBdhall@Render the difference between the normal form of two expressionsCdhall-Render the difference between two expressions>?@ABC>?@ABC*None9@AeGdhallA G! that is almost identical to Text.Megaparsec.9 except treating Haskell-style comments as whitespaceJdhallAn exception annotated with a q spandhallDoesn't force the  partGHIJKNone"#fLdhallThe j function uses this type to distinguish whether to parse a URL path component or a file path componentOdhallReturns  if the given  is a valid Unicode codepointPdhall:Parse 0 or more whitespace characters (including comments)This corresponds to the whsp rule in the official grammarQdhall:Parse 1 or more whitespace characters (including comments)This corresponds to the whsp1 rule in the official grammarRdhall*Parse a hex digit (uppercase or lowercase)This corresponds to the HEXDIG rule in the official grammarSdhallParse a k literalThis corresponds to the double-literal rule from the official grammarTdhallParse a signed InfinityThis corresponds to the minus-infinity-literal and plus-infinity-literal$ rules from the official grammarUdhall Parse an k literalThis corresponds to the integer-literal rule from the official grammarVdhallParse a k literal This corresponds to the natural-literal rule from the official grammarWdhall1Parse an identifier (i.e. a variable or built-in)GVariables can have an optional index to disambiguate shadowed variablesThis corresponds to the  identifier rule from the official grammarXdhall<Parse a hexademical number and convert to the corresponding Ydhall1Parse a braced sequence of comma-separated labels?For example, this is used to parse the record projection syntaxThis corresponds to the labels rule in the official grammarZdhall6Parse a label (e.g. a variable/field/alternative name)/Rejects labels that match built-in names (e.g.  Natural/even)This corresponds to the nonreserved-label rule in the official grammar[dhallSame as Z' except that built-in names are allowedThis corresponds to the  any-label rule in the official grammar\dhall,Parse a valid Bash environment variable nameThis corresponds to the bash-environment-variable! rule in the official grammar]dhallParse a valid POSIX environment variable name, which permits a wider range of characters than a Bash environment variable nameThis corresponds to the posix-environment-variable! rule in the official grammardhallParse a path component^dhallParse a _dhall0Parse an HTTP(S) URL without trailing whitespaceThis corresponds to the http-raw rule in the official grammar`dhallA variation on 6 that doesn't quote the expected in error messagesadhallA variation on < that doesn't quote the expected token in error messagesbdhall Parse the if keywordThis corresponds to the if rule from the official grammarcdhall Parse the then keywordThis corresponds to the then rule from the official grammarddhall Parse the else keywordThis corresponds to the else rule from the official grammaredhall Parse the let keywordThis corresponds to the let rule from the official grammarfdhall Parse the in keywordThis corresponds to the in rule from the official grammargdhall Parse the as keywordThis corresponds to the as rule from the official grammarhdhall Parse the using keywordThis corresponds to the using rule from the official grammaridhall Parse the merge keywordThis corresponds to the merge rule from the official grammarjdhall Parse the toMap keywordThis corresponds to the toMap rule from the official grammarkdhall Parse the assert keywordThis corresponds to the assert rule from the official grammarldhall Parse the Some built-inThis corresponds to the Some rule from the official grammarmdhall Parse the None built-inThis corresponds to the None rule from the official grammarndhall Parse the  Natural/fold built-inThis corresponds to the  Natural-fold rule from the official grammarodhall Parse the  Natural/build built-inThis corresponds to the  Natural-build rule from the official grammarpdhall Parse the Natural/isZero built-inThis corresponds to the Natural-isZero rule from the official grammarqdhall Parse the  Natural/even built-inThis corresponds to the  Natural-even rule from the official grammarrdhall Parse the  Natural/odd built-inThis corresponds to the  Natural-odd rule from the official grammarsdhall Parse the Natural/toInteger built-inThis corresponds to the Natural-toInteger rule from the official grammartdhall Parse the  Natural/show built-inThis corresponds to the  Natural-show rule from the official grammarudhall Parse the Natural/subtract built-inThis corresponds to the Natural-subtract rule from the official grammarvdhall Parse the  Integer/clamp built-inThis corresponds to the  Integer-clamp rule from the official grammarwdhall Parse the Integer/negate built-inThis corresponds to the Integer-negate rule from the official grammarxdhall Parse the  Integer/show built-inThis corresponds to the  Integer-show rule from the official grammarydhall Parse the Integer/toDouble built-inThis corresponds to the Integer-toDouble rule from the official grammarzdhall Parse the  Double/show built-inThis corresponds to the  Double-show rule from the official grammar{dhall Parse the  List/build built-inThis corresponds to the  List-build rule from the official grammar|dhall Parse the  List/fold built-inThis corresponds to the  List-fold rule from the official grammar}dhall Parse the  List/length built-inThis corresponds to the  List-length rule from the official grammar~dhall Parse the  List/head built-inThis corresponds to the  List-head rule from the official grammardhall Parse the  List/last built-inThis corresponds to the  List-last rule from the official grammardhall Parse the  List/indexed built-inThis corresponds to the  List-indexed rule from the official grammardhall Parse the  List/reverse built-inThis corresponds to the  List-reverse rule from the official grammardhall Parse the  Optional/fold built-inThis corresponds to the  Optional-fold rule from the official grammardhall Parse the Optional/build built-inThis corresponds to the Optional-build rule from the official grammardhall Parse the Bool built-inThis corresponds to the Bool rule from the official grammardhall Parse the Optional built-inThis corresponds to the Optional rule from the official grammardhall Parse the Natural built-inThis corresponds to the Natural rule from the official grammardhall Parse the Integer built-inThis corresponds to the Integer rule from the official grammardhall Parse the Double built-inThis corresponds to the Double rule from the official grammardhall Parse the Text built-inThis corresponds to the Text rule from the official grammardhall Parse the  Text/show built-inThis corresponds to the  Text-show rule from the official grammardhall Parse the List built-inThis corresponds to the List rule from the official grammardhall Parse the True built-inThis corresponds to the True rule from the official grammardhall Parse the False built-inThis corresponds to the False rule from the official grammardhallParse a NaN literalThis corresponds to the NaN rule from the official grammardhall Parse the Type built-inThis corresponds to the Type rule from the official grammardhall Parse the Kind built-inThis corresponds to the Kind rule from the official grammardhall Parse the Sort built-inThis corresponds to the Sort rule from the official grammardhall Parse the Location keywordThis corresponds to the Location rule from the official grammardhall Parse the = symboldhall Parse the || symboldhall Parse the + symboldhall Parse the ++ symboldhall Parse the # symboldhall Parse the && symboldhall Parse the * symboldhall Parse the == symboldhall Parse the != symboldhall Parse the . symboldhall Parse the { symboldhall Parse the } symboldhall Parse the [] symboldhall Parse the ] symboldhall Parse the < symboldhall Parse the > symboldhall Parse the | symboldhall Parse the , symboldhall Parse the ( symboldhall Parse the ) symboldhall Parse the : symboldhall Parse the @ symboldhallParse the equivalence symbol (=== or "a)dhall Parse the missing keyworddhall Parse the ? symboldhall#Parse the record combine operator (/\ or "')dhall(Parse the record type combine operator (//\\ or *S)dhall$Parse the record "prefer" operator (// or *)dhallParse a lambda (\ or )dhallParse a forall (forall or ")dhallParse a right arrow (-> or !)dhallParse a double colon (::)gLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~gOPQ\]LMN`a^Z[Y_RWXSTVUbcdefghijklmnopqrstuvwxyz{|}~None "#$X dhallVFor efficiency (and simplicity) we only expose two parsers from the result of the M function, since these are the only parsers needed outside of this moduledhallGet the current source positiondhall)Get the current source offset (in tokens)dhallSet the current source offsetdhallWrap a G2 to still match the same text but return only the q spandhallWrap a G= to still match the same text, but to wrap the resulting k in a  constructor containing the q spandhallBParse a complete expression (with leading and trailing whitespace)This corresponds to the complete-expression# rule from the official grammardhallParse an "import expression"This is not the same thing as  . This parses any expression of the same or higher precedence as an import expression (such as a selector expression). For example, this parses (1)This corresponds to the import-expression rule from the official grammardhallGiven a parser for imports, dhall$Parse an environment variable importThis corresponds to the env rule from the official grammardhall0Parse a local import without trailing whitespacedhallParse a local importThis corresponds to the local rule from the official grammardhallParse an HTTP(S) importThis corresponds to the http rule from the official grammardhallParse a  importThis corresponds to the missing rule from the official grammardhall Parse an This corresponds to the  import-type rule from the official grammardhallParse a This corresponds to the hash rule from the official grammardhall Parse an This corresponds to the  import-hashed rule from the official grammardhall Parse an ~This corresponds to the import rule from the official grammarNone"#SXdhallPretty-print a valuedhallUtility function used to throw internal errors that should never happen (in theory) but that are not enforced by the type systemdhall Escape a k% literal using Dhall's escaping rules8Note that the result does not include surrounding quotesdhallUtility used to implement the --censor flag, by:Replacing all q text with spacesReplacing all k( literals inside type errors with spacesdhallUtility used to censor k) by replacing all characters with a spacedhall#Convenience utility for converting -based exceptions to -based exceptionsklm~     ͤl~mk     None"#,dhallGA header corresponds to the leading comment at the top of a Dhall file._The header includes comment characters but is stripped of leading spaces and trailing newlinesdhallA 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.dhallAReplace the source code with spaces when rendering error messages&This utility is used to implement the --censor flagdhallParse an expression from k containing a Dhall programdhallBCreate a header with stripped leading spaces and trailing newlinesdhallLike 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 parseqrstuGHIJKqrstuJKGHINone "#$%<|dhall(Automatically improve a Dhall expressionCurrently this:removes unused let bindings with .fixes  let a = x "a y to be let a = assert : x "a yconsolidates nested let bindings to use a multiple-let binding with fixes paths of the form ./../foo to ../fooReplaces deprecated  Optional/fold and Optional/build built-insdhallRemove unused  bindings.dhallFix . bindings that the user probably meant to be assertsdhallThis transforms ./../foo into ../foodhallThe difference between let x = 1 let y = 2 in x + yand let x = 1 in let y = 2 in x + y,is that in the second expression, the inner  is wrapped by a .We remove such a > in order to consolidate nested let-blocks into a single one.dhallThis replaces  Optional/fold and Optional/build7, both of which can be implemented within the languagedhallThis replaces a saturated  Optional/fold with the equivalent merge expression+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 pointdhallYGraph of all the imports visited so far, represented by a list of import dependencies.dhallCache of imported expressions with their node id in order to avoid importing the same expression twice with different valuesdhallUsed to cache the  when making multiple requestsdhall:The remote resolver, fetches the content at the given URL.dhallYThis enables or disables the semantic cache for imports protected by integrity checksdhall imports (i.e. depends on) dhall(An import that has been fully interpeteddhall7The fully resolved import, typechecked and beta-normal.dhallA fully chainedL import, i.e. if it contains a relative path that path is relative to the current directory. If it is a remote import with headers those are well-typed (either of type `List { header : Text, value Text}` or `List { mapKey : Text, mapValue Text})` and in normal form. These invariants are preserved by the API exposed by  Dhall.Import.dhallThe underlying importdhallInitial W, parameterised over the remote resolver, importing relative to the given directory.dhall Lens from a  to its  fielddhall Lens from a  to its  fielddhall Lens from a  to its  fielddhall Lens from a  to its  fielddhall Lens from a  to its  fielddhall Lens from a  to its  fielddhall Lens from a  to its  field$ None"#opdhall>Utility function to cut out the interior of a large text blockdhallException thrown when the --check( flag to a command-line subcommand failsdhall)Some command-line subcommands can either  their input or k that the input has already been modified. This type is shared between them to record that choice. dhallPath to outputdhallJPath to input or raw input text, necessary since we can't read STDIN twice dhall Path to inputdhallSet to < if you want to censor error text that might include secretsdhallLike p , 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 messagesdhall#Convenience utility for converting -based exceptions to -based exceptionsdhall/Convenient utility for retrieving an expressiondhallEConvenient utility for retrieving an expression along with its headerdhallConvenient utility for retrieving an expression along with its header from | text already read from STDIN (so it's not re-read)p     p     None"#2SXdhalloNewtype used to wrap error messages so that they render with a more detailed explanation of what went wrongdhallGWrap a type error in this exception type to censor source code and k literals from the error messagedhall-A structured type error that includes context$dhall Output of n4, containing short- and long-form error messages&dhall6Default succinct 1-line explanation of what went wrong'dhall1Longer and more detailed explanation of the error(dhallThe specific type erroridhall+Function that converts the value inside an & constructor into a new expressionjdhallA type synonym for RThis is provided for backwards compatibility, since Dhall used to use its own j type instead of  Data.Void.. You should use  instead of j nowkdhallzType-check an expression and return the expression's type if type-checking succeeds or an error if type-checking failsk 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.ldhallGeneralization of k that allows type-checking the " constructor with custom logicdhalll' is implemented internally in terms of / in order to speed up equivalence checking.Specifically, we extend the  to become a 0, which can store the entire contents of a `let`q expression (i.e. the type *and* the value of the bound variable). By storing this extra information in the % we no longer need to substitute `let`3 expressions at all (which is very expensive!).(However, this means that we need to use ',0 to perform equivalence checking instead of  since only judgmentallyEqualg is unable to use the information stored in the extended context for accurate equivalence checking.mdhallm is the same as k with an empty context, meaning that the expression must be closed (i.e. no free variables), otherwise type-checking will fail.ndhall Convert a ( to short- and long-form $odhall Traversal that traverses every k in a (pdhallcThis function verifies that a custom context is well-formed so that type-checking will not loop Note that k already calls p for you on the  that you supplyX !"#$%&'(\/)*+-,.`abc687ghde3104f<59:;=>DCAE?@FGNOQPURTHIJMKLYZVW[X]^_2BSijklmnopXkmlpoij !"#(\/)*+-,.`abc687ghde3104f<59:;=>DCAE?@FGNOQPURTHIJMKLYZVW[X]^_2BSn$%&'None_ dhallFor example, for the line: let foo = "foo"# the tag is: > Tag "let " "foo"dhallIn vtags source code this field is named "pattern" and EMacs used it as a regex pattern to locate line with tag. It's looking for ^ tagpattern#. Looks like vi is not using it.dhallKtext, that editor compare with selected text. So it's really name of entitydhall3line number, starting from 1, where to find the tagdhall>byte offset from start of file. Not sure if any editor uses itdhall3line number, starting from 1, where to find the tagdhallcolumn of line where tag is{dhall$Generate etags for Dhall expressionsdhallFind tags in Text (second argument) and generates a list of them To make tags for filenames that works in both emacs and vi, add two initial tags. First for filename for vi and second with  /filename0 for emacs. Other tags are working for both.dhallqUsed to update tag position and to build tag from term. After getTagsFromExpr line and column in line are in  for each tag. And tagPattern is not added. Emacs use tag pattern to check if tag is on line. It compares line from start with tag pattern and in case they are the same, relocate user. fixPosAndDefinition change position to line and byte offset (9) and add tag pattern. For example, for Dhall string:8let dhallSource = "let foo = \"bar\"\nlet baz = \"qux\""Input for this function is:/foundTerms = [(LC 1 4, "foo"), (LC 2 4, "baz")]And:*fixPosAndDefinition dhallSource foundTerms[(LO {loLine = 1, loOffset = 5},Tag {tagPattern = "let foo ", tagName = "foo"}),(LO {loLine = 2, loOffset = 21},Tag {tagPattern = "let baz ", tagName = "baz"})](where 21 is byte offset from file start.dhall#Generate list of files for a given  {dhall7Where to look for files. This can be a directory name (.! for example), a file name or  . If  -, then this will wait for file names from STDIN+. This way someone can combine tools in bash& to send, for example, output from find to the input of  dhall tags.dhall>List of suffixes for dhall files or Nothing to check all filesdhallFlag if { should follow symlinksdhallContent for tags filedhallIf +, this function will follow symbolic linksdhallList of suffixes. If D, all files will be returned. This parameter only works when the   is an  and point to a directory.{{-None"#9None "#$29SXdhall A call to - failed because there was at least one importdhall.Exception thrown when an integrity check failsdhall *canonicalize . canonicalize = canonicalize Gcanonicalize (a <> b) = canonicalize (canonicalize a <> canonicalize b)dhallNException 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 importdhallConstruct the file path corresponding to a local import. If the import is _relative_ then the resulting path is also relative.dhallGiven a - import construct the corresponding unhashed M import (interpreting relative path as relative to the current directory).dhall*Adjust the import mode of a chained importdhallBChain imports, also typecheck and normalize headers if applicable.dhallZLoad an import, resulting in a fully resolved, type-checked and normalised expression.  loadImport handles the hot cache in Status and defers to  for imports that aren't in the Status cache already.dhall7Load an import from the 'semantic cache'. Defers to t for imports that aren't frozen (and therefore not cached semantically), as well as those that aren't cached yet.dhallwEnsure that the given expression is present in the semantic cache. The given expression should be alpha-beta-normal.dhallGiven a well-typed (of type `List { header : Text, value Text }` or `List { mapKey : Text, mapValue Text }`) headers expressions in normal form construct the corresponding binary http headers; otherwise return the empty list.dhall'Warn if no cache directory is availabledhallDefault 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 expressiondhallUResolve all imports within an expression, importing relative to the given directory.dhall 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 importdhall(Assert than an expression is import-freedhall3canonicalize (Directory {components = ["..",".."]})$Directory {components = ["..",".."]}dhall( means to encode without the version tagCCNone"#% dhall5Specifies why we are adding semantic integrity checksdhallsProtect imports with an integrity check without a fallback so that import resolution fails if the import changesdhallProtect 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 freezedhall&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 contentsdhall)Freeze an import only if the import is a  importdhallImplementation of the  dhall freeze subcommanddhallCurrent working directorydhallCurrent working directory  None"#9dhallArguments to the  subcommanddhallImplementation of the  dhall format subcommandNone"#)ydhallOThis error indicates that you supplied an invalid Dhall expression to the  directoryTreeR function. The Dhall expression could not be translated to a directory tree.dhall@Attempt to transform a Dhall record into a directory tree where:'Records are translated into directoriesText+ values or fields are translated into filesOptional values are omitted if None(For example, the following Dhall record: c{ dir = { `hello.txt` = "Hello\n" } , `goodbye.txt`= Some "Goodbye\n" , `missing.txt` = None Text },... should translate to this directory tree: $ tree result result %%% dir % %%% hello.txt %%% goodbye.txt $ cat result/dir/hello.txt Hello $ cat result/goodbye.txt GoodbyeUse this in conjunction with the Prelude's support for rendering JSON/YAML in "pure Dhall" so that you can generate files containing JSON. For example: slet JSON = https://prelude.dhall-lang.org/v12.0.0/JSON/package.dhall sha256:843783d29e60b558c2de431ce1206ce34bdfde375fcf06de8ec5bf77092fdef7 in { `example.json` = JSON.render (JSON.array [ JSON.number 1.0, JSON.bool True ]) , `example.yaml` = JSON.renderYAML (JSON.object (toMap { foo = JSON.string "Hello", bar = JSON.null })) }... which would generate: a$ cat result/example.json [ 1.0, true ] $ cat result/example.yaml ! "bar": null ! "foo": "Hello"qThis utility does not take care of type-checking and normalizing the provided expression. This will raise a = exception upon encountering an expression that is not a  or .None"#,-1478=>?HMPSUVX`jdhall allows you to build an  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: R< Result : Text | Queued : Natural | Errored : Text >.Result "Finish successfully"Our encoder has type  Status>, but we can't build that out of any smaller encoders, as 1s cannot be combined. However, we can use an  to build an  for Status::{ injectStatus :: Encoder Status%injectStatus = adapt >$< unionEncoder, ( encodeConstructorWith "Queued" inject, >|< encodeConstructorWith "Result" inject, >|< encodeConstructorWith "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 / instance to inject each branch, we could write:{ injectStatus :: Encoder Status%injectStatus = adapt >$< unionEncoder ( encodeConstructor "Queued" >|< encodeConstructor "Result"! >|< encodeConstructor "Errored" ) where adapt (Queued n) = Left n& adapt (Result t) = Right (Left t)' adapt (Errored e) = Right (Right e):}dhall&Intermediate type used for building a  instance for a recorddhallThe  monoid allows you to build a  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: R< Result : Text | Queued : Natural | Errored : Text >.Result "Finish successfully"Our decoder has type  Status>, but we can't build that out of any smaller decoders, as $s cannot be combined (they are only s). However, we can use a  to build a  for Status::{status :: Decoder Statusstatus = union2 ( ( Queued <$> constructor "Queued" natural )5 <> ( Result <$> constructor "Result" strictText )5 <> ( Errored <$> constructor "Errored" strictText ) ):}dhallThe + applicative functor allows you to build a  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 decoder has type  Project>, but we can't build that out of any smaller decoders, as $s cannot be combined (they are only s). However, we can use a  to build a  for Project::{project :: Decoder Project project = record) ( Project <$> field "name" strictText0 <*> field "description" strictText' <*> field "stars" natural ):}dhall-This is the underlying class that powers the H class's support for automatically deriving a generic implementationdhallA compatibility alias for  This will eventually be removed.dhallThis class is used by  instance for functions: 7instance (ToDhall a, FromDhall b) => FromDhall (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 Void)"Applying the Dhall function (i.e. f :: Expr Src Void!) 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 valuedhallAn  (Encoder a)- represents a way to marshal a value of type 'a' from Haskell into Dhalldhall,Embeds a Haskell value as a Dhall expressiondhallDhall type of the Haskell valuedhall-This is the underlying class that powers the H class's support for automatically deriving a generic implementationdhallPThis type specifies how to model a Haskell constructor with 1 field in Dhall@For example, consider the following Haskell datatype definition: /data Example = Foo { x :: Double } | Bar DoubleJDepending on which option you pick, the corresponding Dhall type could be: 9< Foo : Double | Bar : Double > -- Bare << Foo : { x : Double } | Bar : { _1 : Double } > -- Wrapped :< Foo : { x : Double } | Bar : Double > -- Smartdhall Never wrap the field in a recorddhall!Always wrap the field in a recorddhall)Only fields in a record if they are nameddhallMUse these options to tweak how Dhall derives a generic implementation of dhall\Function used to transform Haskell field names into their corresponding Dhall field namesdhallhFunction used to transform Haskell constructor names into their corresponding Dhall alternative namesdhallKSpecify how to handle constructors with only one field. The default is dhallThis is only used by the z instance for functions in order to normalize the function input before marshaling the input into a Dhall expressiondhall!This type is exactly the same as  except with a different ] instance. This intermediate type simplies the implementation of the inner loop for the  instance for dhallA compatibility alias for  This will eventually be removed.dhallAny value that implements G can be automatically decoded based on the inferred return type of -input auto "[1, 2, 3]" :: IO (Vector Natural)[1,2,3]@input auto "toMap { a = False, b = True }" :: IO (Map Text Bool)!fromList [("a",False),("b",True)]RThis class auto-generates a default implementation for records that implement C. This does not auto-generate an instance for recursive types.dhallA  (Decoder a)- represents a way to marshal a value of type 'a' from Dhall into HaskellYou can produce s either explicitly: 6example :: Decoder (Vector Text) example = vector text... or implicitly using 1: /example :: Decoder (Vector Text) example = autoYou can consume  s using the  function: "input :: Decoder a -> Text -> IO adhall0Extracts Haskell value from the Dhall expressiondhallDhall type of the Haskell valuedhalldhalldhalldhallEvery I must obey the contract that if an expression's type matches the the  type then the S function must not fail with a type error. If not, then this value is returned.%This value indicates that an invalid  was provided to the  functiondhallExtraction of a value can fail for two reasons, either a type mismatch (which should not happen, as expressions are type-checked against the expected type before being passed to extractC), or a term-level error, described with a freeform text value.dhallZOne or more errors returned from extracting a Dhall expression to a Haskell expressiondhall"Useful synonym for the equivalent * type used when marshalling Dhall codedhallUseful synonym for the 1 type used when marshalling Dhall expressionsdhall_Generate a type error during extraction by specifying the expected type and the actual typedhallTurn a k# message into an extraction failure dhallSwitches from an  Applicative5 extraction result, able to accumulate errors, to a Monad7 extraction result, able to chain sequential operations dhallSwitches from a Monad< extraction result, able to chain sequential errors, to an  Applicative- extraction result, able to accumulate errors dhall5Default input settings: resolves imports relative to .@ (the current working directory), report errors as coming from (input)(, and default evaluation settings from . dhall4Access the directory to resolve imports relative to. dhallAccess 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.dhallkDefault evaluation settings: no extra entries in the initial context, and no special normalizer behaviour.dhallBAccess the starting context used for evaluation and type-checking.dhall Access the custom substitutions.dhallAccess the custom normalizer.dhallIType-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 1T to automatically select which type to decode based on the inferred return type:input auto "True" :: IO BoolTrueThis uses the settings from  .dhallExtend  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.dhallNType-check and evaluate a Dhall program that is read from the file-system.This uses the settings from .dhallExtend E with a custom typing context and a custom normalization process.dhall Similar to %, but without interpreting the Dhall k into a Haskell type.Uses the settings from  .dhallExtend  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.dhall.Helper function for the input* function familydhallUse 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  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 kinput bool "True"Truedhall Decode a kinput natural "42"42dhall Decode an kinput integer "+42"42dhall Decode a input scientific "1e100"1.0e100dhall Decode a kinput double "42.0"42.0dhall Decode lazy kinput lazyText "\"Test\"""Test" dhallDecode strict kinput strictText "\"Test\"""Test"!dhall Decode a input (maybe natural) "Some 1"Just 1"dhall 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 a Dhall function into a Haskell function`f <- input (function defaultInterpretOptions inject bool) "Natural/even" :: IO (Natural -> Bool)f 0Truef 1False&dhall Decode a Set from a 1input (setIgnoringDuplicates natural) "[1, 2, 3]"fromList [1,2,3]Duplicate elements are ignored.1input (setIgnoringDuplicates natural) "[1, 1, 3]"fromList [1,3]'dhall Decode a HashSet from a 5input (hashSetIgnoringDuplicates natural) "[1, 2, 3]"fromList [1,2,3]Duplicate elements are ignored.5input (hashSetIgnoringDuplicates natural) "[1, 1, 3]"fromList [1,3](dhall Decode a Set from a  with distinct elements/input (setFromDistinctList natural) "[1, 2, 3]"fromList [1,2,3]3An error is thrown if the list contains duplicates. >>> input (setFromDistinctList natural) "[1, 1, 3]" *** Exception: Error: Failed extraction The expression type-checked successfully but the transformation to the target type failed with the following error: One duplicate element in the list: 1 >>> input (setFromDistinctList natural) "[1, 1, 3, 3]" *** Exception: Error: Failed extraction The expression type-checked successfully but the transformation to the target type failed with the following error: 2 duplicates were found in the list, including 1 )dhall Decode a HashSet from a  with distinct elements3input (hashSetFromDistinctList natural) "[1, 2, 3]"fromList [1,2,3]3An error is thrown if the list contains duplicates. >>> input (hashSetFromDistinctList natural) "[1, 1, 3]" *** Exception: Error: Failed extraction The expression type-checked successfully but the transformation to the target type failed with the following error: One duplicate element in the list: 1  >>> input (hashSetFromDistinctList natural) "[1, 1, 3, 3]" *** Exception: Error: Failed extraction The expression type-checked successfully but the transformation to the target type failed with the following error: 2 duplicates were found in the list, including 1 *dhall Decode a  from a toMap expression or generally a Prelude.Map.TypeAinput (Dhall.map strictText bool) "toMap { a = True, b = False }"!fromList [("a",True),("b",False)]Minput (Dhall.map strictText bool) "[ { mapKey = \"foo\", mapValue = True } ]"fromList [("foo",True)]If there are duplicate mapKey s, later mapValues take precedence:Rlet expr = "[ { mapKey = 1, mapValue = True }, { mapKey = 1, mapValue = False } ]"#input (Dhall.map natural bool) exprfromList [(1,False)]+dhall Decode a  from a toMap expression or generally a Prelude.Map.TypeEinput (Dhall.hashMap strictText bool) "toMap { a = True, b = False }"!fromList [("a",True),("b",False)]Qinput (Dhall.hashMap strictText bool) "[ { mapKey = \"foo\", mapValue = True } ]"fromList [("foo",True)]If there are duplicate mapKey s, later mapValues take precedence:Rlet expr = "[ { mapKey = 1, mapValue = True }, { mapKey = 1, mapValue = False } ]"'input (Dhall.hashMap natural bool) exprfromList [(1,False)],dhallDecode a tuple from a Prelude.Map.Entry recordPinput (pairFromMapEntry strictText natural) "{ mapKey = \"foo\", mapValue = 3 }" ("foo",3)-dhallDecode () from an empty record.=input unit "{=}" -- GHC doesn't print the result if it is ().dhallDecode  from an empty union.Since <> is uninhabited,  . will always fail./dhall Decode a input string "\"ABC\"""ABC"0dhallGiven a pair of ,s, decode a tuple-record into their pairing.3input (pair natural bool) "{ _1 = 42, _2 = False }" (42,False)1dhall=Use the default options for interpreting a configuration file 'auto = autoWith defaultInterpretOptions2dhall2# is the default implementation for 1 if you derive &. The difference is that you can use 2, without having to explicitly provide a 5 instance for a type as long as the type derives 3dhallFDefault interpret options, which you can tweak or override, like this: \autoWith (defaultInterpretOptions { fieldModifier = Data.Text.Lazy.dropWhile (== '_') })4dhall-Use the default options for injecting a value +inject = injectWith defaultInterpretOptions5dhallYUse the default options for injecting a value, whose structure is determined generically.&This can be used when you want to use = on types that you don't want to define orphan instances for.6dhallRun a  to build a .7dhall!Parse a single field of a record.8dhallRun a  to build a .9dhall%Parse a single constructor of a union:dhallThe > divisible (contravariant) functor allows you to build an  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 encoder has type  Project>, but we can't build that out of any smaller encoders, as $s cannot be combined (they are only s). However, we can use an  to build an  for Project::{ injectProject :: Encoder ProjectinjectProject = recordEncoder- ( adapt >$< encodeFieldWith "name" inject4 >*< encodeFieldWith "description" inject. >*< encodeFieldWith "stars" inject ) whereK adapt (Project{..}) = (projectName, (projectDescription, projectStars)):}"Or, since we are simply using the . instance to inject each field, we could write:{ injectProject :: Encoder ProjectinjectProject = recordEncoder" ( adapt >$< encodeField "name") >*< encodeField "description"# >*< encodeField "stars" ) whereK adapt (Project{..}) = (projectName, (projectDescription, projectStars)):}Infix ;dhallISpecify how to encode one field of a record by supplying an explicit  for that field<dhall>Specify how to encode one field of a record using the default  instance for that type=dhall Convert a  into the equivalent >dhall 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).?dhall Convert a  into the equivalent @dhall>Specify how to encode an alternative by providing an explicit  for that alternativeAdhall:Specify how to encode an alternative by using the default  instance for that typeWdhallKYou can use this instance to marshal recursive types from Dhall to Haskell.(Here is an example use of this instance: {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveFoldable #-} {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE DeriveTraversable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE QuasiQuotes #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TemplateHaskell #-} import Data.Fix (Fix(..)) import Data.Text (Text) import Dhall (FromDhall) import GHC.Generics (Generic) import Numeric.Natural (Natural) import qualified Data.Fix as Fix import qualified Data.Functor.Foldable as Foldable import qualified Data.Functor.Foldable.TH as TH import qualified Dhall import qualified NeatInterpolation data Expr = Lit Natural | Add Expr Expr | Mul Expr Expr deriving (Show) TH.makeBaseFunctor ''Expr deriving instance Generic (ExprF a) deriving instance FromDhall a => FromDhall (ExprF a) example :: Text example = [NeatInterpolation.text| \(Expr : Type) -> let ExprF = < LitF : Natural | AddF : { _1 : Expr, _2 : Expr } | MulF : { _1 : Expr, _2 : Expr } > in \(Fix : ExprF -> Expr) -> let Lit = \(x : Natural) -> Fix (ExprF.LitF x) let Add = \(x : Expr) -> \(y : Expr) -> Fix (ExprF.AddF { _1 = x, _2 = y }) let Mul = \(x : Expr) -> \(y : Expr) -> Fix (ExprF.MulF { _1 = x, _2 = y }) in Add (Mul (Lit 3) (Lit 7)) (Add (Lit 1) (Lit 2)) |] convert :: Fix ExprF -> Expr convert = Fix.cata Foldable.embed main :: IO () main = do x <- Dhall.input Dhall.auto example :: IO (Fix ExprF) print (convert x :: Expr)\dhallsNote that this instance will throw errors in the presence of duplicates in the list. To ignore duplicates, use '.]dhallsNote that this instance will throw errors in the presence of duplicates in the list. To ignore duplicates, use &.ydhallEmbed a 01 as a Prelude.Map.TypeCprettyExpr $ embed inject (HashMap.fromList [(1 :: Natural, True)])#[ { mapKey = 1, mapValue = True } ]GprettyExpr $ embed inject (HashMap.fromList [] :: HashMap Natural Bool)/[] : List { mapKey : Natural, mapValue : Bool }zdhallEmbed a 0 as a Prelude.Map.TypeDprettyExpr $ embed inject (Data.Map.fromList [(1 :: Natural, True)])#[ { mapKey = 1, mapValue = True } ]MprettyExpr $ embed inject (Data.Map.fromList [] :: Data.Map.Map Natural Bool)/[] : List { mapKey : Natural, mapValue : Bool }|dhall*Note that the ouput list may not be sorted3let x = Data.HashSet.fromList ["hi", "mom" :: Text]prettyExpr $ embed inject x[ "mom", "hi" ]}dhall'Note that the ouput list will be sorted/let x = Data.Set.fromList ["mom", "hi" :: Text]prettyExpr $ embed inject x[ "hi", "mom" ]dhallembed inject (12 :: Word64) NaturalLit 12dhallembed inject (12 :: Word32) NaturalLit 12dhallembed inject (12 :: Word16) NaturalLit 12dhallembed inject (12 :: Word8) NaturalLit 12dhallembed inject (12 :: Word) NaturalLit 12dhallThe decoder for the Dhall valuedhallThe Dhall programdhallThe decoded value in HaskelldhallThe decoder for the Dhall valuedhallThe Dhall programdhallThe decoded value in HaskelldhallThe decoder for the Dhall valuedhallThe path to the Dhall program.dhallThe decoded value in Haskell.dhallThe decoder for the Dhall valuedhallThe path to the Dhall program.dhallThe decoded value in Haskell.dhallThe Dhall programdhallThe fully normalized ASTdhallThe Dhall programdhallThe fully normalized ASTdhallThe Dhall programdhallThe fully normalized ASTdhallThe decoder for the Dhall valuedhallAa closed form Dhall program, which evaluates to the expected typedhallThe decoded value in Haskellq      !"#$%&'()*+,-./0123456789:;<=>?@Aq     123 !"#$%(&)'*+,-./0678945;<=@A?>::5>52NoneNone"#456& dhallUsed by ) to specify how to generate Haskell typesdhallOGenerate a Haskell type with more than one constructor from a Dhall union typedhall@Generate a Haskell type with one constructor from any Dhall typeTo generate a constructor with multiple named fields, supply a Dhall record type. This does not support more than one anonymous field.dhall"Name of the generated Haskell typedhall)Dhall code that evaluates to a union typedhallName of the constructordhalllThis fully resolves, type checks, and normalizes the expression, so the resulting AST is self-contained.This can be used to resolve all of an expression s imports at compile time, allowing one to reference Dhall expressions from Haskell without having a runtime dependency on the location of Dhall files.For example, given a file "./Some/Type.dhall" containing 0< This : Natural | Other : ../Other/Type.dhall >:... rather than duplicating the AST manually in a Haskell , you can do: Dhall.Type (\case UnionLit "This" _ _ -> ... UnionLit "Other" _ _ -> ...) $(staticDhallExpression "./Some/Type.dhall").This would create the Dhall Expr AST from the "./Some/Type.dhall" file at compile time with all imports resolved, making it easy to keep your Dhall configs and Haskell interpreters in sync.dhallConvert a Dhall type to a Haskell type that does not require any new data declarations beyond the data declarations supplied as the first argumentdhallFConvert a Dhall type to the corresponding Haskell datatype declarationdhall=Convert a Dhall type to the corresponding Haskell constructordhallGenerate a Haskell datatype declaration from a Dhall union type where each union alternative corresponds to a Haskell constructor*For example, this Template Haskell splice: @Dhall.TH.makeHaskellTypeFromUnion "T" "< A : { x : Bool } | B >" ... generates this Haskell code: $data T = A {x :: GHC.Types.Bool} | BThis is a special case of : ZmakeHaskellTypeFromUnion typeName code = makeHaskellTypes [ MultipleConstructors{..} ]dhallOGenerate a Haskell datatype declaration with one constructor from a Dhall typeThis comes in handy if you need to keep Dhall types and Haskell types in sync. You make the Dhall types the source of truth and use Template Haskell to generate the matching Haskell type declarations from the Dhall types.#For example, given this Dhall code: 9-- ./Department.dhall < Sales | Engineering | Marketing > D-- ./Employee.dhall { name : Text, department : ./Department.dhall }!... this Template Haskell splice: Dhall.TH.makeHaskellTypes [ MultipleConstructors "Department" "./tests/th/Department.dhall" , SingleConstructor "Employee" "MakeEmployee" "./tests/th/Employee.dhall" ] ... generates this Haskell code: data Department = Engineering | Marketing | Sales data Employee = MakeEmployee {department :: Department, name :: Data.Text.Internal.Text}gCarefully note that the conversion makes a best-effort attempt to auto-detect when a Dhall type (like ./Employee.dhall&) refers to another Dhall type (like ./Department.dhallC) and replaces that reference with the corresponding Haskell type.&To add any desired instances (such as /), you can use the StandaloneDeriving language extension, like this: {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-} Dhall.TH.makeHaskellTypes [ MultipleConstructors "Department" "./tests/th/Department.dhall" , SingleConstructor "Employee" "MakeEmployee" "./tests/th/Employee.dhall" ] deriving instance Generic Department deriving instance FromDhall Department deriving instance Generic Employee deriving instance FromDhall Employeedhall#All Dhall-derived data declarationseUsed to replace complex types with references to one of these data declarations when the types matchdhall4Dhall expression to convert to a simple Haskell typedhall (constructorName, fieldType)dhall"Name of the generated Haskell typedhall)Dhall code that evaluates to a union type  3Safe٬Safedhall The current Version of the Haskell implementationdhallThe current version  for the Haskell implementationNone"#$>dhallImplementation of the  dhall repl subcommanddhall7Find the index for the current _active_ dhall save filedhall6Find the name for the current _active_ dhall save filedhall*Find the name for the next dhall save fileNone"#$9_dhallThe 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//4564789:;4<=4>?@ABCDEFGHIJKLMMNOPQRSTUVGWXYZ[\]H^_`abcJdefghijklmnopqKrstuvwxyz{|}~ !"#$KrXGl\]f%%%))   %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%8%%%%%%%%%%%%%%%%%%%%%;%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % %%%%%%%%%%%%%%%%%%%%% %!%"%#%$%%'&('('((()(*(+(,(-(.(/(0(1(2(3(4 5 G 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)XYYZ[\]^_`*a*a*b*c*cdefghijklmnopqrstuvwxyz{|}~++++++++++++++++++++ + + + + ++++++               !  " H # $ % & ' ())*+*,,-./00123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()g*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Y;44@@4>4%4%%%%%%%%%%%%&&&'''''''''''''''''''''''''''''''''' ' ' ' ' ''''''''''''''''''' '!'"'#'$'%'&'''(')'*'+','-'.'/'0'1'2'3'4'5'6'7'8'9'9':';'<'='>'?','+'@'A'/'.B4CD(E4FG H)I)J)K)L))M)N)O)P)Q)R)S)T)U)V)W)X)Y)Z)[)\)])r)^)_)`)a)b)c)d)e)f)g)h)i)j)k)l)m)n)o)p)q)r)s)t)u)v)w)x)yz{|}~***********s*xy444+++++ +  -A44144<..33333333a#dhall-1.30.0-HX3KpQfOuj98TdnbjnZGDZDhallDhall.TypeCheck Dhall.Context Dhall.Crypto Dhall.Map Dhall.Optics Dhall.Set Dhall.Core Dhall.Pretty Dhall.Util Dhall.SrcDhall.Substitution Dhall.Binary Dhall.Diff Dhall.ParserDhall.Parser.TokenDhall.Parser.Expression Dhall.Lint Dhall.Import Dhall.Tags Dhall.Freeze Dhall.FormatDhall.DirectoryTreeDhall.TH Dhall.Version Dhall.Repl Dhall.MainData.MapMapDhall.Import.Manager Control.Lens rewriteOf transformOf rewriteMOf transformMOfmapMOf Dhall.Syntax Dhall.URL Dhall.EvalDhall.NormalizeDhall.Pretty.InternalDhall.Parser.CombinatorsDhall.Import.TypesconvDhall.Import.HTTP$Data.Functor.Contravariant.DivisiblechosenDataHashMapDhall.Tutorial Paths_dhallbase GHC.GenericsGeneric GHC.NaturalNatural text-1.2.3.1Data.Text.InternalTextData.Functor.Contravariant>$< Data.Voidabsurdcontainers-0.6.0.1Data.Sequence.InternalSeq&vector-0.12.1.2-FWeXzqARiSu45G657Sieqk Data.VectorVectorContextemptyinsertmatchlookuptoList$fFunctorContext SHA256DigestunSHA256Digestsha256DigestFromByteString sha256Hash$fShowSHA256Digest$fEqSHA256Digest$fGenericSHA256Digest$fOrdSHA256Digest$fNFDataSHA256Digest$fByteArrayAccessSHA256Digest singletonfromListfromListWithKeyunorderedSingletonunorderedFromListsortisSorted insertWithdeletefilter restrictKeys withoutKeysmapMaybeunconsmembersizeunion unionWith outerJoin intersectionintersectionWith differencefoldMapWithKey mapWithKeytraverseWithKeyunorderedTraverseWithKeyunorderedTraverseWithKey_ toAscListtoMapkeyselemskeysSet $fLiftKeys $fIsListMap $fShowMap $fMonoidMap$fSemigroupMap$fTraversableMap $fFoldableMap $fFunctorMap$fOrdMap$fEqMap $fLiftMap $fDataKeys $fGenericKeys $fNFDataKeys $fDataMap $fGenericMap $fNFDataMapSettoSettoSeqfromSetappendnull $fFoldableSet $fLiftSet$fOrdSet$fEqSet $fGenericSet $fShowSet $fDataSet $fNFDataSetExprConstVarAnn prettyExprsnipSrcsrcStartsrcEndsrcText $fPrettySrc $fLiftSrc $fDataSrc$fEqSrc $fGenericSrc$fOrdSrc $fShowSrc $fNFDataSrcImport importHashed importMode ImportHashedhash importType ImportModeCodeRawTextLocation ImportTypeLocalRemoteEnvMissingURLscheme authoritypathqueryheadersSchemeHTTPHTTPS FilePrefixAbsoluteHereParentHomeFile directoryfile Directory componentsMultiLetLamPiAppLetAnnotBoolBoolLitBoolAndBoolOrBoolEQBoolNEBoolIf NaturalLit NaturalFold NaturalBuild NaturalIsZero NaturalEven NaturalOddNaturalToInteger NaturalShowNaturalSubtract NaturalPlus NaturalTimesInteger IntegerLit IntegerClamp IntegerNegate IntegerShowIntegerToDoubleDouble DoubleLit DoubleShowTextLit TextAppendTextShowListListLit ListAppend ListBuildListFold ListLengthListHeadListLast ListIndexed ListReverseOptionalSomeNone OptionalFold OptionalBuildRecord RecordLitUnionCombine CombineTypesPreferRecordCompletionMergeToMapFieldProjectAssert EquivalentNote ImportAltEmbedChunks DhallDoublegetDhallDoubleBinding bindingSrc0variable bindingSrc1 annotation bindingSrc2valueVTypeKindSort makeBindingmultiLet wrapInLetssubExpressions bindingExprs chunkExprs pathCharacterdenoterenote shallowDenotereservedIdentifierstextShowReifiedNormalizergetReifiedNormalizer Normalizer NormalizerMjudgmentallyEqualshiftsubstalphaNormalize normalize normalizeWithnormalizeWithMisNormalizedWith isNormalizedfreeIn Substitutions substituteDecodingFailureCBORIsNotDhallStandardVersion NoVersionV_5_0_0V_4_0_0V_3_0_0V_2_0_0V_1_0_0renderStandardVersionencodeExpressiondecodeExpression$fSerialiseExpr$fSerialiseExpr0$fShowDecodingFailure$fExceptionDecodingFailure$fEnumStandardVersion$fBoundedStandardVersion$fEqDecodingFailure CharacterSetASCIIUnicodeKeywordSyntaxLabelLiteralBuiltinOperatorannToAnsiStyle escapeLabelescapeEnvironmentVariableprettyCharacterSetlayout layoutOptsDiffsamedocdiffNormalizeddiff$fIsStringDiff $fMonoidDiff$fSemigroupDiffParserunParserSourcedException ComponentType URLComponent FileComponentvalidCodepoint whitespacenonemptyWhitespacehexdig doubleLiteraldoubleInfinityintegerLiteralnaturalLiteral identifier hexNumberlabelslabelanyLabelbashEnvironmentVariableposixEnvironmentVariablefile_httpRawtextchar_if_then_else_let_in_as_using_merge_toMap_assert_Some_None _NaturalFold _NaturalBuild_NaturalIsZero _NaturalEven _NaturalOdd_NaturalToInteger _NaturalShow_NaturalSubtract _IntegerClamp_IntegerNegate _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 _Location_equal_or_plus _textAppend _listAppend_and_times _doubleEqual _notEqual_dot _openBrace _closeBrace _openBracket _closeBracket _openAngle _closeAngle_bar_comma _openParens _closeParens_colon_at _equivalent_missing _importAlt_combine _combineTypes_prefer_lambda_forall_arrow _doubleColonParserscompleteExpression_importExpression_ getSourcePos getOffset setOffsetsrcnotedcompleteExpressionimportExpressionparsersenv localOnlylocalhttpmissing importType_ importHash_ importHashed_import_pretty internalError escapeTextcensorExpression censorTextthrowsHeader ParseErrorunwrapinputexprexprAcensor exprFromText createHeaderexprAndHeaderFromText$fExceptionParseError$fShowParseError $fShowHeaderlintremoveUnusedBindings fixAssert fixParentPathremoveLetInLetreplaceOptionalBuildFoldreplaceSaturatedOptionalFoldPrettyHttpExceptionStatus_stack_graph_cache_manager_remote_substitutions _normalizer_startingContext_semanticCacheModeSemanticCacheModeIgnoreSemanticCacheUseSemanticCacheDependsparentchildImportSemanticsChained chainedImportstackgraphcacheremote substitutions normalizerstartingContext CheckFailedcommandmodified OutputModeWriteCheckOutputStandardOutput OutputFileInput StandardInput InputFileCensorNoCensorsnipDoc_ERROR getExpressiongetExpressionAndHeader#getExpressionAndHeaderFromStdinText$fShowCheckFailed$fExceptionCheckFailedDetailedTypeErrorCensoredCensoredDetailed TypeErrorcontextcurrent typeMessage ErrorMessagesshortlong TypeMessageUnboundVariableInvalidInputTypeInvalidOutputType NotAFunction TypeMismatch AnnotMismatchUntypedMissingListTypeMismatchedListElementsInvalidListElementInvalidListTypeListLitInvariant InvalidSomeInvalidPredicateIfBranchMismatchIfBranchMustBeTermInvalidFieldTypeInvalidAlternativeTypeAlternativeAnnotationMismatchListAppendMismatchMustCombineARecordInvalidDuplicateFieldInvalidRecordCompletionCompletionSchemaMustBeARecordCombineTypesRequiresRecordTypeRecordTypeMismatchDuplicateFieldCannotBeMergedFieldCollisionFieldTypeCollisionMustMergeARecordMustMergeUnionOrOptionalMustMapARecordInvalidToMapRecordKindHeterogenousRecordToMapInvalidToMapTypeMapTypeMismatchMissingToMapType UnusedHandlerMissingHandlerHandlerInputTypeMismatchDisallowedHandlerTypeHandlerOutputTypeMismatchInvalidHandlerOutputTypeMissingMergeTypeHandlerNotAFunction CantAccess CantProjectCantProjectByExpression MissingFieldMissingConstructorProjectionTypeMismatchAssertionFailedNotAnEquivalenceIncomparableExpressionEquivalenceTypeMismatchCantAndCantOrCantEQCantNECantInterpolateCantTextAppendCantListAppendCantAdd CantMultiplyTyperXtypeWith typeWithAtypeOfprettyTypeMessagemessageExpressions checkContext$fPrettyTypeError$fExceptionTypeError$fShowTypeError$fPrettyDetailedTypeError$fExceptionDetailedTypeError$fShowDetailedTypeError$fPrettyCensored$fExceptionCensored$fShowCensored$fShowTypeMessagegenerate $fMonoidTags$fSemigroupTags$fEqLineColumn$fOrdLineColumn$fShowLineColumn$fEqLineOffset$fOrdLineOffset$fShowLineOffset $fShowTagImportResolutionDisabled HashMismatch expectedHash actualHashMissingImportsMissingEnvironmentVariablename MissingFileImported importStacknestedReferentiallyOpaque opaqueImportCycle cyclicImport localToPathchainedFromLocalHerechainedChangeMode chainImportwriteExpressionToSemanticCache toHeaderswarnAboutMissingCaches emptyStatusloadWithloadloadRelativeTohashExpressionhashExpressionToCodeassertNoImports $fShowCycle$fExceptionCycle$fShowReferentiallyOpaque$fExceptionReferentiallyOpaque$fShowImported$fExceptionImported$fShowMissingFile$fExceptionMissingFile $fShowMissingEnvironmentVariable%$fExceptionMissingEnvironmentVariable$fShowMissingImports$fExceptionMissingImports$fShowCannotImportHTTPURL$fExceptionCannotImportHTTPURL$fCanonicalizeImport$fCanonicalizeImportHashed$fCanonicalizeImportType$fCanonicalizeFile$fCanonicalizeDirectory$fShowHashMismatch$fExceptionHashMismatch$fShowImportResolutionDisabled#$fExceptionImportResolutionDisabledIntentSecureCacheScopeOnlyRemoteImports AllImports freezeImportfreezeRemoteImportfreezeFormat characterSet outputModeformatFilesystemErrorunexpectedExpressiontoDirectoryTree$fExceptionFilesystemError$fShowFilesystemError UnionEncoder RecordEncoder UnionDecoder RecordDecoderGenericToDhallgenericToDhallWithInjectToDhall injectWithEncoderembeddeclaredGenericFromDhallgenericAutoWithSingletonConstructorsBareWrappedSmartInterpretOptions fieldModifierconstructorModifiersingletonConstructorsinputNormalizer Interpret FromDhallautoWithDecoderextractexpectedHasEvaluateSettingsEvaluateSettings InputSettingsInvalidDecoderinvalidDecoderExpectedinvalidDecoderExpression ExtractErrors getErrorsMonadicExtractor Extractor typeError extractError toMonadic fromMonadicdefaultInputSettings rootDirectory sourceNamedefaultEvaluateSettingsinputWithSettings inputFileinputFileWithSettings inputExprinputExprWithSettingsrawInputdetailedboolnaturalinteger scientificdoublelazyText strictTextmaybesequencelistvectorfunctionsetIgnoringDuplicateshashSetIgnoringDuplicatessetFromDistinctListhashSetFromDistinctListmaphashMappairFromMapEntryunitvoidstringpairauto genericAutodefaultInterpretOptionsinjectgenericToDhallrecordfield constructor>*<encodeFieldWith encodeField recordEncoder>|< unionEncoderencodeConstructorWithencodeConstructor$fShowInvalidDecoder$fExceptionInvalidDecoder$fExceptionExtractError$fShowExtractError$fExceptionExtractErrors$fShowExtractErrors%$fHasEvaluateSettingsEvaluateSettings"$fHasEvaluateSettingsInputSettings$fGenericFromDhallk:*:$fGenericFromDhallkU1$fGenericFromDhallkM1$fGenericFromDhallk:+:$fGenericFromDhallk:+:0$fGenericFromDhallk:+:1$fGenericFromDhallk:+:2$fGenericFromDhallkV1$fGenericFromDhallkM10$fGenericFromDhallkM11$fGenericFromDhallk:*:0$fGenericFromDhallk:*:1$fGenericFromDhallk:*:2$fFromDhallFix$fFromDhallResult$fFromDhall(,)$fFromDhallHashMap$fFromDhallMap$fFromDhallHashSet$fFromDhallSet$fFromDhallVector $fFromDhall[]$fFromDhallSeq$fFromDhallMaybe$fFromDhallText$fFromDhallText0$fFromDhall[]0$fFromDhallDouble$fFromDhallScientific$fFromDhallInteger$fFromDhallNatural$fFromDhallBool $fFromDhall()$fFromDhallVoid$fContravariantEncoder$fGenericToDhallkU1$fGenericToDhallk:*:$fGenericToDhallk:+:$fGenericToDhallk:+:0$fGenericToDhallk:+:1$fGenericToDhallk:+:2$fGenericToDhallkM1$fGenericToDhallkM10$fGenericToDhallk:*:0$fGenericToDhallk:*:1$fGenericToDhallk:*:2$fGenericToDhallkM11$fToDhallHashMap $fToDhallMap $fToDhall(,)$fToDhallHashSet $fToDhallSet$fToDhallVector $fToDhall[] $fToDhallSeq$fToDhallMaybe $fToDhall()$fToDhallScientific$fToDhallDouble$fToDhallWord64$fToDhallWord32$fToDhallWord16$fToDhallWord8 $fToDhallWord $fToDhallInt$fToDhallInteger$fToDhallNatural $fToDhall[]0 $fToDhallText$fToDhallText0 $fToDhallBool $fToDhallVoid $fFromDhall->$fMonoidUnionDecoder$fSemigroupUnionDecoder$fDivisibleRecordEncoder$fContravariantRecordEncoder$fSemigroupExtractErrors$fFunctorDecoder$fFunctorRecordDecoder$fApplicativeRecordDecoder$fFunctorUnionDecoder$fContravariantUnionEncoder HaskellTypeMultipleConstructorsSingleConstructortypeNamecodeconstructorNamestaticDhallExpressionmakeHaskellTypeFromUnionmakeHaskellTypes$fFunctorHaskellType$fFoldableHaskellType$fTraversableHaskellType dhallVersiondhallVersionStringreplModeDefaultVersionResolve NormalizeReplFreezeHashLintTagsEncodeDecode DirectoryTree SyntaxTreeoutputannotatealphasemanticCacheModeversion resolveModequietall_expr1expr2suffixesfollowSymlinksjsonOptionsmodeexplainplainascii parseOptionsparserInfoOptionsmainGHC.Basefmapbytestring-0.10.8.2Data.ByteString.Internal ByteString GHC.MaybeNothing(http-client-0.6.4-Dltunv90k40KvX745duCavNetwork.HTTP.Client.TypesManagernubOrdData.Map.InternalData.Set.InternalVoidghc-prim GHC.TypesIntJust GHC.ClassesEqTrueCharsplitOnNonEmpty linesLiteralunlinesLiteral emptyLine leadingSpaceslongestSharedWhitespacePrefix dropLiteraltoDoubleQuoted$fOrdDhallDoubleOrd$fEqDhallDouble $fPrettyExpr $fOrdExpr$fEqExprrenderComponent renderQuery renderURLHLamInfoevalVHLamValquotePrimTypedNaturalSubtractZeronf $fShowValNamesBind EmptyNamesVPiVHPiVConstVVarVPrimVarVAppVLamVBoolVBoolLitVBoolAndVBoolOrVBoolEQVBoolNEVBoolIfVNatural VNaturalLit VNaturalFold VNaturalBuildVNaturalIsZero VNaturalEven VNaturalOddVNaturalToInteger VNaturalShowVNaturalSubtract VNaturalPlus VNaturalTimesVInteger VIntegerLit VIntegerClampVIntegerNegate VIntegerShowVIntegerToDoubleVDouble VDoubleLit VDoubleShowVTextVTextLit VTextAppend VTextShowVListVListLit VListAppend VListBuild VListFold VListLength VListHead VListLast VListIndexed VListReverse VOptionalVSomeVNone VOptionalFoldVOptionalBuildVRecord VRecordLitVUnionVCombine VCombineTypesVPreferVMergeVToMapVFieldVInjectVProjectVAssert VEquivalentVEmbedClosure EnvironmentEmptyExtendSkiptoVHPi~>envNames countNamesFalseGHC.Errerror boundedTypeMonadData.ByteString.Lazy.InternalunApply duplicateencloseenclose' renderSrcanglesbracesarrowsforallmultilineChunksescapeSharedWhitespacePrefixescapeControlCharacterssplitOnPredicateescapeTrailingSingleQuotepretty_escapeSingleQuotedText escapeText_prettyEnvironmentVariable prettyConst prettyVar prettySrcExprkeywordliteralbuiltinoperatorcommalbracketrbracketlangleranglelbracerbracelparenrparenpipecolonequalsdotlambdararrow prettyLabelprettyAnyLabel prettyLabels prettyNumber prettyInt prettyNatural prettyDoubleprettyToStringdocToStrictTextprettyToStrictText*prettyprinter-1.6.1-KjG1sEzf1n21EgCkj9uNVa"Data.Text.Prettyprint.Doc.InternalDoc&megaparsec-8.0.0-9g7AKmV0pGtLHgiBXCxWUText.MegaparsecParseclaxSrcEqcountrangeoptionstarplussatisfy takeWhile takeWhile1 noDuplicates toMapWith pathComponent&parsers-0.12.10-7AKBVUN7J0lHWrhoCAsg9lText.Parser.Char Data.EitherEitherIOGHC.ShowShow Data.DynamicDynamic InternalErrorimportSemanticsemptyStatusWithInputOrTextFromStdininferCtxTag tagPatterntagNameloLineloOffset_lcLine _lcColumnfileTagsfixPosAndDefinition LineColumn LineOffset inputToFilesfetchFromHttpUrl CanonicalizeCannotImportHTTPURL loadImportloadImportWithSemanticCacheloadImportWithSemisemanticCacheFunctorResult%data-fix-0.2.0-1uhrmMdZVS2IRXxxgCLu1bData.FixFix ExtractError%either-5.0.1.1-8B1trZbPNmi58nJuy0erx8Data.Either.Validation Validation inputHelper)scientific-0.3.6.2-6bc2BhY5av25ENBHp3W8voData.Scientific ScientificMaybe3unordered-containers-0.2.10.0-b9YJCQLkMeLUf311RZkQDData.HashMap.BaseString Contravariant*contravariant-1.5.2-1ZQM8SswnWXJmdlHRX0Vigdivided Divisibletemplate-haskellLanguage.Haskell.TH.SyntaxtoNestedHaskellType toDeclaration toConstructor getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNamecurrentSaveFileIndexcurrentSaveFile nextSaveFile3optparse-applicative-0.15.1.0-2OPgP7o9KjFKThFwjitEaOptions.Applicative.Types ParserInfo