h$y       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstu v w x y z { | } ~                                                                                                                                                                            , Safe-Inferred5dhallA  (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  match (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 toList empty = [] toList (insert k v ctx) = (k, v) : toList ctx  None8dhallA SHA256 digestdhallAttempt to interpret a   as a , returning   if the conversion failsdhallHash a   and return the hash as a dhall  representation of a "None None 38:;?>*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)]fromList [("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.fromListWithKey (\k v1 v2 -> k ++ v1 ++ v2) [("B","v1"),("A","v2"),("B","v3")]#fromList [("B","Bv3v1"),("A","v2")]dhall Create a  from a Data.Map. dhall Create a  from a single key-value pair.Any 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 pairsAny further operations on this map will not retain the order of the keys.unorderedFromList [] fromList []unorderedFromList [("B",1),("A",2)] -- The map /doesn't/ preserve orderfromList [("A",2),("B",1)]unorderedFromList [("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) = TrueisSorted (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 , overriding any previous value stored underneath the same key, if present insert = insertWith (\v _ -> v)insert "C" 1 (fromList [("B",2),("A",3)]) -- Values are inserted on left"fromList [("C",1),("B",2),("A",3)]insert "C" 1 (fromList [("C",2),("A",3)]) -- New value takes precedencefromList [("C",1),("A",3)]$dhallInsert a key-value pair into a , using the supplied function to combine the new value with any old value underneath the same key, if presentinsertWith (+) "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)]'dhallSplit the map into values that do and don't satisfy the predicate3partition even (fromList [("C",3),("B",2),("A",1)])/(fromList [("B",2)],fromList [("C",3),("A",1)])2partition odd (fromList [("C",3),("B",2),("A",1)])/(fromList [("C",3),("A",1)],fromList [("B",2)])(dhall Restrict a  to only those keys found in a Data.Set. .restrictKeys (fromList [("A",1),("B",2)]) (Data.Set.fromList ["A"])fromList [("A",1)])dhallRemove all keys in a Data.Set.  from a withoutKeys (fromList [("A",1),("B",2)]) (Data.Set.fromList ["A"])fromList [("B",2)]*dhallTransform all values in a  using the supplied function, deleting the key if the function returns  mapMaybe Data.Maybe.listToMaybe (fromList [("C",[1]),("B",[]),("A",[3])])fromList [("C",1),("A",3)]+dhallRetrieve a key from a  lookup 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  member 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)]0dhall Combine two /s using a combining function for colliding keysunionWith (+) (fromList [("D",1),("C",2)]) (fromList [("B",3),("A",4)])*fromList [("D",1),("C",2),("B",3),("A",4)]unionWith (+) (fromList [("D",1),("C",2)]) (fromList [("C",3),("A",4)])"fromList [("D",1),("C",5),("A",4)]1dhallA generalised 0.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.2dhall Combine two < on their shared keys, keeping the value from the first  +intersection = intersectionWith (\v _ -> v)intersection (fromList [("C",1),("B",2)]) (fromList [("B",3),("A",4)])fromList [("B",2)]3dhall Combine two s on their shared keys, using the supplied function to combine values from the first and second intersectionWith (+) (fromList [("C",1),("B",2)]) (fromList [("B",3),("A",4)])fromList [("B",5)]4dhallCompute the difference of two .s by subtracting all keys from the second  from the first difference (fromList [("C",1),("B",2)]) (fromList [("B",3),("A",4)])fromList [("C",1)]5dhall%Fold all of the key-value pairs in a , in their original order3foldMapWithKey (,) (fromList [("B",[1]),("A",[2])]) ("BA",[1,2])6dhallTransform the values of a  using their corresponding key mapWithKey (pure id) = id mapWithKey (liftA2 (.) f g) = mapWithKey f . mapWithKey g mapWithKey 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))]7dhall)Traverse all of the key-value pairs in a , in their original order0traverseWithKey (,) (fromList [("B",1),("A",2)])!("BA",fromList [("B",1),("A",2)])8dhallSame as 7, except that the order of effects is not necessarily the same as the order of the keys9dhall)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.:dhall Convert a ; to a list of key-value pairs in the original order of keys#toList (fromList [("B",1),("A",2)])[("B",1),("A",2)];dhall Convert a 8 to a list of key-value pairs in ascending order of keys<dhall Convert a  Dhall.Map. to a Data.Map. toMap (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.  of the keys$keysSet (fromList [("B",1),("A",2)])fromList ["A","B"]Bdhall'\x -> x <> mempty == (x :: Map Int Int)'\x -> mempty <> x == (x :: Map Int Int)Cdhall9\x y z -> x <> (y <> z) == (x <> y) <> (z :: Map Int Int)Gdhall7fromList [("A",1),("B",2)] < fromList [("B",1),("A",0)]True' !"#$%&'()*+,-./0123456789:;<=>?' !"#$%&'()*+-,./0123467895:;<=?> Safe-InferredA Qdhall Identical to Control.Lens.Type.#$`Rdhall Identical to Control.Lens.Type.#$Sdhall Identical to  Control.Lens.%&Tdhall Identical to  Control.Lens.%'Udhall Identical to  Control.Lens.%(Vdhall Identical to  Control.Lens.%)Wdhall Identical to  Control.Lens.%*Xdhall Identical to Control.Lens.Plated.+,Ydhall Identical to Control.Lens.Getter.-.Zdhall Identical to Control.Lens.Fold./0 QRSTUVWXYZ RQSTUVWXYZNone38:;FM[dhallThis is a variation on Data.Set.  that remembers the original order of elements. This ensures that ordering is not lost when formatting Dhall code]dhallConvert to an unordered Data.Set. ^dhallConvert to an ordered _dhall Convert a [= to a list, preserving the original order of the elements`dhall Convert a [ to a list of ascending elementsadhallConvert a list to a [, remembering the element orderbdhall Convert a Data.Set.  to a sorted [cdhall"Append an element to the end of a [ddhall The empty [edhallReturns, 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.)fdhall:Sort the set elements, forgetting their original ordering.)sort (fromList [2, 1]) == fromList [1, 2]TruegdhallisSorted (fromList [2, 1])FalseisSorted (fromList [1, 2])Truehdhallnull (fromList [1])Falsenull (fromList [])Trueidhallsize (fromList [1])1[\]^_`abcdefghi[\_`]^abcdefghi None 38:FvdhallSource code extractvwxyzvwxyz1None !#$235678:;<+rdhallSyntax tree for expressionsThe s< type parameter is used to track the presence or absence of v spans:If s = v then the code may contains v spans (either in a > constructor or inline within another constructor, like )If s =   then the code has no v spansThe a 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 ssdhall Constants for a pure type systemThe axioms are: E Type : Kind E Kind : Sort!... and the valid rule pairs are: E Type C Type : Type -- Functions from terms to terms (ordinary functions) E Kind C Type : Type -- Functions from types to terms (type-polymorphic functions) E Sort C Type : Type -- Functions from kinds to terms E Kind C Kind : Kind -- Functions from types to types (type-level functions) E Sort C Kind : Sort -- Functions from kinds to types (kind-polymorphic functions) E Sort C Sort : Sort -- Functions from kinds to kinds (kind-level functions)Note that Dhall does not support functions from terms to types and therefore Dhall is not a dependently typed languagetdhallLabel for a bound variableThe % field is the variable's name (i.e. "x").The   field disambiguates variables with the same name if there are multiple bound variables of the same name in scope. Zero refers to the nearest bound variable and the index increases by one for each bound variable of the same name going outward. The following diagram may help:  JJJrefers toJJJ J J v J (x : Type) C (y : Type) C (x : Type) C x@0 JJJJJJJJJJJJJJJJJJrefers toJJJJJJJJJJJJJJJJJJ J J v J (x : Type) C (y : Type) C (x : Type) C 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:  JJrefers toJJ J J v J (x : Type) C (y : Type) C (x : Type) C x.Zero indices are omitted when pretty-printing Var6s and non-zero indices appear as a numeric suffix.dhall!Reference to an external resourcedhallA = extended with an optional hash for semantic integrity checksdhallHow 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 schemedhallThe 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  namedhallInternal 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  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 _ (FunctionBinding _ "x" _ _ A) b ~ (x : A) -> bdhall Pi _ "_" A B ~ A -> B Pi _ x A B ~ D(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  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 TextLit (Chunks [(t1, e1), (t2, e2)] t3) ~ "t1${e1}t2${e2}t3"dhall 2TextAppend x y ~ x ++ ydhall 7TextReplace ~ Text/replacedhall 5TextShow ~ Text/showdhall 0Date ~ Datedhall 6DateLiteral (fromGregorian _YYYY _MM _DD) ~ YYYY-MM-DDdhall 0Time ~ TimedhallPrecision | > TimeZone ~ TimeZonedhall 9TimeZoneLiteral (TimeZone ( 60 * _HH + _MM) _ _) ~ +HH:MM=| > TimeZoneLiteral (TimeZone (-60 * _HH + _MM) _ _) ~ -HH:MMdhall 0List ~ Listdhall ListLit (Just t ) [] ~ [] : t ListLit Nothing [x, y, z] ~ [x, y, z]Invariant: A non-empty list literal is always represented as ListLit Nothing xs.When 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 Record [ (k1, RecordField _ t1) ~ { k1 : t1, k2 : t1 } , (k2, RecordField _ t2) ]dhall RecordLit [ (k1, RecordField _ v1) ~ { k1 = v1, k2 = v2 } , (k2, RecordField _ v2) ]dhall ?Union [(k1, Just t1), (k2, Nothing)] ~ < k1 : t1 | k2 >dhall 1Combine _ Nothing x y ~ x D yThe first field is a   when the  operator is introduced as a result of desugaring duplicate record fields: RecordLit [ ( k ~ { k = x, k = y } , RecordField _ (Combine (Just k) x y) )]dhall 1CombineTypes _ x y ~ x T ydhall 1Prefer _ False x y ~ x U yThe first field is a   when the 5 operator is introduced as a result of desugaring a with expressiondhall 0RecordCompletion x y ~ x::ydhall Merge x y (Just t ) ~ merge x y : t Merge x y Nothing ~ merge x ydhall ToMap x (Just t) ~ toMap x : t ToMap x Nothing ~ toMap xdhall =ShowConstructor x ~ showConstructor xdhall 2Field e (FieldSelection _ x _) ~ e.xdhall Project e (Left xs) ~ e.{ xs } Project e (Right t) ~ e.(t)dhall 6Assert e ~ assert : edhall 3Equivalent _ x y ~ x D ydhall 8With x y e ~ x with y = edhall -Note s x ~ edhall 3ImportAlt ~ e1 ? e2dhall 2Embed import ~ importdhallA path component for a with expressiondhall)Record the field on a selector-expression For example, e . {- A -} x {- B -}"@ will be instantiated as follows:fieldSelectionSrc0 corresponds to the A commentfieldSelectionLabel corresponds to xfieldSelectionSrc1 corresponds to the B commentGiven our limitation that not all expressions recover their whitespaces, the purpose of fieldSelectionSrc1 is to save the 23 where the fieldSelectionLabel ends, but we still use a 'Maybe Src' (s = v3) to be consistent with similar data types such as , for example.dhall e"@ will be instantiated as follows:functionBindingSrc0 corresponds to the A commentfunctionBindingVariable is afunctionBindingSrc1 corresponds to the B commentfunctionBindingSrc2 corresponds to the C commentfunctionBindingAnnotation is TdhallRecord the field of a record-type and record-literal expression. The reason why we use the same ADT for both of them is because they store the same information. For example, !{ {- A -} x {- B -} : {- C -} T }... or !{ {- A -} x {- B -} = {- C -} T } will be instantiated as follows:recordFieldSrc0 corresponds to the A comment.recordFieldValue is TrecordFieldSrc1 corresponds to the B comment.recordFieldSrc2 corresponds to the C comment. Although the A comment isn't annotating the T> Record Field, this is the best place to keep these comments. Note that recordFieldSrc2 is always   when the - is for a punned entry, because there is no = sign. For example, { {- A -} x {- B -} } will be instantiated as follows:recordFieldSrc0 corresponds to the A comment.recordFieldValue corresponds to  (Var "x")recordFieldSrc1 corresponds to the B comment.recordFieldSrc2 will be  The labels involved in a record using dot-syntax like in this example: { {- A -} a {- B -} . {- C -} b {- D -} . {- E -} c {- F -} = {- G -} e } will be instantiated as follows:  For both the a and b field, recordfieldSrc2 is  For the a field:recordFieldSrc0 corresponds to the A commentrecordFieldSrc1 corresponds to the B commentFor the b field:recordFieldSrc0 corresponds to the C commentrecordFieldSrc1 corresponds to the D commentFor the c field:recordFieldSrc0 corresponds to the E commentrecordFieldSrc1 corresponds to the F commentrecordFieldSrc2 corresponds to the G comment?That is, for every label except the last one the semantics of recordFieldSrc0 and recordFieldSrc1/ are the same from a regular record label but recordFieldSrc2 is always  &. For the last keyword, all srcs are  dhallUsed to record the origin of a //= operator (i.e. from source code or a product of desugaring)dhallStores the original with expressiondhallThe 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. For example, 8let {- A -} x {- B -} : {- C -} Bool = {- D -} 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 Construct a  with no src informationdhallSmart constructor for  with no src informationdhallSmart constructor for  with no src informationdhall 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 r.% can be understood as an inverse for : let MultiLet bs e1 = multiLet b e0 wrapInLets bs e1 == Let b e0dhallA traversal over the immediate sub-expressions of an expression.dhallA traversal over the immediate sub-expressions of an expression which allows mapping embedded values dhallAn internal utility used to implement transformations that require changing one of the type variables of the r typeThis utility only works because the implementation is partial, not handling the , , or 3 cases, which need to be handled by the caller.dhallTraverse over the immediate r children in a .dhallTraverse over the immediate r children in a .dhallTraverse over the immediate r 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 r (i.e. de-)*This also remove CharacterSet annotations.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  constructors dhall.The set of reserved keywords according to the keyword rule in the grammardhallThe set of reserved identifiers for the Dhall language | Contains also all keywords from "reservedKeywords" dhallSplit  by lines dhallFlatten several  back into a single  by inserting newlines dhallCompute the longest shared whitespace prefix for the purposes of stripping leading indentation dhallConvert a single-quoted - literal to the equivalent double-quoted  literaldhall is used by both normalization and type-checking to avoid variable capture by shifting variable indicesFor example, suppose that you were to normalize the following expression: 4(a : Type) C (x : a) C ((y : a) C (x : a) C y) xIf you were to substitute y with x without shifting any variable indices, then you would get the following incorrect result: (a : Type) C (x : a) C (x : a) C 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) C (x : a) C (x : a) C x@1As a more worked example, suppose that you were to normalize the following expression:  (a : Type) C (f : a C a C a) C (x : a) C (x : a) C ((x : a) C f x x@1) x@1'The correct normalized result would be:  (a : Type) C (f : a C a C a) C (x : a) C (x : a) C f x@1 xThe 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)We 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 m 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.dhallUtility function used to throw internal errors that should never happen (in theory) but that are not enforced by the type system dhallThis 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 == nanTrueThis instance is also consistent with with the binary encoding of Dhall Doubles:toBytes n = Dhall.Binary.encodeExpression (DoubleLit n :: Expr Void Import),\a b -> (a == b) == (toBytes a == toBytes b) dhall-Generates a syntactically valid Dhall program dhallNote that this   instance inherits  's defects. dhallThis instance encodes what the Dhall standard calls an "exact match" between two expressions. Note thatnan = DhallDouble (0/0)DoubleLit nan == DoubleLit nanTruerst   4None #$ 5None  &2?dhallUtility that powers the  Text/show built-in dhall$Quote a value into beta-normal form. dhall For use with Text.Show.Functions.   56None & dhall A reified , 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   otherwise can fail with an  ) if you compare ill-typed expressionsdhall;Substitute all occurrences of a variable with an expression subst x C B ~ B[x := C]dhall=-normalize an expression by renaming all bound variables to "_"4 and using De Bruijn indices to distinguish them mfb = Syntax.makeFunctionBindingalphaNormalize (Lam mempty (mfb "a" (Const Type)) (Lam mempty (mfb "b" (Const Type)) (Lam mempty (mfb "x" "a") (Lam mempty (mfb "y" "b") "x"))))Lam Nothing (FunctionBinding {functionBindingSrc0 = Nothing, functionBindingVariable = "_", functionBindingSrc1 = Nothing, functionBindingSrc2 = Nothing, functionBindingAnnotation = Const Type}) (Lam Nothing (FunctionBinding {functionBindingSrc0 = Nothing, functionBindingVariable = "_", functionBindingSrc1 = Nothing, functionBindingSrc2 = Nothing, functionBindingAnnotation = Const Type}) (Lam Nothing (FunctionBinding {functionBindingSrc0 = Nothing, functionBindingVariable = "_", functionBindingSrc1 = Nothing, functionBindingSrc2 = Nothing, functionBindingAnnotation = Var (V "_" 1)}) (Lam Nothing (FunctionBinding {functionBindingSrc0 = Nothing, functionBindingVariable = "_", functionBindingSrc1 = Nothing, functionBindingSrc2 = Nothing, functionBindingAnnotation = Var (V "_" 1)}) (Var (V "_" 1)))))/-normalization does not affect free variables:alphaNormalize "x" Var (V "x" 0)dhallReduce 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 expressiondhallReduce an expression to its normal form, performing beta reduction and applying any custom definitions.& is designed to be used with function 7. The 7 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  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 expressiondhallCheck 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!dhallDetect if the given variable is free within the given expression"x" `freeIn` "x"True"x" `freeIn` "y"False"x" `freeIn` Lam mempty (Syntax.makeFunctionBinding "x" (Const Type)) "x"False NoneydhallSubstitutions 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 expr (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".The 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 #$&>?dhall)This indicates that a given CBOR-encoded  3 did not correspond to a valid Dhall expressiondhall,Encode a Dhall expression as a CBOR-encoded  dhall&Decode a Dhall expression from a CBOR 89:None #$&38:;dhall/This type determines whether to render code as  or dhallAnnotation type used to tag elements in a pretty-printed document for syntax highlighting purposesdhallPretty print an expressiondhallUsed for syntactic keywordsdhall:Syntax punctuation such as commas, parenthesis, and bracesdhall Record labelsdhall%Literals such as integers and stringsdhallBuiltin types and valuesdhall OperatorsdhallConvert annotations to their corresponding color for syntax highlighting purposesdhallDetect which character set is used for the syntax of an expression If any parts of the expression uses the Unicode syntax, the whole expression is deemed to be using the Unicode syntax.dhall/Escape a label if it is not valid when unquoteddhallEscape an environment variable if not a valid Bash environment variabledhallPretty-print an r using the given . largely ignores s. 1s do however matter for the layout of let-blocks:let inner = Let (Binding Nothing "x" Nothing Nothing Nothing (NaturalLit 1)) (Var (V "x" 0)) :: Expr Src ()prettyCharacterSet 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. dhallPretty-print a value dhall Escape a % literal using Dhall's escaping rules8Note that the result does not include surrounding quotesdhall 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 optionsdhall7Convert an expression representing a temporal value to , if possibleThis is used by downstream integrations (e.g. `dhall-json` for treating temporal values as strings dhallSince ASCII is a subset of Unicode, if either argument is Unicode, the result is Unicode9      NoneNone #$&dhallThis type is a   enriched with a = flag to efficiently track if any difference was detecteddhallRender the difference between the normal form of two expressionsdhall-Render the difference between two expressions;None dhallA ! that is almost identical to Text.Megaparsec. 9 except treating Haskell-style comments as whitespacedhallAn exception annotated with a v span dhallDoesn't force the  part dhall count n p parses n occurrences of p dhall range lo hi p parses n ocurrences of p where  lo <= n <= hi dhalloption p tries to apply parser p returning mempty if parsing failed dhallstar p tries to apply a parser 0 or more times dhallplus p tries to apply a parser 1 or more times dhall satisfy p creates a parser that consumes and return the next character if it satisfies the predicate p dhall takeWhile p creates a parser that accepts the longest sequence of characters that match the given predicate possibly returning an empty sequence dhall takeWhile1 p creates a parser that accepts the longest sequence of characters that match the given predicate. It fails when no character was consumed dhallCreates a map with the given key-value pairs, failing if there was a duplicate key. dhallCreates a 'Map Text a' using the provided combining function and the key-value pairs dhall1Convert a list of digits to the equivalent number None #$dhallThe  pathComponent function uses this type to distinguish whether to parse a URL path component or a file path componentdhall'Match an end-of-line character sequencedhallReturns   if the given   is a valid Unicode codepointdhall:Parse 0 or more whitespace characters (including comments)This corresponds to the whsp rule in the official grammardhall:Parse 1 or more whitespace characters (including comments)This corresponds to the whsp1 rule in the official grammardhall*Parse a hex digit (uppercase or lowercase)This corresponds to the HEXDIG rule in the official grammardhallParse a leading + or - signdhallParse a  literalThis corresponds to the double-literal rule from the official grammardhallParse a signed InfinityThis corresponds to the minus-infinity-literal and plus-infinity-literal$ rules from the official grammardhall Parse an  literalThis corresponds to the integer-literal rule from the official grammardhallParse a  literalThis corresponds to the natural-literal rule from the official grammardhallParse a 4-digit yearThis corresponds to the  date-fullyear rule from the official grammardhallParse a 2-digit monthThis corresponds to the  date-month rule from the official grammardhall Parse a 2-digit day of the monthThis corresponds to the  date-mday rule from the official grammardhallParse a 2-digit hourThis corresponds to the  time-hour rule from the official grammardhallParse a 2-digit minuteThis corresponds to the  time-minute rule from the official grammardhallParse a 2-digit secondThis corresponds to the  time-second rule from the official grammardhall*Parse the fractional component of a secondThis corresponds to the  time-secfrac rule from the official grammardhall1Parse an identifier (i.e. a variable or built-in)Variables can have an optional index to disambiguate shadowed variablesThis corresponds to the  identifier rule from the official grammardhall symboldhall Parse the | symboldhall Parse the , symboldhall Parse the ( symboldhall Parse the ) symboldhall Parse the : symboldhall Parse the @ symboldhallParse the equivalence symbol (=== or D)dhall Parse the missing keyworddhall Parse the ? symboldhall#Parse the record combine operator (/\ or D)dhall(Parse the record type combine operator (//\\ or T)dhall$Parse the record "prefer" operator (// or U)dhallParse a lambda (\ or )dhallParse a forall (forall or D)dhallParse a right arrow (-> or C)dhallParse a double colon (::)None !#$%?dhall< distinguishes certain subtypes of application expressions.dhall merge x y, Some x or toMap x, unparenthesized.dhallAn import expression.dhall!Any other application expression.dhallFor efficiency (and simplicity) we only expose two parsers from the result of the  function, since these are the only parsers needed outside of this moduledhall)Get the current source offset (in tokens)dhallSet the current source offsetdhallWrap a 2 to still match the same text but return only the v spandhallSame as %, except also return the parsed valuedhallWrap a = to still match the same text, but to wrap the resulting r in a  constructor containing the v spandhallParse 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 grammardhallParse a numeric This corresponds to the time-numoffset rule from the official grammardhallParse a numeric  or a ZThis corresponds to the  time-offset rule from the official grammardhallParse a This corresponds to the  partial-time rule from the official grammardhallParse a This corresponds to the  full-date rule from the official grammardhallParse a , , 1 or any valid permutation of them as a recordThis corresponds to the temporal-literal rule from the official grammardhall -- 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 nameddhallThis is only used by the = instance for functions in order to normalize the function input before marshaling the input into a Dhall expression.dhallUse these options to tweak how Dhall derives a generic implementation of =.dhallFunction used to transform Haskell field names into their corresponding Dhall field namesdhallFunction used to transform Haskell constructor names into their corresponding Dhall alternative namesdhallSpecify how to handle constructors with only one field. The default is dhall!This type is exactly the same as   except with a different = instance. This intermediate type simplifies the implementation of the inner loop for the = instance for  .dhallDefault normalization-related settings (no custom normalization)dhallDefault interpret options for generics-based instances, which you can tweak or override, like this: genericAutoWith (defaultInterpretOptions { fieldModifier = Data.Text.Lazy.dropWhile (== '_') }),      None #$-9>?)dhall 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:}And assume that we have the following Dhall union that we would like to parse as a Status: < 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):}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 }:}And assume that we have the following Dhall record that we would like to parse as a Project: { 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 ) where 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" ) where adapt (Project{..}) = (projectName, (projectDescription, projectStars)):}dhall-This is the underlying class that powers the = class's support for automatically deriving a generic implementation.dhallA compatibility alias for 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:Marshaling 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))Marshaling the resulting Dhall expression back into a Haskell valueThis class auto-generates a default implementation for types that implement . This does not auto-generate an instance for recursive types.*The default instance can be tweaked using / and custom , or using  https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#extension-DerivingVia DerivingVia and > from Dhall.Deriving.dhallAn  (Encoder a)- represents a way to marshal a value of type 'a' from Haskell into Dhall.dhall,Embeds a Haskell value as a Dhall expressiondhallDhall type of the Haskell valuedhall7Use the default input normalizer for injecting a value. *inject = injectWith defaultInputNormalizerdhallUse 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.dhallUse custom 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.dhall is like , but instead of using the  it expects an custom .dhall Convert a  into the equivalent .dhall>Specify how to encode one field of a record using the default  instance for that type.dhallSpecify how to encode one field of a record by supplying an explicit  for that field.dhall Convert a  into the equivalent .dhall:Specify how to encode an alternative by using the default  instance for that type.dhall>Specify how to encode an alternative by providing an explicit  for that alternative.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).dhallInfix  dhallEmbed a AB as a Prelude.Map.Type.prettyExpr $ embed inject (HashMap.fromList [(1 :: Natural, True)])#[ { mapKey = 1, mapValue = True } ]prettyExpr $ embed inject (HashMap.fromList [] :: HashMap Natural Bool)/[] : List { mapKey : Natural, mapValue : Bool }dhallEmbed a A! as a Prelude.Map.Type.prettyExpr $ embed inject (Data.Map.fromList [(1 :: Natural, True)])#[ { mapKey = 1, mapValue = True } ]prettyExpr $ embed inject (Data.Map.fromList [] :: Data.Map.Map Natural Bool)/[] : List { mapKey : Natural, mapValue : Bool }dhall+Note that the output list may not be sorteddhall)Note that the output list will be sorted./let x = Data.Set.fromList ["mom", "hi" :: Text]prettyExpr $ embed inject x[ "hi", "mom" ]dhall Encode a   to a Dhall Natural.embed inject (12 :: Word64) NaturalLit 12dhall Encode a   to a Dhall Natural.embed inject (12 :: Word32) NaturalLit 12dhall Encode a   to a Dhall Natural.embed inject (12 :: Word16) NaturalLit 12dhall Encode a   to a Dhall Natural.embed inject (12 :: Word8) NaturalLit 12dhall Encode a   to a Dhall Natural.embed inject (12 :: Word) NaturalLit 12..55None !#$%&/dhall(Automatically improve a Dhall expressionCurrently this:removes unused let bindings with .fixes  let a = x D y to be let a = assert : x D yconsolidates nested let bindings to use a multiple-let binding with fixes paths of the form ./../foo to ../foodhallRemove unused  bindings.dhallFix . bindings that the user probably meant to be assertsdhallThis transforms ./../foo into ../foodhallThis transforms  $https://prelude.dhall-lang.org/@/foo to  *https://prelude.dhall-lang.org/@/foo.dhalldhallThe 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 a record of key-value pairs with the equivalent use of toMapThis is currently not used by  dhall lint because this would sort Map keys, which is not necessarily a behavior-preserving change, but is still made available as a convenient rewrite rule. For example, {json,yaml}-to-dhall+ use this rewrite to simplify their output.CNone #$;dhallWrapper around DEs with a prettier   instance8In order to keep the library API constant even when the  with-http Cabal flag is disabled the pretty error message is pre-rendered and the real DE is stored in a  dhallThis exception indicates that there was an internal error in Dhall's import-related logic)This exception indicates that an invalid 1F was provided to the G functiondhall,State threaded throughout the import processdhall Stack of s that we've imported along the way to get to the current pointdhallGraph 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 requestsdhallLoad the origin headers from environment or configuration file. After loading once, further evaluations return the cached version.dhall:The remote resolver, fetches the content at the given URL.dhallRecords whether or not we already warned the user about issues with cache directorydhallUsed internally to track whether or not we've already warned the user about caching issues dhall$A map of site origin -> HTTP headersdhall HTTP headersdhallShared state for HTTP requestsdhallThis enables or disables the semantic cache for imports protected by integrity checksdhall imports (i.e. depends on) dhall(An import that has been fully interpeted dhall7The fully resolved import, typechecked and beta-normal.dhallA fully "chained" 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 importdhallThe default HTTP  dhallInitial , parameterised over the HTTP , the origin headers and the remote resolver, importing relative to the given root import.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 dhall Lens from a  to its  field/       None #$%B1udhall>Utility function to cut out the interior of a large text blockdhallException thrown when the --check( flag to a command-line subcommand failsdhallA check failure corresponding to a single input. This type is intended to be used with  for error reporting.dhall)Some command-line subcommands can either  their input or  that the input has already been modified. This type is shared between them to record that choice.dhallPath to outputdhallSpecifies whether or not an input's transitive dependencies should also be processed. Transitive dependencies are restricted to relative file imports.dhall&Do not process transitive dependenciesdhall/Process transitive dependencies in the same waydhall Path to inputdhallSet to < if you want to censor error text that might include secretsdhallLike u , 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 messagesdhallRun IO for multiple inputs, then collate all the check failures before throwing if there was any failuredhall/Convenient utility for retrieving an expressiondhallConvenient 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)dhallConvenient utility to output an expression either to a file or to stdout."u"uNone #$&3JdhallNewtype used to wrap error messages so that they render with a more detailed explanation of what went wrongdhallWrap a type error in this exception type to censor source code and  literals from the error messagedhall-A structured type error that includes contextdhall Output of 4, containing short- and long-form error messagesdhall6Default succinct 1-line explanation of what went wrongdhallPossibly-empty hints based on specific types involved in the errordhall1Longer and more detailed explanation of the errordhallThe specific type errordhall+Function that converts the value inside an & constructor into a new expressiondhallA type synonym for  This is provided for backwards compatibility, since Dhall used to use its own  type instead of  Data.Void. . You should use   instead of  nowdhallType-check an expression and return the expression's type if type-checking succeeds or an error if type-checking fails does not necessarily normalize the type since full normalization is not necessary for just type-checking. If you actually care about the returned type then you may want to  it afterwards. The supplied  records the types of the names in scope. If these are ill-typed, the return value may be ill-typed.dhallGeneralization of  that allows type-checking the " constructor with custom logicdhall is the same as  with an empty context, meaning that the expression must be closed (i.e. no free variables), otherwise type-checking will fail.dhall Convert a  to short- and long-form dhall Traversal that traverses every r in a dhallThis function verifies that a custom context is well-formed so that type-checking will not loop Note that  already calls  for you on the  that you supplyHNone &MdhallGiven 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. dhallNormalize, typecheck and return OriginHeaders from a given expression. None P dhall$Generate etags for Dhall expressionsdhall7Where 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 fileNone #$%&-.1259<>??dhallError type used when determining the Dhall type of a Haskell expression.dhallOne or more errors returned when determining the Dhall type of a Haskell expression.dhallUseful synonym for the  2 type used when marshalling Dhall expressions.dhallEvery  must obey the contract that if an expression's type matches the  type then the  function must not fail with a type error. However, decoding may still fail for other reasons (such as the decoder for  Is rejecting a Dhall List with duplicate elements).This error type is used to indicate an internal error in the implementation of a  where the expected type matched the Dhall expression, but the expression supplied to the extraction function did not match the expected type. If this happens that means that the  itself needs to be fixed.dhall"Useful synonym for the equivalent  + type used when marshalling Dhall code.dhallUseful synonym for the  2 type used when marshalling Dhall expressions.dhallExtraction 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 extract), or a term-level error, described with a freeform text value.dhallOne or more errors returned from extracting a Dhall expression to a Haskell expression.dhall5A newtype suitable for collecting one or more errors.dhallThe  monoid allows you to build a  from a Dhall union.8For example, let's take the following Haskell data type::{data Status = Queued Natural | Result Text | Errored Text:}And assume that we have the following Dhall union that we would like to parse as a Status: < 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 }:}And assume that we have the following Dhall record that we would like to parse as a Project: { 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  class's support for automatically deriving a generic implementation for a union type.dhall-This is the underlying class that powers the  class's support for automatically deriving a generic implementation.dhallA compatibility alias for .dhallAny value that implements  can be automatically decoded based on the inferred return type of G.-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)]This class auto-generates a default implementation for types that implement . This does not auto-generate an instance for recursive types.*The default instance can be tweaked using / and custom , or using  https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/glasgow_exts.html#extension-DerivingVia DerivingVia and > from Dhall.Deriving.dhallA  (Decoder a)- represents a way to marshal a value of type 'a' from Dhall into Haskell.You can produce s either explicitly: 6example :: Decoder (Vector Text) example = vector text... or implicitly using : /example :: Decoder (Vector Text) example = autoYou can consume  s using the G function: "input :: Decoder a -> Text -> IO adhall0Extracts Haskell value from the Dhall expressiondhallDhall type of the Haskell valuedhall;Use the default input normalizer for interpreting an input. &auto = autoWith defaultInputNormalizerdhall# is the default implementation for  if you derive &. The difference is that you can use , without having to explicitly provide a 5 instance for a type as long as the type derives .dhall is a configurable version of .dhall is like , but instead of using the  it expects an custom .dhall Decode a  .input bool "True"Truedhall Decode a JK.input natural "42"42dhall Decode an  .input integer "+42"42dhall Decode a   from a Dhall Natural.input word "42"42dhall Decode a   from a Dhall Natural.input word8 "42"42dhall Decode a   from a Dhall Natural.input word16 "42"42dhall Decode a   from a Dhall Natural.input word32 "42"42dhall Decode a   from a Dhall Natural.input word64 "42"42dhall Decode an   from a Dhall Integer.input int "-42"-42dhall Decode an   from a Dhall Integer.input int8 "-42"-42dhall Decode an   from a Dhall Integer.input int16 "-42"-42dhall Decode an   from a Dhall Integer.input int32 "-42"-42dhall Decode an   from a Dhall Integer.input int64 "-42"-42dhall Decode a  .input scientific "1e100"1.0e100dhall Decode a  .input double "42.0"42.0dhallDecode  .input shortText "\"Test\"""Test"dhall Decode lazy .input lazyText "\"Test\"""Test"dhallDecode strict .input strictText "\"Test\"""Test"dhallDecode  input timeOfDay "00:00:00"00:00:00dhallDecode  input day "2000-01-01" 2000-01-01dhallDecode  input timeZone "+00:00"+0000dhallDecode  %input localTime "2020-01-01T12:34:56"2020-01-01 12:34:56dhallDecode  +input zonedTime "2020-01-01T12:34:56+02:00"2020-01-01 12:34:56 +0200dhallDecode  )input utcTime "2020-01-01T12:34:56+02:00"2020-01-01 10:34:56 UTCdhallDecode  input dayOfWeek "< Sunday | Monday | Tuesday | Wednesday | Thursday | Friday | Saturday >.Monday"Mondaydhall Decode a  .input (maybe natural) "Some 1"Just 1dhall Decode a .$input (sequence natural) "[1, 2, 3]"fromList [1,2,3]dhallDecode a list. input (list natural) "[1, 2, 3]"[1,2,3]dhall Decode a ."input (vector natural) "[1, 2, 3]"[1,2,3]dhall0Decode a Dhall function into a Haskell function.f <- input (function inject bool) "Natural/even" :: IO (Natural -> Bool)f 0Truef 1FalsedhallDecode a Dhall function into a Haskell function using the specified normalizer.f <- input (functionWith defaultInputNormalizer inject bool) "Natural/even" :: IO (Natural -> Bool)f 0Truef 1Falsedhall Decode a   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   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   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   from a  with distinct elements.3input (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.Type.input (Dhall.map strictText bool) "toMap { a = True, b = False }"!fromList [("a",True),("b",False)]input (Dhall.map strictText bool) "[ { mapKey = \"foo\", mapValue = True } ]"fromList [("foo",True)]If there are duplicate mapKey s, later mapValues take precedence:let 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.Type.fmap (List.sort . HashMap.toList) (input (Dhall.hashMap strictText bool) "toMap { a = True, b = False }")[("a",True),("b",False)]fmap (List.sort . HashMap.toList) (input (Dhall.hashMap strictText bool) "[ { mapKey = \"foo\", mapValue = True } ]")[("foo",True)]If there are duplicate mapKey s, later mapValues take precedence:let 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 record.input (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, G  will always fail.dhall Decode a  input string "\"ABC\"""ABC"dhallGiven a pair of ,s, decode a tuple-record into their pairing.3input (pair natural bool) "{ _1 = 42, _2 = False }" (42,False)dhallRun a  to build a .dhall!Parse a single field of a record.dhallRun a  to build a .dhall&Parse a single constructor of a union.dhall2Render a given prefix and some errors to a string.dhallGenerate a type error during extraction by specifying the expected type and the actual type. The expected type is not yet determined.dhallTurn a $ message into an extraction failure.dhallSwitches from an  Applicative5 extraction result, able to accumulate errors, to a Monad8 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.dhallYou 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.foldFix Foldable.embed main :: IO () main = do x <- Dhall.input Dhall.auto example :: IO (Fix ExprF) print (convert x :: Expr)dhallNote that this instance will throw errors in the presence of duplicates in the list. To ignore duplicates, use .dhallNote that this instance will throw errors in the presence of duplicates in the list. To ignore duplicates, use .LNone #$% None  #$%3:?"dhall A call to - failed because there was at least one importdhall.Exception thrown when an integrity check failsdhallList 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  import (interpreting relative path as relative to the current directory).dhall*Adjust the import mode of a chained importdhallChain imports, also typecheck and normalize headers if applicable.dhallEnsure that the given expression is present in the semantic cache. The given expression should be alpha-beta-normal.dhall Fetch the text contents of a URLdhall6Load headers only from the environment (used in tests)dhallDefault starting ,, importing relative to the given directory.dhallSee dhallSee .dhallDefault 1 appropriate for a server interpreting Dhall code Using this  ensures that interpreted Dhall code cannot access server-local resources (like files or environment variables)dhallSee dhallGeneralized version of ;You can configure the desired behavior through the initial  that you supplydhall(Resolve all imports within an expressiondhallSee .dhallResolve all imports within an expression, importing relative to the given directory.dhallSee .dhall Hash a fully resolved expressiondhallConvenience utility to hash a fully resolved expression and return the base-16 encoded hash with the sha256: prefixIn 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-freedhallThis function is used by the  --transitive option of the dhall {freeze,format,lint} subcommands to determine which dependencies to descend intodependencyToFile (emptyStatus ".") Import{ importHashed = ImportHashed{ hash = Nothing, importType = Local Here (File (Directory []) "foo") }, importMode = Code } Just "./foo"dependencyToFile (emptyStatus "./foo") Import{ importHashed = ImportHashed{ hash = Nothing, importType = Local Here (File (Directory []) "bar") }, importMode = Code }Just "./foo/bar"dependencyToFile (emptyStatus "./foo") Import{ importHashed = ImportHashed{ hash = Nothing, importType = Remote (URL HTTPS "example.com" (File (Directory []) "") Nothing Nothing) }, importMode = Code }NothingdependencyToFile (emptyStatus ".") Import{ importHashed = ImportHashed{ hash = Nothing, importType = Env "foo" }, importMode = Code }Nothingdhall3canonicalize (Directory {components = ["..",".."]})$Directory {components = ["..",".."]}dhallPublic address of the serverNone #$:^dhallErrors that can be thrown by dhallArguments to the rewrite-with-schemas subcommanddhallImplementation of the dhall rewrite-with-schemas subcommanddhall5Simplify a Dhall expression using a record of schemasdhallRecord of schemasdhall1Expression to simplify using the supplied schemas  None #$-.1>?dhalldhalldhalldhall5Default 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.dhallDefault evaluation settings: no extra entries in the initial context, and no special normalizer behaviour.dhallAccess the starting context used for evaluation and type-checking.dhall Access the custom substitutions.dhallAccess the custom normalizer.$dhall$Access the HTTP manager initializer.dhallType-check and evaluate a Dhall program, decoding the result into HaskellThe 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  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.dhallType-check and evaluate a Dhall program that is read from the file-system.This uses the settings from .dhallExtend  with a custom typing context and a custom normalization process.dhall Similar to %, but without interpreting the Dhall r 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.dhallUse this function to extract Haskell values directly from Dhall AST. The intended use case is to allow easy extraction of Dhall values for making the function  easier to use.For other use cases, use  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 N:N symbol, like this: JJJJJJJJJ J x : t J NxN is an expression and NtN is the annotated type or kind of NxN JJJJJJJJJ 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: JJJJJJJJJJJJJJJ J 1 : Natural J N1N is an expression that has type NNaturalN, so the type JJJJJJJJJJJJJJJ checker accepts the annotation JJJJJJJJJJJJJJJJJJJJJJJJJ J Natural/even 2 : Bool J NNatural/even 2N has type NBoolN, so the type JJJJJJJJJJJJJJJJJJJJJJJJJ checker accepts the annotation JJJJJJJJJJJJJJJJJJJJJJ J List : Type C Type J NListN is an expression that has kind NType C TypeN, JJJJJJJJJJJJJJJJJJJJJJ so the type checker accepts the annotation JJJJJJJJJJJJJJJJJJJJ J List Text : Type J NList TextN is an expression that has kind NTypeN, so JJJJJJJJJJJJJJJJJJJJ the type checker accepts the annotation However, the following annotations are not valid and the type checker will reject them: JJJJJJJJJJJJ J 1 : Text J The type checker rejects this because N1N does not have type JJJJJJJJJJJJ NTextN JJJJJJJJJJJJJJJ J List : Type J NListN does not have kind NTypeN JJJJJJJJJJJJJJJ You or the interpreter annotated this expression: C True ... with this type or kind: C Integer ... but the inferred type or kind of the expression is actually: C Bool Some common reasons why you might get this error: K The Haskell Dhall interpreter implicitly inserts a top-level annotation matching the expected type For example, if you run the following Haskell code: JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ J >>> input auto "1" :: IO Text J JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ ... then the interpreter will actually type check the following annotated expression: JJJJJJJJJJJJ J 1 : Text J JJJJJJJJJJJJ ... and then type-checking will fail JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ True : Integer (input):1:1dhallThe 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 decoder for the Dhall valuedhalla closed form Dhall program, which evaluates to the expected typedhallThe decoded value in HaskellMNoneNone #$567BdhallThis data type holds various options that let you control several aspects how Haskell code is generated. In particular you candisable the generation of / instances.modify how a Dhall union field translates to a Haskell data constructor.dhallHow to map a Dhall union field name to a Haskell constructor. Note: The  of & will be passed to this function, too.dhallHow to map a Dhall record field names to a Haskell record field names.dhall Generate a  instance for the Haskell typedhall Generate a  instance for the Haskell typedhallUsed by  and + to specify how to generate Haskell types.dhallGenerate a Haskell type with more than one constructor from a Dhall union type.dhallGenerate a Haskell type with one constructor from any Dhall type.To 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 constructordhallThis 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 F, 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.dhall%A quasi-quoter for Dhall expressions.This quoter is build on top of . Therefore consult the documentation of that function for further information.This quoter is meant to be used in expression context only; Other contexts like pattern contexts or declaration contexts are not supported and will result in an error.dhallGenerate 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 : makeHaskellTypeFromUnion typeName code = makeHaskellTypes [ MultipleConstructors{..} ]dhall!A default set of options used by  . That means:.Constructors and fields are passed unmodified.Both  and  instances are generated.dhallGenerate a Haskell datatype declaration with one constructor from a Dhall type.This 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 > -- ./Employee.dhall { name : Text, department : ./Department.dhall }!... this Template Haskell splice: {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DerivingStrategies #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE TemplateHaskell #-} 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 deriving stock (GHC.Generics.Generic) deriving anyclass (Dhall.FromDhall, Dhall.ToDhall) data Employee = MakeEmployee {department :: Department, name :: Data.Text.Internal.Text} deriving stock (GHC.Generics.Generic) deriving anyclass (Dhall.FromDhall, Dhall.ToDhall)Carefully 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.dhall) and replaces that reference with the corresponding Haskell type.This Template Haskell splice requires you to enable the following extensions:  DeriveGeneric DerivingAnyClass DerivingStrategies,By default, the generated types only derive , , and *. To add any desired instances (such as  / / ), you can use the StandaloneDeriving language extension, like this: {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DerivingStrategies #-} {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-} Dhall.TH.makeHaskellTypes [ MultipleConstructors "Department" "./tests/th/Department.dhall" , SingleConstructor "Employee" "MakeEmployee" "./tests/th/Employee.dhall" ] deriving instance Eq Department deriving instance Ord Department deriving instance Show Department deriving instance Eq Employee deriving instance Ord Employee deriving instance Show EmployeedhallLike , but with the ability to customize the generated Haskell code by passing .For instance, $ is implemented using this function: >makeHaskellTypes = makeHaskellTypesWith defaultGenerateOptionsdhall"Name of the generated Haskell typedhall)Dhall code that evaluates to a union typeNone ./>?dhallType-level version of  Wrap the field of a singleton constructor in a record only if the field is nameddhallType-level version of > Always wrap the field of a singleton constructor in a recorddhallType-level version of >. Never wrap the field of a singleton constructor in a recorddhallConvert a type of kind SingletonConstructors into a value of type SingletonConstructorsdhallSetSingletonConstructors t replaces the singletonConstructors from options! with the value-level version of t.dhallConvert casing to Train-Cased-PhrasedhallConvert casing to spinal-cased-phrasedhallConvert casing to snake_cased_phrasedhallConvert casing to PascalCasedPhrasedhallConvert casing to camelCasedPhrasedhallConvert casing to Title Cased PhrasedhallDropPrefix prefix, corresponds to the value level function  prefixdhallConvert a type into a  Text -> Text functiondhall Constructor t post-composes the constructorModifier from options$ with the value-level version of t, obtained with  TextFunctiondhallField t post-composes the  fieldModifier from options$ with the value-level version of t, obtained with  TextFunctiondhallComposition for functions on  and on Text . We use <<< since . isn't a valid type operator yet (it will be valid starting from ghc-8.8.1)dhallThe identity for functions on  and on Text. Useful for deriving  FromDhall and ToDhall with the default options.dhallConvert a type into a $InterpretOptions -> InterpretOptions functiondhallIntended for use on  deriving via clauses for types with a  instance. The tag% argument is used to construct an 1 value which is used as the first argument to .dhalldropPrefix prefix text returns the suffix of text if its prefix matches prefix, or the entire text otherwisedhalladdFieldModifier f options post-composes the  fieldModifier from options with f.dhall addConstructorModifier f options post-composes the constructorModifier from options with f.dhall"setSingletonConstructors v options replaces the singletonConstructors from options with v.1None #$&Y dhall5Specifies why we are adding semantic integrity checks dhallProtect imports with an integrity check without a fallback so that import resolution fails if the import changes dhallProtect imports with an integrity check and also add a fallback import import without an integrity check. This is useful if you only want to cache imports when possible but still gracefully degrade to resolving them if the semantic integrity check has changed. dhall!Specifies which imports to freeze dhall&Freeze only remote imports (i.e. URLs) dhall>Freeze all imports (including paths and environment variables) dhall Retrieve an 1 and update the hash to match the latest contents dhallSee  . dhall)Freeze an import only if the import is a  import dhallSee  . dhallImplementation of the  dhall freeze subcommand dhallSee  . dhall"Slightly more pure version of the   functionThis still requires   to freeze the import, but now the input and output expression are passed in explicitly dhallSee  . dhallCurrent working directory dhallCurrent working directory dhallStarting directory  None #$# dhallArguments to the   subcommand dhallImplementation of the  dhall format subcommand  None !#$& dhallThis error indicates that you supplied an invalid Dhall expression to the   function. The Dhall expression could not be translated to a directory tree. dhallAttempt to transform a Dhall record into a directory tree where:'Records are translated into directoriesMap&s are also translated into directoriesText+ values or fields are translated into filesOptional values are omitted if None(For example, the following Dhall record: { dir = { `hello.txt` = "Hello\n" } , `goodbye.txt`= Some "Goodbye\n" , `missing.txt` = None Text },... should translate to this directory tree: $ tree result result JJJ dir J JJJ hello.txt JJJ 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: let 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: $ cat result/example.json [ 1.0, true ] $ cat result/example.yaml ! "bar": null ! "foo": "Hello"This utility does not take care of type-checking and normalizing the provided expression. This will raise a   exception upon encountering an expression that cannot be converted as-is.  N Safe-Inferred%  Safe-Inferred dhall The current   of the Haskell implementation dhallThe current version   for the Haskell implementation  None #$%&?P dhallImplementation of the  dhall repl subcommand  None #$%1 dhall5This specifies how to resolve transitive dependencies dhallGenerate a DOT file for graphviz dhall6List all transitive dependencies as text, one per line dhall1List immediate dependencies as text, one per line dhallThe subcommands for the dhall executable dhallTop-level program options dhall  for the   type dhall  for the   type dhall!Run the command specified by the   type dhallEntry point for the dhall executable9 9 OPQORKSTUOVWOXYZ[\]^_`abcdefgghijklmnop!aqrstuvwxbyz{|}~de$&'()*,.0IIerawx111              :::::11111111111111111111111111111111111111111111111111111111K111111111111111111111U111111111111111111111111111111111111111111111111111111111111111111111111111111111F111111111111111111111566666666666666  a          ::::::::::::::;;;;;G<<<<<<<<<<<<<<<CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC        G                 b         7H=GG>>                                  F         U              G           O  O  O  "Z !Z IOX  O     1  1 1 1 1 1 1  1 1 1 1 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 55 5 55  O O   : : : : : : : : : :: : : : : : : : : : : : : : : : : : : : : : : : : : : : :  2 ; ; ; ; ; ; ; ; ; ;; ;O  O    O  O  O  O  O  O  O  O   B  << < < < < < < < OV ? ?  O  O  C C C C C C CCH H H  O            O   L L N N N N N N N N O    #dhall-1.41.2-CygVEUAXWhKKGHhZSAzzm9Dhall.Marshal.EncodeDhall.TypeCheck Dhall.Context Dhall.Crypto Dhall.Map Dhall.Optics Dhall.Set Dhall.Core Dhall.Util Dhall.Src Dhall.PrettyDhall.Substitution Dhall.Binary Dhall.Diff Dhall.ParserDhall.Parser.TokenDhall.Parser.Expression Dhall.Lint Dhall.Import Dhall.TagsDhall.Marshal.Decode Dhall.SchemasDhallDhall.THDhall.Deriving Dhall.Freeze Dhall.FormatDhall.DirectoryTree Dhall.Version Dhall.Repl Dhall.MainData.MapMapDhall.Import.ManagerControl.Lens.TypeOptic Control.Lens rewriteOf transformOf rewriteMOf transformMOfmapMOfControl.Lens.PlatedcosmosOfControl.Lens.GettertoControl.Lens.FoldfoldOf Dhall.SyntaxText.Megaparsec SourcePos Dhall.URL Dhall.EvalDhall.NormalizetypeWithCodec.CBOR.TermTermDhall.Pretty.InternalDhall.Parser.CombinatorsDhall.Marshal.Internal FromDhallCodec$Data.Functor.Contravariant.DivisiblechosenDataHashMapDhall.Import.TypesNetwork.HTTP.Client HttpExceptionTypeinputDhall.Import.HeadersSetPreludeNaturalDhall.Import.HTTPDhall.Tutorial Paths_dhallbase GHC.GenericsGeneric GHC.Natural text-1.2.3.2Data.Text.InternalTextData.Functor.Contravariant>$< Data.Voidabsurdcontainers-0.6.2.1Data.Sequence.InternalSeq&vector-0.12.3.1-BS9vrRx3ry325IASWLF2UH Data.VectorVectorContextemptyinsertmatchlookuptoList$fFunctorContext SHA256DigestunSHA256Digestsha256DigestFromByteString sha256HashtoString$fShowSHA256Digest$fEqSHA256Digest$fGenericSHA256Digest$fOrdSHA256Digest$fNFDataSHA256Digest singletonfromListfromListWithKeyfromMapunorderedSingletonunorderedFromListsortisSorted insertWithdeletefilter partition restrictKeys withoutKeysmapMaybeunconsmembersizeunion unionWith outerJoin intersectionintersectionWith differencefoldMapWithKey mapWithKeytraverseWithKeyunorderedTraverseWithKeyunorderedTraverseWithKey_ toAscListtoMapkeyselemskeysSet $fIsListMap $fShowMap $fMonoidMap$fSemigroupMap$fTraversableMap $fFoldableMap $fFunctorMap$fOrdMap$fEqMap $fDataMap $fGenericMap$fLiftLiftedRepMap $fNFDataMap $fDataKeys $fGenericKeys$fLiftLiftedRepKeys $fNFDataKeysOptic'toSettoSeqfromSetappendnull $fFoldableSet$fOrdSet$fEqSet $fGenericSet $fShowSet $fDataSet $fNFDataSet$fLiftLiftedRepSetExprConstVarsnipSrcsrcStartsrcEndsrcText $fPrettySrc$fLiftLiftedRepSrc $fDataSrc$fEqSrc $fGenericSrc$fOrdSrc $fShowSrc $fNFDataSrc CharacterSetASCIIUnicodeAnn prettyExprImport 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 TextAppend TextReplaceTextShowDate DateLiteralTime TimeLiteralTimeZoneTimeZoneLiteralListListLit ListAppend ListBuildListFold ListLengthListHeadListLast ListIndexed ListReverseOptionalSomeNoneRecord RecordLitUnionCombine CombineTypesPreferRecordCompletionMergeToMapShowConstructorFieldProjectAssert EquivalentWithNote ImportAltEmbed WithComponent WithLabel WithQuestionFieldSelectionfieldSelectionSrc0fieldSelectionLabelfieldSelectionSrc1FunctionBindingfunctionBindingSrc0functionBindingVariablefunctionBindingSrc1functionBindingSrc2functionBindingAnnotation RecordFieldrecordFieldSrc0recordFieldValuerecordFieldSrc1recordFieldSrc2PreferAnnotationPreferFromSourcePreferFromWithPreferFromCompletionChunks DhallDoublegetDhallDoubleBinding bindingSrc0variable bindingSrc1 annotation bindingSrc2valueVKindSort makeBindingmakeRecordFieldmakeFunctionBindingmakeFieldSelectionmultiLet wrapInLetssubExpressionssubExpressionsWith bindingExprsrecordFieldExprsfunctionBindingExprs chunkExprs pathCharacterdenoterenote shallowDenotereservedIdentifiersshift internalErrortextShowReifiedNormalizergetReifiedNormalizer Normalizer NormalizerMjudgmentallyEqualsubstalphaNormalize normalize normalizeWithnormalizeWithMisNormalizedWith isNormalizedfreeIn Substitutions substituteDecodingFailureCBORIsNotDhallencodeExpressiondecodeExpression$fSerialiseExpr$fSerialiseExpr0$fShowDecodingFailure$fExceptionDecodingFailure$fEqDecodingFailureKeywordSyntaxLabelLiteralBuiltinOperatorannToAnsiStyledetectCharacterSet escapeLabelescapeEnvironmentVariableprettyCharacterSetlayout layoutOptstemporalToTextDiffsamedocdiffNormalizeddiff$fIsStringDiff $fMonoidDiff$fSemigroupDiffParserunParserSourcedException ComponentType URLComponent FileComponent endOfLinevalidCodepoint whitespacenonemptyWhitespacehexdig signPrefix doubleLiteraldoubleInfinityintegerLiteralnaturalLiteral dateFullYear dateMonthdateMdaytimeHour timeMinute timeSecond timeSecFrac identifier hexNumberlineCommentPrefix lineComment blockCommentlabelslabelanyLabelanyLabelOrSomebashEnvironmentVariableposixEnvironmentVariablefile_httpRawtextchar_if_then_else_let_in_as_using_merge_toMap_showConstructor_assert_with_Some_None _NaturalFold _NaturalBuild_NaturalIsZero _NaturalEven _NaturalOdd_NaturalToInteger _NaturalShow_NaturalSubtract _IntegerClamp_IntegerNegate _IntegerShow_IntegerToDouble _DoubleShow _ListBuild _ListFold _ListLength _ListHead _ListLast _ListIndexed _ListReverse_Bool _Optional_Natural_Integer_Double_Text _TextReplace _TextShow_Date_Time _TimeZone_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 _doubleColonApplicationExprInfoNakedMergeOrSomeOrToMap ImportExprApplicationExprParserscompleteExpression_importExpression_ letBinding getOffset setOffsetsrcsrcAndnotedcompleteExpressionimportExpression timeNumOffset timeOffset partialTimefullDatetemporalLiteralshebangparsersenv localOnlylocalhttpmissing importType_ importHash_ importHashed_import_pretty escapeTextcensorExpression censorTextthrowsHeader ParseErrorunwrapexprexprAcensor exprFromText createHeaderexprAndHeaderFromText$fExceptionParseError$fShowParseError $fShowHeaderSingletonConstructorsBareWrappedSmartInputNormalizergetInputNormalizerInterpretOptions fieldModifierconstructorModifiersingletonConstructorsResultdefaultInputNormalizerdefaultInterpretOptions UnionEncoder RecordEncoderGenericToDhallgenericToDhallWithNormalizerInjectToDhall injectWithEncoderembeddeclaredinjectgenericToDhallgenericToDhallWith!genericToDhallWithInputNormalizer recordEncoder encodeFieldencodeFieldWith unionEncoderencodeConstructorencodeConstructorWith>|<>*<$fContravariantEncoder$fGenericToDhallU1$fGenericToDhall:*:$fGenericToDhall:+:$fGenericToDhall:+:0$fGenericToDhall:+:1$fGenericToDhall:+:2$fGenericToDhallM1$fGenericToDhallM10$fGenericToDhall:*:0$fGenericToDhall:*:1$fGenericToDhall:*:2$fGenericToDhallM11 $fToDhallFix$fToDhallResult$fToDhallHashMap $fToDhallMap $fToDhall(,)$fToDhallHashSet $fToDhallSet$fToDhallDayOfWeek$fToDhallUTCTime$fToDhallZonedTime$fToDhallLocalTime$fToDhallTimeZone $fToDhallDay$fToDhallTimeOfDay$fToDhallVector $fToDhall[] $fToDhallSeq$fToDhallMaybe $fToDhall()$fToDhallScientific$fToDhallDouble$fToDhallWord64$fToDhallWord32$fToDhallWord16$fToDhallWord8 $fToDhallWord$fToDhallInt64$fToDhallInt32$fToDhallInt16 $fToDhallInt8 $fToDhallInt$fToDhallInteger$fToDhallNatural $fToDhall[]0 $fToDhallText$fToDhallText0$fToDhallShortText $fToDhallBool $fToDhallVoid$fDivisibleRecordEncoder$fContravariantRecordEncoder$fContravariantUnionEncoderlintremoveUnusedBindings fixAssert fixParentPathaddPreludeExtensionsremoveLetInLetuseToMapPrettyHttpExceptionStatus_stack_graph_cache _newManager_manager_loadOriginHeaders_remote_substitutions _normalizer_startingContext_semanticCacheMode _cacheWarning CacheWarningCacheNotWarned CacheWarned HTTPHeaderManagerSemanticCacheModeIgnoreSemanticCacheUseSemanticCacheDependsparentchildImportSemanticsChained chainedImportdefaultNewManagerstackgraphcacheremote substitutions normalizerstartingContextMultipleCheckFailedcommandmodifiedinputs CheckFailed OutputModeWriteCheckOutputStandardOutput OutputFile Transitivity NonTransitive TransitiveInput StandardInput InputFileCensorNoCensorsnipDoc_ERRORhandleMultipleChecksFailed getExpressiongetExpressionAndHeader#getExpressionAndHeaderFromStdinTextrenderExpression$fShowMultipleCheckFailed$fExceptionMultipleCheckFailed $fEqInputDetailedTypeErrorCensoredCensoredDetailed TypeErrorcontextcurrent typeMessage ErrorMessagesshorthintslong TypeMessageUnboundVariableInvalidInputTypeInvalidOutputType NotAFunction TypeMismatch AnnotMismatchUntypedMissingListTypeMismatchedListElementsInvalidListElementInvalidListTypeListLitInvariant InvalidSomeInvalidPredicateIfBranchMismatchInvalidFieldTypeInvalidAlternativeTypeListAppendMismatchMustUpdateARecordMustCombineARecordInvalidDuplicateFieldInvalidRecordCompletionCompletionSchemaMustBeARecordCombineTypesRequiresRecordTypeRecordTypeMismatchDuplicateFieldCannotBeMergedFieldCollisionFieldTypeCollisionMustMergeARecordMustMergeUnionOrOptionalMustMapARecordInvalidToMapRecordKindHeterogenousRecordToMapInvalidToMapTypeMapTypeMismatchMissingToMapType UnusedHandlerMissingHandlerHandlerInputTypeMismatchDisallowedHandlerTypeHandlerOutputTypeMismatchInvalidHandlerOutputTypeMissingMergeTypeHandlerNotAFunction CantAccess CantProjectCantProjectByExpressionDuplicateProjectionLabel MissingFieldMissingConstructorProjectionTypeMismatchAssertionFailedNotAnEquivalenceIncomparableExpressionEquivalenceTypeMismatchNotWithARecordCantAndCantOrCantEQCantNECantInterpolateCantTextAppendCantListAppendCantAdd CantMultiplyOptionalWithTypeMismatch NotALabelPathNotAQuestionPathShowConstructorNotOnUnionTyperX typeWithAtypeOfprettyTypeMessagemessageExpressions checkContext$fPrettyTypeError$fExceptionTypeError$fShowTypeError$fPrettyDetailedTypeError$fExceptionDetailedTypeError$fShowDetailedTypeError$fPrettyCensored$fExceptionCensored$fShowCensored$fShowTypeMessage toHeadersgenerate $fMonoidTags$fSemigroupTags $fShowTag$fEqLineOffset$fOrdLineOffset$fShowLineOffset$fEqLineColumn$fOrdLineColumn$fShowLineColumnExpectedTypeErrorRecursiveTypeErrorExpectedTypeErrorsExpectorInvalidDecoderinvalidDecoderExpectedinvalidDecoderExpressionMonadicExtractor Extractor ExtractError ExtractErrors DhallErrors getErrors UnionDecoder RecordDecoderGenericFromDhallUniongenericUnionAutoWithNormalizerGenericFromDhallgenericAutoWithNormalizer InterpretautoWithDecoderextractexpectedauto genericAutogenericAutoWithgenericAutoWithInputNormalizerboolnaturalintegerwordword8word16word32word64intint8int16int32int64 scientificdouble shortTextlazyText strictText timeOfDaydaytimeZone localTime zonedTimeutcTime dayOfWeekmaybesequencelistvectorfunction functionWithsetIgnoringDuplicateshashSetIgnoringDuplicatessetFromDistinctListhashSetFromDistinctListmaphashMappairFromMapEntryunitvoidstringpairrecordfield constructorshowDhallErrors typeError extractError toMonadic fromMonadic$fExceptionDhallErrors$fShowInvalidDecoder$fExceptionInvalidDecoder$fExceptionExpectedTypeError$fShowDhallErrors$fExceptionExtractError$fShowExtractError$fShowDhallErrors0$fMonoidUnionDecoder$fSemigroupUnionDecoder$fGenericFromDhallUnionkkt:+:$fGenericFromDhallUnionkktM1$fGenericFromDhallTYPEkaM1$fGenericFromDhallTYPEka2:*:$fGenericFromDhallTYPEka1:*:$fGenericFromDhallkkt:*:$fGenericFromDhallkktU1$fGenericFromDhallkktM1$fGenericFromDhallkkt:+:$fGenericFromDhallkktV1$fGenericFromDhallkktM10$fGenericFromDhallkktM11$fGenericFromDhallkkt:*:0$fGenericFromDhallkkt:*:1$fGenericFromDhallkkt:*:2$fFromDhallFix$fFromDhallResult$fFromDhall(,) $fFromDhall->$fFromDhallHashMap$fFromDhallMap$fFromDhallHashSet$fFromDhallSet$fFromDhallDayOfWeek$fFromDhallUTCTime$fFromDhallZonedTime$fFromDhallLocalTime$fFromDhallTimeZone$fFromDhallDay$fFromDhallTimeOfDay$fFromDhallVector $fFromDhall[]$fFromDhallSeq$fFromDhallMaybe$fFromDhallText$fFromDhallText0$fFromDhallShortText$fFromDhall[]0$fFromDhallDouble$fFromDhallScientific$fFromDhallInt64$fFromDhallInt32$fFromDhallInt16$fFromDhallInt8$fFromDhallInt$fFromDhallInteger$fFromDhallWord64$fFromDhallWord32$fFromDhallWord16$fFromDhallWord8$fFromDhallWord$fFromDhallNatural$fFromDhallBool $fFromDhall()$fFromDhallVoid$fFunctorUnionDecoder$fFunctorDecoder$fFunctorRecordDecoder$fApplicativeRecordDecoder$fEqExpectedTypeError$fShowExpectedTypeError$fEqDhallErrors$fFunctorDhallErrors$fSemigroupDhallErrors $fFromDhallOp$fFromDhallEquivalence$fFromDhallPredicateImportResolutionDisabled HashMismatch expectedHash actualHashMissingImportsMissingEnvironmentVariablename MissingFileImported importStacknestedReferentiallyOpaque opaqueImportCycle cyclicImport localToPathchainedFromLocalHerechainedChangeMode chainImportwriteExpressionToSemanticCache fetchRemoteenvOriginHeaders emptyStatusemptyStatusWithManagermakeEmptyStatus remoteStatusremoteStatusWithManagerloadWithloadloadWithManagerloadRelativeToloadWithStatushashExpressionhashExpressionToCodeassertNoImportsdependencyToFile $fShowCycle$fExceptionCycle$fShowReferentiallyOpaque$fExceptionReferentiallyOpaque$fShowImported$fExceptionImported$fShowMissingFile$fExceptionMissingFile $fShowMissingEnvironmentVariable%$fExceptionMissingEnvironmentVariable$fShowMissingImports$fExceptionMissingImports$fShowCannotImportHTTPURL$fExceptionCannotImportHTTPURL$fCanonicalizeImport$fCanonicalizeImportHashed$fCanonicalizeImportType$fCanonicalizeFile$fCanonicalizeDirectory$fShowHashMismatch$fExceptionHashMismatch$fShowImportResolutionDisabled#$fExceptionImportResolutionDisabled SchemasErrorNotASchemaRecordSchemaschosenCharacterSet outputModeschemasschemasCommandrewriteWithSchemas$fShowSchemasError$fExceptionSchemasErrorHasEvaluateSettingsevaluateSettingsEvaluateSettings InputSettingsdefaultInputSettings rootDirectory sourceNamedefaultEvaluateSettings newManagerinputWithSettings inputFileinputFileWithSettings inputExprinputExprWithSettingsrawInputdetailed%$fHasEvaluateSettingsEvaluateSettings"$fHasEvaluateSettingsInputSettingsGenerateOptionsgenerateFromDhallInstancegenerateToDhallInstance HaskellTypeMultipleConstructorsSingleConstructortypeNamecodeconstructorNamestaticDhallExpressiondhallmakeHaskellTypeFromUniondefaultGenerateOptionsmakeHaskellTypesmakeHaskellTypesWith$fFunctorHaskellType$fFoldableHaskellType$fTraversableHaskellTypeToSingletonConstructorsasSingletonConstructorsSetSingletonConstructors TrainCase SpinalCase SnakeCase PascalCase CamelCase TitleCase DropPrefix TextFunction textFunction Constructor<<<AsIs ModifyOptions modifyOptionsunCodec dropPrefixaddFieldModifieraddConstructorModifiersetSingletonConstructors$fToDhallCodec$fFromDhallCodec$fModifyOptionsTYPE()$fModifyOptionsTYPE<<<$fModifyOptionsTYPEConstructor$fModifyOptionsTYPEField$fTextFunctionTYPE<<<$fTextFunctionTYPE()$fTextFunctionTYPEDropPrefix$fTextFunctionTYPETitleCase$fTextFunctionTYPECamelCase$fTextFunctionTYPEPascalCase$fTextFunctionTYPESnakeCase$fTextFunctionTYPESpinalCase$fTextFunctionTYPETrainCase+$fModifyOptionsTYPESetSingletonConstructors$fToSingletonConstructorsBare $fToSingletonConstructorsWrapped$fToSingletonConstructorsSmartIntentSecureCacheScopeOnlyRemoteImports AllImports freezeImportfreezeImportWithManagerfreezeRemoteImportfreezeRemoteImportWithManagerfreezefreezeWithManagerfreezeExpressionfreezeExpressionWithManagerFormat transitivityformatFilesystemErrorunexpectedExpressiontoDirectoryTree$fExceptionFilesystemError$fShowFilesystemError dhallVersiondhallVersionStringrepl ResolveModeDotListTransitiveDependenciesListImmediateDependenciesModeDefaultVersionResolve NormalizeReplFreezeHashLintTagsEncodeDecode DirectoryTree SyntaxTreeoutputannotatealphasemanticCacheModeversion resolveModequietdeprecatedInPlaceall_expr1expr2suffixesfollowSymlinksjsonOptionsmodeexplainplain parseOptionsparserInfoOptionsmainGHC.Basefmapbytestring-0.10.10.0Data.ByteString.Internal ByteString GHC.MaybeNothingString+http-client-0.7.13.1-5WfBytlyxfqHk7MifvJU3BNetwork.HTTP.Client.TypesData.Map.InternalData.Set.InternalVoidghc-prim GHC.TypesIntJustTrue GHC.ClassesEqunsafeSubExpressionsCharreservedKeywords linesLiteralunlinesLiterallongestSharedWhitespacePrefixtoDoubleQuoted$fOrdDhallDoubleOrd$fEqDhallDouble $fPrettyExpr $fOrdExpr$fEqExprrenderComponent renderQuery renderURLquote $fShowValNamesBind EmptyNamesValVHLamVPiVHPiVConstVVarVPrimVarVAppVLamVBoolVBoolLitVBoolAndVBoolOrVBoolEQVBoolNEVBoolIfVNatural VNaturalLit VNaturalFold VNaturalBuildVNaturalIsZero VNaturalEven VNaturalOddVNaturalToInteger VNaturalShowVNaturalSubtract VNaturalPlus VNaturalTimesVInteger VIntegerLit VIntegerClampVIntegerNegate VIntegerShowVIntegerToDoubleVDouble VDoubleLit VDoubleShowVTextVTextLit VTextAppend VTextShow VTextReplaceVDate VDateLiteralVTime VTimeLiteral VTimeZoneVTimeZoneLiteralVListVListLit VListAppend VListBuild VListFold VListLength VListHead VListLast VListIndexed VListReverse VOptionalVSomeVNoneVRecord VRecordLitVUnionVCombine VCombineTypesVPreferVMergeVToMapVShowConstructorVFieldVInjectVProjectVAssert VEquivalentVWithVEmbedClosure EnvironmentEmptyExtendSkiptoVHPi~>evalconvenvNames countNamesFalseGHC.ErrerrorMonadData.ByteString.Lazy.Internalpretty_ escapeText_$fSemigroupCharacterSetprettyImportExpressionprettyEnvironmentVariable prettyConst prettyVar prettySrcExprkeywordliteralbuiltinoperatorcommalbracketrbracketlangleranglelbracerbracelparenrparenpipecolonequalsdotlambdaforallrarrow prettyLabelprettyAnyLabel prettyLabels prettyNumber prettyInt prettyNatural prettyDoubleprettyToStringdocToStrictTextprettyToStrictText)prettyprinter-1.7.1-BauxLiNvN3EiJKyXe93SMPrettyprinter.InternalDoc'megaparsec-9.2.1-LXk3a8uRFW2H1cw5gbRHNzParseclaxSrcEqcountrangeoptionstarplussatisfy takeWhile takeWhile1 toMapWith&parsers-0.12.11-Ajutq2gTR1a9A4Ty0QTZlAText.Parser.Char Data.EitherEitherIO%data-fix-0.3.2-CUr69cSA09WI9zTJTjUQRDData.FixFixGHC.IntInt8Int16Int32Int64GHC.WordWord8Word16Word32Word64)scientific-0.3.7.0-J42tIA1QDQWBNyzgwhCVBYData.Scientific Scientific4unordered-containers-0.2.19.1-ARlYDgKGRsAGn3XTR9LnoMData.HashMap.InternalunFix _unResultunsafeExpectUnionunsafeExpectRecordunsafeExpectUnionLitunsafeExpectRecordLitnotEmptyRecordLitnotEmptyRecord getSelName Contravariant*contravariant-1.5.5-Ahm1naNh6BQEDiMrfTOLxo DivisibledividedWordGHC.ShowShow Data.DynamicDynamic InternalError OriginHeadersimportSemanticsemptyStatusWith cacheWarningtoOriginHeadersoriginHeadersTypeExprnormalizeHeaders#either-5.0.2-DRFdgXBYxCZDnIpIxRBMGYData.Either.Validation ValidationFunctorinteger-wired-inGHC.Integer.Type'text-short-0.1.5-BIkoZbkleox1jgBtISnd7TData.Text.Short.Internal ShortText time-1.9.3&Data.Time.LocalTime.Internal.TimeOfDay TimeOfDayData.Time.Calendar.DaysDay%Data.Time.LocalTime.Internal.TimeZone&Data.Time.LocalTime.Internal.LocalTime LocalTime&Data.Time.LocalTime.Internal.ZonedTime ZonedTime Data.Time.Clock.Internal.UTCTimeUTCTimeData.Time.Calendar.Week DayOfWeekMaybeData.HashSet.InternalHashSetfetchFromHttpUrloriginHeadersFileExpr getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileName Data.Version4optparse-applicative-0.17.0.0-6R71jIJXBDz8NWUkaPEQXtOptions.Applicative.Types ParserInfo