| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Spago.Dhall
Synopsis
- format :: MonadIO m => Text -> m ()
- data TemplateComments
- type DhallExpr a = Expr Src a
- prettyWithHeader :: Pretty a => Header -> DhallExpr a -> Text
- processComments :: TemplateComments -> Text -> Text
- stripComments :: Text -> Text
- extractRecordValues :: Map Text (RecordField Src a) -> Map Text (Expr Src a)
- readImports :: Text -> IO [Import]
- readRawExpr :: Text -> IO (Maybe (Header, DhallExpr Import))
- writeRawExpr :: Text -> (Header, DhallExpr Import) -> IO ()
- toTextLit :: Text -> DhallExpr a
- fromTextLit :: Typeable a => DhallExpr a -> Either (ReadError a) Text
- data ReadError a where
- ConfigIsNotRecord :: forall a. Typeable a => DhallExpr a -> ReadError a
- PackagesIsNotRecord :: forall a. Typeable a => DhallExpr a -> ReadError a
- DependenciesIsNotList :: forall a. Typeable a => DhallExpr a -> ReadError a
- ExprIsNotTextLit :: forall a. Typeable a => DhallExpr a -> ReadError a
- CannotParsePackageSet :: forall a. Typeable a => DhallExpr a -> ReadError a
- ImportCannotBeUpdated :: forall a. Typeable a => Import -> ReadError a
- RequiredKeyMissing :: forall a. Typeable a => Text -> Map Text (DhallExpr a) -> ReadError a
- requireKey :: (Typeable b, Pretty b, MonadThrow m) => Map Text (DhallExpr b) -> Text -> (DhallExpr b -> m a) -> m a
- requireTypedKey :: (MonadIO m, MonadThrow m) => Map Text (DhallExpr Void) -> Text -> Decoder a -> m a
- maybeTypedKey :: (MonadIO m, MonadThrow m) => Map Text (DhallExpr Void) -> Text -> Decoder a -> m (Maybe a)
- module Dhall
- data File = File {}
- data Expr s a
- = Const Const
- | Var Var
- | Lam (Maybe CharacterSet) (FunctionBinding s a) (Expr s a)
- | Pi (Maybe CharacterSet) Text (Expr s a) (Expr s a)
- | App (Expr s a) (Expr s a)
- | Let (Binding s a) (Expr s a)
- | Annot (Expr s a) (Expr s a)
- | Bool
- | BoolLit Bool
- | BoolAnd (Expr s a) (Expr s a)
- | BoolOr (Expr s a) (Expr s a)
- | BoolEQ (Expr s a) (Expr s a)
- | BoolNE (Expr s a) (Expr s a)
- | BoolIf (Expr s a) (Expr s a) (Expr s a)
- | Bytes
- | BytesLit ByteString
- | Natural
- | NaturalLit Natural
- | NaturalFold
- | NaturalBuild
- | NaturalIsZero
- | NaturalEven
- | NaturalOdd
- | NaturalToInteger
- | NaturalShow
- | NaturalSubtract
- | NaturalPlus (Expr s a) (Expr s a)
- | NaturalTimes (Expr s a) (Expr s a)
- | Integer
- | IntegerLit Integer
- | IntegerClamp
- | IntegerNegate
- | IntegerShow
- | IntegerToDouble
- | Double
- | DoubleLit DhallDouble
- | DoubleShow
- | Text
- | TextLit (Chunks s a)
- | TextAppend (Expr s a) (Expr s a)
- | TextReplace
- | TextShow
- | Date
- | DateLiteral Day
- | DateShow
- | Time
- | TimeLiteral TimeOfDay Word
- | TimeShow
- | TimeZone
- | TimeZoneLiteral TimeZone
- | TimeZoneShow
- | List
- | ListLit (Maybe (Expr s a)) (Seq (Expr s a))
- | ListAppend (Expr s a) (Expr s a)
- | ListBuild
- | ListFold
- | ListLength
- | ListHead
- | ListLast
- | ListIndexed
- | ListReverse
- | Optional
- | Some (Expr s a)
- | None
- | Record (Map Text (RecordField s a))
- | RecordLit (Map Text (RecordField s a))
- | Union (Map Text (Maybe (Expr s a)))
- | Combine (Maybe CharacterSet) (Maybe Text) (Expr s a) (Expr s a)
- | CombineTypes (Maybe CharacterSet) (Expr s a) (Expr s a)
- | Prefer (Maybe CharacterSet) PreferAnnotation (Expr s a) (Expr s a)
- | RecordCompletion (Expr s a) (Expr s a)
- | Merge (Expr s a) (Expr s a) (Maybe (Expr s a))
- | ToMap (Expr s a) (Maybe (Expr s a))
- | ShowConstructor (Expr s a)
- | Field (Expr s a) (FieldSelection s)
- | Project (Expr s a) (Either [Text] (Expr s a))
- | Assert (Expr s a)
- | Equivalent (Maybe CharacterSet) (Expr s a) (Expr s a)
- | With (Expr s a) (NonEmpty WithComponent) (Expr s a)
- | Note s (Expr s a)
- | ImportAlt (Expr s a) (Expr s a)
- | Embed a
- data Const
- insert :: Pretty a => a -> Doc Ann
- data Binding s a = Binding {
- bindingSrc0 :: Maybe s
- variable :: Text
- bindingSrc1 :: Maybe s
- annotation :: Maybe (Maybe s, Expr s a)
- bindingSrc2 :: Maybe s
- value :: Expr s a
- data ImportMode
- data Input
- newtype Header = Header Text
- normalize :: Eq a => Expr s a -> Expr t a
- shift :: Int -> Var -> Expr s a -> Expr s a
- newtype Directory = Directory {
- components :: [Text]
- internalError :: Text -> forall b. b
- data ImportHashed = ImportHashed {}
- data OutputMode
- data ImportType
- data URL = URL {}
- data Import = Import {}
- data MultiLet s a = MultiLet (NonEmpty (Binding s a)) (Expr s a)
- judgmentallyEqual :: Eq a => Expr s a -> Expr t a -> Bool
- normalizeWith :: Eq a => Maybe (ReifiedNormalizer a) -> Expr s a -> Expr t a
- data Var = V Text !Int
- data WithComponent
- data FieldSelection s = FieldSelection {}
- data PreferAnnotation
- newtype DhallDouble = DhallDouble {}
- makeFieldSelection :: Text -> FieldSelection s
- data Chunks s a = Chunks [(Text, Expr s a)] Text
- data RecordField s a = RecordField {
- recordFieldSrc0 :: Maybe s
- recordFieldValue :: Expr s a
- recordFieldSrc1 :: Maybe s
- recordFieldSrc2 :: Maybe s
- makeRecordField :: Expr s a -> RecordField s a
- recordFieldExprs :: Applicative f => (Expr s a -> f (Expr s b)) -> RecordField s a -> f (RecordField s b)
- data FunctionBinding s a = FunctionBinding {}
- makeFunctionBinding :: Text -> Expr s a -> FunctionBinding s a
- functionBindingExprs :: Applicative f => (Expr s a -> f (Expr s b)) -> FunctionBinding s a -> f (FunctionBinding s b)
- makeBinding :: Text -> Expr s a -> Binding s a
- bindingExprs :: Applicative f => (Expr s a -> f (Expr s b)) -> Binding s a -> f (Binding s b)
- snip :: Text -> Text
- chunkExprs :: Applicative f => (Expr s a -> f (Expr t b)) -> Chunks s a -> f (Chunks t b)
- multiLet :: Binding s a -> Expr s a -> MultiLet s a
- wrapInLets :: Foldable f => f (Binding s a) -> Expr s a -> Expr s a
- subExpressions :: Applicative f => (Expr s a -> f (Expr s a)) -> Expr s a -> f (Expr s a)
- subExpressionsWith :: Applicative f => (a -> f (Expr s b)) -> (Expr s a -> f (Expr s b)) -> Expr s a -> f (Expr s b)
- denote :: Expr s a -> Expr t a
- renote :: Expr Void a -> Expr s a
- shallowDenote :: Expr s a -> Expr s a
- reservedIdentifiers :: HashSet Text
- data Scheme
- data FilePrefix
- pathCharacter :: Char -> Bool
- textShow :: Text -> Text
- newtype ReifiedNormalizer a = ReifiedNormalizer {}
- type Normalizer a = NormalizerM Identity a
- type NormalizerM (m :: Type -> Type) a = forall s. Expr s a -> m (Maybe (Expr s a))
- subst :: Var -> Expr s a -> Expr s a -> Expr s a
- alphaNormalize :: Expr s a -> Expr s a
- normalizeWithM :: (Monad m, Eq a) => NormalizerM m a -> Expr s a -> m (Expr t a)
- isNormalizedWith :: (Eq s, Eq a) => Normalizer a -> Expr s a -> Bool
- isNormalized :: Eq a => Expr s a -> Bool
- freeIn :: Eq a => Var -> Expr s a -> Bool
- escapeText :: Text -> Text
- censorExpression :: Expr Src a -> Expr Src a
- censorText :: Text -> Text
- throws :: (Exception e, MonadIO io) => Either e a -> io a
- data MultipleCheckFailed = MultipleCheckFailed {}
- newtype CheckFailed = CheckFailed Input
- data Output
- data Transitivity
- data Censor
- snipDoc :: Doc Ann -> Doc a
- _ERROR :: IsString string => string
- _WARNING :: IsString string => string
- printWarning :: MonadIO m => String -> m ()
- handleMultipleChecksFailed :: (Foldable t, Traversable t) => Text -> Text -> (a -> IO (Either CheckFailed ())) -> t a -> IO ()
- getExpression :: Censor -> Input -> IO (Expr Src Import)
- getExpressionAndHeader :: Censor -> Input -> IO (Header, Expr Src Import)
- getExpressionAndHeaderFromStdinText :: Censor -> String -> Text -> IO (Header, Expr Src Import)
- renderExpression :: Pretty a => CharacterSet -> Bool -> Maybe FilePath -> Expr Src a -> IO ()
Documentation
format :: MonadIO m => Text -> m () #
Format a Dhall file in ASCII We first check if it's already formatted, if not we reformat it.
data TemplateComments #
Constructors
| WithComments | |
| NoComments |
prettyWithHeader :: Pretty a => Header -> DhallExpr a -> Text #
Prettyprint a Dhall expression adding a comment on top
processComments :: TemplateComments -> Text -> Text #
stripComments :: Text -> Text #
extractRecordValues :: Map Text (RecordField Src a) -> Map Text (Expr Src a) #
readImports :: Text -> IO [Import] #
Return a list of all imports starting from a particular file
fromTextLit :: Typeable a => DhallExpr a -> Either (ReadError a) Text #
Casts a Dhall Text literal to a string, or fails
Spago configuration cannot be read
Constructors
| ConfigIsNotRecord :: forall a. Typeable a => DhallExpr a -> ReadError a | the toplevel value is not a record |
| PackagesIsNotRecord :: forall a. Typeable a => DhallExpr a -> ReadError a | the "packages" key is not a record |
| DependenciesIsNotList :: forall a. Typeable a => DhallExpr a -> ReadError a | the "dependencies" key is not a list |
| ExprIsNotTextLit :: forall a. Typeable a => DhallExpr a -> ReadError a | the expression is not a Text Literal |
| CannotParsePackageSet :: forall a. Typeable a => DhallExpr a -> ReadError a | the packages.dhall could not be parsed |
| ImportCannotBeUpdated :: forall a. Typeable a => Import -> ReadError a | the Import is not pointing to the right repo |
| RequiredKeyMissing :: forall a. Typeable a => Text -> Map Text (DhallExpr a) -> ReadError a | a key is missing from a Dhall map |
Instances
| (Pretty a, Typeable a) => Exception (ReadError a) # | |
Defined in Spago.Dhall Methods toException :: ReadError a -> SomeException # fromException :: SomeException -> Maybe (ReadError a) # displayException :: ReadError a -> String # backtraceDesired :: ReadError a -> Bool # | |
| Pretty a => Show (ReadError a) # | |
requireKey :: (Typeable b, Pretty b, MonadThrow m) => Map Text (DhallExpr b) -> Text -> (DhallExpr b -> m a) -> m a #
Require a key from a Dhall.Map, and run an action on it if found. If not found, return the name of the key.
requireTypedKey :: (MonadIO m, MonadThrow m) => Map Text (DhallExpr Void) -> Text -> Decoder a -> m a #
Same as requireKey, but we give it a Dhall.Decoder to automagically decode from
maybeTypedKey :: (MonadIO m, MonadThrow m) => Map Text (DhallExpr Void) -> Text -> Decoder a -> m (Maybe a) #
Try to find a key from a Dhall.Map, and automagically decode the value with the given Dhall.Type
If not found, return Nothing, if type is incorrect throw error
module Dhall
Instances
| Canonicalize File | |||||
Defined in Dhall.Import Methods canonicalize :: File -> File | |||||
| Semigroup File | |||||
| Data File | |||||
Defined in Dhall.Syntax.Import Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> File -> c File # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c File # dataTypeOf :: File -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c File) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c File) # gmapT :: (forall b. Data b => b -> b) -> File -> File # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> File -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> File -> r # gmapQ :: (forall d. Data d => d -> u) -> File -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> File -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> File -> m File # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> File -> m File # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> File -> m File # | |||||
| Generic File | |||||
Defined in Dhall.Syntax.Import Associated Types
| |||||
| type Rep File | |||||
Defined in Dhall.Syntax.Import type Rep File = D1 ('MetaData "File" "Dhall.Syntax.Import" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) (C1 ('MetaCons "File" 'PrefixI 'True) (S1 ('MetaSel ('Just "directory") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Directory) :*: S1 ('MetaSel ('Just "file") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text))) | |||||
Syntax tree for expressions
The s type parameter is used to track the presence or absence of
Src spans:
- If
s =then the code may containsSrcSrcspans (either in aNoteconstructor or inline within another constructor, likeLet) - If
s =then the code has noVoidSrcspans
The a type parameter is used to track the presence or absence of imports
Constructors
| Const Const | Const c ~ c |
| Var Var | Var (V x 0) ~ x Var (V x n) ~ x@n |
| Lam (Maybe CharacterSet) (FunctionBinding s a) (Expr s a) | Lam _ (FunctionBinding _ "x" _ _ A) b ~ λ(x : A) -> b |
| Pi (Maybe CharacterSet) Text (Expr s a) (Expr s a) | Pi _ "_" A B ~ A -> B Pi _ x A B ~ ∀(x : A) -> B |
| App (Expr s a) (Expr s a) | App f a ~ f a |
| Let (Binding s a) (Expr s a) | Let (Binding _ x _ Nothing _ r) e ~ let x = r in e Let (Binding _ x _ (Just t ) _ r) e ~ let x : t = r in e The difference between let x = a let y = b in e and let x = a in let y = b in e is only an additional See |
| Annot (Expr s a) (Expr s a) | Annot x t ~ x : t |
| Bool | Bool ~ Bool |
| BoolLit Bool | BoolLit b ~ b |
| BoolAnd (Expr s a) (Expr s a) | BoolAnd x y ~ x && y |
| BoolOr (Expr s a) (Expr s a) | BoolOr x y ~ x || y |
| BoolEQ (Expr s a) (Expr s a) | BoolEQ x y ~ x == y |
| BoolNE (Expr s a) (Expr s a) | BoolNE x y ~ x != y |
| BoolIf (Expr s a) (Expr s a) (Expr s a) | BoolIf x y z ~ if x then y else z |
| Bytes | Bytes ~ Bytes |
| BytesLit ByteString | BytesLit "\x00\xFF" ~ 0x"00FF" |
| Natural | Natural ~ Natural |
| NaturalLit Natural | NaturalLit n ~ n |
| NaturalFold | NaturalFold ~ Natural/fold |
| NaturalBuild | NaturalBuild ~ Natural/build |
| NaturalIsZero | NaturalIsZero ~ Natural/isZero |
| NaturalEven | NaturalEven ~ Natural/even |
| NaturalOdd | NaturalOdd ~ Natural/odd |
| NaturalToInteger | NaturalToInteger ~ Natural/toInteger |
| NaturalShow | NaturalShow ~ Natural/show |
| NaturalSubtract | NaturalSubtract ~ Natural/subtract |
| NaturalPlus (Expr s a) (Expr s a) | NaturalPlus x y ~ x + y |
| NaturalTimes (Expr s a) (Expr s a) | NaturalTimes x y ~ x * y |
| Integer | Integer ~ Integer |
| IntegerLit Integer | IntegerLit n ~ ±n |
| IntegerClamp | IntegerClamp ~ Integer/clamp |
| IntegerNegate | IntegerNegate ~ Integer/negate |
| IntegerShow | IntegerShow ~ Integer/show |
| IntegerToDouble | IntegerToDouble ~ Integer/toDouble |
| Double | Double ~ Double |
| DoubleLit DhallDouble | DoubleLit n ~ n |
| DoubleShow | DoubleShow ~ Double/show |
| Text | Text ~ Text |
| TextLit (Chunks s a) | TextLit (Chunks [(t1, e1), (t2, e2)] t3) ~ "t1${e1}t2${e2}t3" |
| TextAppend (Expr s a) (Expr s a) | TextAppend x y ~ x ++ y |
| TextReplace | TextReplace ~ Text/replace |
| TextShow | TextShow ~ Text/show |
| Date | Date ~ Date |
| DateLiteral Day | DateLiteral (fromGregorian _YYYY _MM _DD) ~ YYYY-MM-DD |
| DateShow | DateShow ~ Date/show |
| Time | Time ~ Time |
| TimeLiteral | TimeLiteral (TimeOfDay hh mm ss) _ ~ hh:mm:ss |
| TimeShow | |
| TimeZone | TimeZone ~ TimeZone |
| TimeZoneLiteral TimeZone | TimeZoneLiteral (TimeZone ( 60 * _HH + _MM) _ _) ~ +HH:MM | > TimeZoneLiteral (TimeZone (-60 * _HH + _MM) _ _) ~ -HH:MM |
| TimeZoneShow | TimeZoneShow ~ TimeZone/Show |
| List | List ~ List |
| ListLit (Maybe (Expr s a)) (Seq (Expr s a)) | ListLit (Just t ) [] ~ [] : t ListLit Nothing [x, y, z] ~ [x, y, z] Invariant: A non-empty list literal is always represented as
When an annotated, non-empty list literal is parsed, it is represented as Annot (ListLit Nothing [x, y, z]) t ~ [x, y, z] : t |
| ListAppend (Expr s a) (Expr s a) | ListAppend x y ~ x # y |
| ListBuild | ListBuild ~ List/build |
| ListFold | ListFold ~ List/fold |
| ListLength | ListLength ~ List/length |
| ListHead | ListHead ~ List/head |
| ListLast | ListLast ~ List/last |
| ListIndexed | ListIndexed ~ List/indexed |
| ListReverse | ListReverse ~ List/reverse |
| Optional | Optional ~ Optional |
| Some (Expr s a) | Some e ~ Some e |
| None | None ~ None |
| Record (Map Text (RecordField s a)) | Record [ (k1, RecordField _ t1) ~ { k1 : t1, k2 : t1 }
, (k2, RecordField _ t2)
] |
| RecordLit (Map Text (RecordField s a)) | RecordLit [ (k1, RecordField _ v1) ~ { k1 = v1, k2 = v2 }
, (k2, RecordField _ v2)
] |
| Union (Map Text (Maybe (Expr s a))) | Union [(k1, Just t1), (k2, Nothing)] ~ < k1 : t1 | k2 > |
| Combine (Maybe CharacterSet) (Maybe Text) (Expr s a) (Expr s a) | Combine _ Nothing x y ~ x ∧ y The first field is a RecordLit [ ( k ~ { k = x, k = y }
, RecordField
_
(Combine (Just k) x y)
)] |
| CombineTypes (Maybe CharacterSet) (Expr s a) (Expr s a) | CombineTypes _ x y ~ x ⩓ y |
| Prefer (Maybe CharacterSet) PreferAnnotation (Expr s a) (Expr s a) | Prefer _ _ x y ~ x ⫽ y |
| RecordCompletion (Expr s a) (Expr s a) | RecordCompletion x y ~ x::y |
| Merge (Expr s a) (Expr s a) (Maybe (Expr s a)) | Merge x y (Just t ) ~ merge x y : t Merge x y Nothing ~ merge x y |
| ToMap (Expr s a) (Maybe (Expr s a)) | ToMap x (Just t) ~ toMap x : t ToMap x Nothing ~ toMap x |
| ShowConstructor (Expr s a) | ShowConstructor x ~ showConstructor x |
| Field (Expr s a) (FieldSelection s) | Field e (FieldSelection _ x _) ~ e.x |
| Project (Expr s a) (Either [Text] (Expr s a)) | Project e (Left xs) ~ e.{ xs }
Project e (Right t) ~ e.(t) |
| Assert (Expr s a) | Assert e ~ assert : e |
| Equivalent (Maybe CharacterSet) (Expr s a) (Expr s a) | Equivalent _ x y ~ x ≡ y |
| With (Expr s a) (NonEmpty WithComponent) (Expr s a) | With x y e ~ x with y = e |
| Note s (Expr s a) | Note s x ~ e |
| ImportAlt (Expr s a) (Expr s a) | ImportAlt ~ e1 ? e2 |
| Embed a | Embed import ~ import |
Instances
Constants for a pure type system
The axioms are:
⊦ Type : Kind ⊦ Kind : Sort
... and the valid rule pairs are:
⊦ Type ↝ Type : Type -- Functions from terms to terms (ordinary functions) ⊦ Kind ↝ Type : Type -- Functions from types to terms (type-polymorphic functions) ⊦ Sort ↝ Type : Type -- Functions from kinds to terms ⊦ Kind ↝ Kind : Kind -- Functions from types to types (type-level functions) ⊦ Sort ↝ Kind : Sort -- Functions from kinds to types (kind-polymorphic functions) ⊦ Sort ↝ Sort : Sort -- Functions from kinds to kinds (kind-level functions)
Note that Dhall does not support functions from terms to types and therefore Dhall is not a dependently typed language
Instances
| Bounded Const | |||||
| Enum Const | |||||
Defined in Dhall.Syntax.Const | |||||
| Generic Const | |||||
Defined in Dhall.Syntax.Const Associated Types
| |||||
| type Rep Const | |||||
Defined in Dhall.Syntax.Const | |||||
Record the binding part of a let expression.
For example,
let {- A -} x {- B -} : {- C -} Bool = {- D -} True in x… will be instantiated as follows:
bindingSrc0corresponds to theAcomment.variableis"x"bindingSrc1corresponds to theBcomment.annotationisJusta pair, corresponding to theCcomment andBool.bindingSrc2corresponds to theDcomment.valuecorresponds toTrue.
Constructors
| Binding | |
Fields
| |
Instances
| Generic (Binding s a) | |||||
Defined in Dhall.Syntax.Binding Associated Types
| |||||
| type Rep (Binding s a) | |||||
Defined in Dhall.Syntax.Binding type Rep (Binding s a) = D1 ('MetaData "Binding" "Dhall.Syntax.Binding" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) (C1 ('MetaCons "Binding" 'PrefixI 'True) ((S1 ('MetaSel ('Just "bindingSrc0") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe s)) :*: (S1 ('MetaSel ('Just "variable") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text) :*: S1 ('MetaSel ('Just "bindingSrc1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe s)))) :*: (S1 ('MetaSel ('Just "annotation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Maybe s, Expr s a))) :*: (S1 ('MetaSel ('Just "bindingSrc2") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe s)) :*: S1 ('MetaSel ('Just "value") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Expr s a)))))) | |||||
data ImportMode #
How to interpret the import's contents (i.e. as Dhall code or raw text)
Instances
| Data ImportMode | |||||
Defined in Dhall.Syntax.Import Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportMode -> c ImportMode # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImportMode # toConstr :: ImportMode -> Constr # dataTypeOf :: ImportMode -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImportMode) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportMode) # gmapT :: (forall b. Data b => b -> b) -> ImportMode -> ImportMode # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportMode -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportMode -> r # gmapQ :: (forall d. Data d => d -> u) -> ImportMode -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportMode -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportMode -> m ImportMode # | |||||
| Generic ImportMode | |||||
Defined in Dhall.Syntax.Import Associated Types
| |||||
| type Rep ImportMode | |||||
Defined in Dhall.Syntax.Import type Rep ImportMode = D1 ('MetaData "ImportMode" "Dhall.Syntax.Import" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) ((C1 ('MetaCons "Code" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RawText" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Location" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "RawBytes" 'PrefixI 'False) (U1 :: Type -> Type))) | |||||
Path to input
Constructors
| StandardInput | |
| InputFile FilePath |
A header corresponds to the leading comment at the top of a Dhall file.
The header includes comment characters but is stripped of leading spaces and trailing newlines
normalize :: Eq a => Expr s a -> Expr t a #
Reduce an expression to its normal form, performing beta reduction
normalize 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.
normalize can also fail with error if you normalize an ill-typed
expression
shift :: Int -> Var -> Expr s a -> Expr s a #
shift is used by both normalization and type-checking to avoid variable
capture by shifting variable indices
For example, suppose that you were to normalize the following expression:
λ(a : Type) → λ(x : a) → (λ(y : a) → λ(x : a) → y) x
If you were to substitute y with x without shifting any variable
indices, then you would get the following incorrect result:
λ(a : Type) → λ(x : a) → λ(x : a) → x -- Incorrect normalized form
In order to substitute x in place of y we need to shift x by 1 in
order to avoid being misinterpreted as the x bound by the innermost
lambda. If we perform that shift then we get the correct result:
λ(a : Type) → λ(x : a) → λ(x : a) → x@1
As a more worked example, suppose that you were to normalize the following expression:
λ(a : Type) → λ(f : a → a → a) → λ(x : a) → λ(x : a) → (λ(x : a) → f x x@1) x@1
The correct normalized result would be:
λ(a : Type) → λ(f : a → a → a) → λ(x : a) → λ(x : a) → f x@1 x
The 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@1tox@2before 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 lessxvariable 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
1to avoid variable capture during substitution - decrement variables by
1when deleting lambdas after substitution
n 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.
Internal representation of a directory that stores the path components in reverse order
In other words, the directory /foo/bar/baz is encoded as
Directory { components = [ "baz", "bar", "foo" ] }
Constructors
| Directory | |
Fields
| |
Instances
| Canonicalize Directory |
| ||||
Defined in Dhall.Import Methods canonicalize :: Directory -> Directory | |||||
| Semigroup Directory | |||||
| Data Directory | |||||
Defined in Dhall.Syntax.Import Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Directory -> c Directory # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Directory # toConstr :: Directory -> Constr # dataTypeOf :: Directory -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Directory) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Directory) # gmapT :: (forall b. Data b => b -> b) -> Directory -> Directory # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Directory -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Directory -> r # gmapQ :: (forall d. Data d => d -> u) -> Directory -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Directory -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Directory -> m Directory # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Directory -> m Directory # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Directory -> m Directory # | |||||
| Generic Directory | |||||
Defined in Dhall.Syntax.Import Associated Types
| |||||
| type Rep Directory | |||||
Defined in Dhall.Syntax.Import | |||||
internalError :: Text -> forall b. b #
Utility function used to throw internal errors that should never happen (in theory) but that are not enforced by the type system
data ImportHashed #
A ImportType extended with an optional hash for semantic integrity checks
Constructors
| ImportHashed | |
Fields | |
Instances
| Canonicalize ImportHashed | |||||
Defined in Dhall.Import Methods | |||||
| Semigroup ImportHashed | |||||
Defined in Dhall.Syntax.Import Methods (<>) :: ImportHashed -> ImportHashed -> ImportHashed # sconcat :: NonEmpty ImportHashed -> ImportHashed # stimes :: Integral b => b -> ImportHashed -> ImportHashed # | |||||
| Data ImportHashed | |||||
Defined in Dhall.Syntax.Import Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportHashed -> c ImportHashed # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImportHashed # toConstr :: ImportHashed -> Constr # dataTypeOf :: ImportHashed -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImportHashed) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportHashed) # gmapT :: (forall b. Data b => b -> b) -> ImportHashed -> ImportHashed # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportHashed -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportHashed -> r # gmapQ :: (forall d. Data d => d -> u) -> ImportHashed -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportHashed -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportHashed -> m ImportHashed # | |||||
| Generic ImportHashed | |||||
Defined in Dhall.Syntax.Import Associated Types
| |||||
| type Rep ImportHashed | |||||
Defined in Dhall.Syntax.Import type Rep ImportHashed = D1 ('MetaData "ImportHashed" "Dhall.Syntax.Import" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) (C1 ('MetaCons "ImportHashed" 'PrefixI 'True) (S1 ('MetaSel ('Just "hash") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SHA256Digest)) :*: S1 ('MetaSel ('Just "importType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ImportType))) | |||||
data OutputMode #
data ImportType #
The type of import (i.e. local vs. remote vs. environment)
Constructors
| Local FilePrefix File | Local path |
| Remote URL | URL of remote resource and optional headers stored in an import |
| Env Text | Environment variable |
| Missing |
Instances
| Canonicalize ImportType | |||||
Defined in Dhall.Import Methods canonicalize :: ImportType -> ImportType | |||||
| Semigroup ImportType | |||||
Defined in Dhall.Syntax.Import Methods (<>) :: ImportType -> ImportType -> ImportType # sconcat :: NonEmpty ImportType -> ImportType # stimes :: Integral b => b -> ImportType -> ImportType # | |||||
| Data ImportType | |||||
Defined in Dhall.Syntax.Import Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportType -> c ImportType # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImportType # toConstr :: ImportType -> Constr # dataTypeOf :: ImportType -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImportType) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportType) # gmapT :: (forall b. Data b => b -> b) -> ImportType -> ImportType # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportType -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportType -> r # gmapQ :: (forall d. Data d => d -> u) -> ImportType -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportType -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportType -> m ImportType # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportType -> m ImportType # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportType -> m ImportType # | |||||
| Generic ImportType | |||||
Defined in Dhall.Syntax.Import Associated Types
| |||||
| type Rep ImportType | |||||
Defined in Dhall.Syntax.Import type Rep ImportType = D1 ('MetaData "ImportType" "Dhall.Syntax.Import" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) ((C1 ('MetaCons "Local" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FilePrefix) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 File)) :+: C1 ('MetaCons "Remote" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 URL))) :+: (C1 ('MetaCons "Env" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)) :+: C1 ('MetaCons "Missing" 'PrefixI 'False) (U1 :: Type -> Type))) | |||||
This type stores all of the components of a remote import
Constructors
| URL | |
Instances
| Data URL | |||||
Defined in Dhall.Syntax.Import Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> URL -> c URL # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c URL # dataTypeOf :: URL -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c URL) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URL) # gmapT :: (forall b. Data b => b -> b) -> URL -> URL # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r # gmapQ :: (forall d. Data d => d -> u) -> URL -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> URL -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> URL -> m URL # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> URL -> m URL # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> URL -> m URL # | |||||
| Generic URL | |||||
Defined in Dhall.Syntax.Import Associated Types
| |||||
| type Rep URL | |||||
Defined in Dhall.Syntax.Import type Rep URL = D1 ('MetaData "URL" "Dhall.Syntax.Import" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) (C1 ('MetaCons "URL" 'PrefixI 'True) ((S1 ('MetaSel ('Just "scheme") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Scheme) :*: S1 ('MetaSel ('Just "authority") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)) :*: (S1 ('MetaSel ('Just "path") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 File) :*: (S1 ('MetaSel ('Just "query") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Text)) :*: S1 ('MetaSel ('Just "headers") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe (Expr Src Import))))))) | |||||
Reference to an external resource
Constructors
| Import | |
Fields | |
Instances
| Canonicalize Import | |||||
Defined in Dhall.Import Methods canonicalize :: Import -> Import | |||||
| Semigroup Import | |||||
| Data Import | |||||
Defined in Dhall.Syntax.Import Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Import -> c Import # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Import # toConstr :: Import -> Constr # dataTypeOf :: Import -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Import) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Import) # gmapT :: (forall b. Data b => b -> b) -> Import -> Import # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Import -> r # gmapQ :: (forall d. Data d => d -> u) -> Import -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Import -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Import -> m Import # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Import -> m Import # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Import -> m Import # | |||||
| Generic Import | |||||
Defined in Dhall.Syntax.Import Associated Types
| |||||
| type Rep Import | |||||
Defined in Dhall.Syntax.Import type Rep Import = D1 ('MetaData "Import" "Dhall.Syntax.Import" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) (C1 ('MetaCons "Import" 'PrefixI 'True) (S1 ('MetaSel ('Just "importHashed") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ImportHashed) :*: S1 ('MetaSel ('Just "importMode") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ImportMode))) | |||||
This type represents 1 or more nested Let bindings that have been
coalesced together for ease of manipulation
judgmentallyEqual :: Eq a => Expr s a -> Expr t a -> Bool #
Returns True if two expressions are α-equivalent and β-equivalent and
False otherwise
judgmentallyEqual can fail with an error if you compare ill-typed
expressions
normalizeWith :: Eq a => Maybe (ReifiedNormalizer a) -> Expr s a -> Expr t a #
Reduce an expression to its normal form, performing beta reduction and applying any custom definitions.
normalizeWith is designed to be used with function typeWith. The typeWith
function allows typing of Dhall functions in a custom typing context whereas
normalizeWith allows evaluating Dhall expressions in a custom context.
To be more precise normalizeWith 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.
normalizeWith can fail with an error if you normalize an ill-typed
expression
Label for a bound variable
The Text field is the variable's name (i.e. "x").
The Int 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:
┌──refers to──┐
│ │
v │
λ(x : Type) → λ(y : Type) → λ(x : Type) → x@0
┌─────────────────refers to─────────────────┐
│ │
v │
λ(x : Type) → λ(y : Type) → λ(x : Type) → x@1This Int behaves like a De Bruijn index in the special case where all
variables have the same name.
You can optionally omit the index if it is 0:
┌─refers to─┐
│ │
v │
λ(x : Type) → λ(y : Type) → λ(x : Type) → xZero indices are omitted when pretty-printing Vars and non-zero indices
appear as a numeric suffix.
Instances
| IsString Var | |||||
Defined in Dhall.Syntax.Var Methods fromString :: String -> Var # | |||||
| Generic Var | |||||
Defined in Dhall.Syntax.Var Associated Types
| |||||
| type Rep Var | |||||
Defined in Dhall.Syntax.Var type Rep Var = D1 ('MetaData "Var" "Dhall.Syntax.Var" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) (C1 ('MetaCons "V" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'SourceStrict 'DecidedUnpack) (Rec0 Int))) | |||||
data WithComponent #
A path component for a with expression
Constructors
| WithLabel Text | |
| WithQuestion |
Instances
| Generic WithComponent | |||||
Defined in Dhall.Syntax.Types Associated Types
| |||||
| type Rep WithComponent | |||||
Defined in Dhall.Syntax.Types type Rep WithComponent = D1 ('MetaData "WithComponent" "Dhall.Syntax.Types" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) (C1 ('MetaCons "WithLabel" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)) :+: C1 ('MetaCons "WithQuestion" 'PrefixI 'False) (U1 :: Type -> Type)) | |||||
data FieldSelection s #
Record the field on a selector-expression
For example,
e . {- A -} x {- B -}… will be instantiated as follows:
fieldSelectionSrc0corresponds to theAcommentfieldSelectionLabelcorresponds toxfieldSelectionSrc1corresponds to theBcomment
Given our limitation that not all expressions recover their whitespaces, the
purpose of fieldSelectionSrc1 is to save the SourcePos
where the fieldSelectionLabel ends, but we still use a
'Maybe Dhall.Src.Src' (s = ) to be consistent with similar
data types such as SrcBinding, for example.
Constructors
| FieldSelection | |
Fields
| |
Instances
| Generic (FieldSelection s) | |||||
Defined in Dhall.Syntax.Types Associated Types
Methods from :: FieldSelection s -> Rep (FieldSelection s) x # to :: Rep (FieldSelection s) x -> FieldSelection s # | |||||
| type Rep (FieldSelection s) | |||||
Defined in Dhall.Syntax.Types type Rep (FieldSelection s) = D1 ('MetaData "FieldSelection" "Dhall.Syntax.Types" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) (C1 ('MetaCons "FieldSelection" 'PrefixI 'True) (S1 ('MetaSel ('Just "fieldSelectionSrc0") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe s)) :*: (S1 ('MetaSel ('Just "fieldSelectionLabel") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 Text) :*: S1 ('MetaSel ('Just "fieldSelectionSrc1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe s))))) | |||||
data PreferAnnotation #
Used to record the origin of a // operator (i.e. from source code or a
product of desugaring)
Constructors
| PreferFromSource | |
| PreferFromCompletion |
Instances
| Generic PreferAnnotation | |||||
Defined in Dhall.Syntax.Types Associated Types
Methods from :: PreferAnnotation -> Rep PreferAnnotation x # to :: Rep PreferAnnotation x -> PreferAnnotation # | |||||
| type Rep PreferAnnotation | |||||
Defined in Dhall.Syntax.Types | |||||
newtype DhallDouble #
This wrapper around Double exists for its Eq instance which is
defined via the binary encoding of Dhall Doubles.
Constructors
| DhallDouble | |
Fields | |
Instances
| Generic DhallDouble | |||||
Defined in Dhall.Syntax.Types Associated Types
| |||||
| type Rep DhallDouble | |||||
Defined in Dhall.Syntax.Types type Rep DhallDouble = D1 ('MetaData "DhallDouble" "Dhall.Syntax.Types" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'True) (C1 ('MetaCons "DhallDouble" 'PrefixI 'True) (S1 ('MetaSel ('Just "getDhallDouble") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Double))) | |||||
makeFieldSelection :: Text -> FieldSelection s #
Smart constructor for FieldSelection with no src information
The body of an interpolated Text literal
Instances
| Monoid (Chunks s a) | |||||
| Semigroup (Chunks s a) | |||||
| IsString (Chunks s a) | |||||
Defined in Dhall.Syntax.Chunks Methods fromString :: String -> Chunks s a # | |||||
| Generic (Chunks s a) | |||||
Defined in Dhall.Syntax.Chunks Associated Types
| |||||
| type Rep (Chunks s a) | |||||
Defined in Dhall.Syntax.Chunks type Rep (Chunks s a) = D1 ('MetaData "Chunks" "Dhall.Syntax.Chunks" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) (C1 ('MetaCons "Chunks" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [(Text, Expr s a)]) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text))) | |||||
data RecordField s a #
Record 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:
recordFieldSrc0corresponds to theAcomment.recordFieldValueisTrecordFieldSrc1corresponds to theBcomment.recordFieldSrc2corresponds to theCcomment.
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 Nothing when the RecordField is for
a punned entry, because there is no = sign. For example,
{ {- A -} x {- B -} }will be instantiated as follows:
recordFieldSrc0corresponds to theAcomment.recordFieldValuecorresponds to(Var "x")recordFieldSrc1corresponds to theBcomment.recordFieldSrc2will beNothing
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
aandbfield,recordfieldSrc2isNothing - For the
afield: recordFieldSrc0corresponds to theAcommentrecordFieldSrc1corresponds to theBcomment- For the
bfield: recordFieldSrc0corresponds to theCcommentrecordFieldSrc1corresponds to theDcomment- For the
cfield: recordFieldSrc0corresponds to theEcommentrecordFieldSrc1corresponds to theFcommentrecordFieldSrc2corresponds to theGcomment
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 Nothing. For the last keyword, all
srcs are Just
Constructors
| RecordField | |
Fields
| |
Instances
| Generic (RecordField s a) | |||||
Defined in Dhall.Syntax.RecordField Associated Types
Methods from :: RecordField s a -> Rep (RecordField s a) x # to :: Rep (RecordField s a) x -> RecordField s a # | |||||
| type Rep (RecordField s a) | |||||
Defined in Dhall.Syntax.RecordField type Rep (RecordField s a) = D1 ('MetaData "RecordField" "Dhall.Syntax.RecordField" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) (C1 ('MetaCons "RecordField" 'PrefixI 'True) ((S1 ('MetaSel ('Just "recordFieldSrc0") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe s)) :*: S1 ('MetaSel ('Just "recordFieldValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Expr s a))) :*: (S1 ('MetaSel ('Just "recordFieldSrc1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe s)) :*: S1 ('MetaSel ('Just "recordFieldSrc2") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe s))))) | |||||
makeRecordField :: Expr s a -> RecordField s a #
Construct a RecordField with no src information
recordFieldExprs :: Applicative f => (Expr s a -> f (Expr s b)) -> RecordField s a -> f (RecordField s b) #
Traverse over the immediate Expr children in a RecordField.
data FunctionBinding s a #
Record the label of a function or a function-type expression
For example,
λ({- A -} a {- B -} : {- C -} T) -> e… will be instantiated as follows:
functionBindingSrc0corresponds to theAcommentfunctionBindingVariableisafunctionBindingSrc1corresponds to theBcommentfunctionBindingSrc2corresponds to theCcommentfunctionBindingAnnotationisT
Constructors
| FunctionBinding | |
Fields
| |
Instances
| Generic (FunctionBinding s a) | |||||
Defined in Dhall.Syntax.FunctionBinding Associated Types
Methods from :: FunctionBinding s a -> Rep (FunctionBinding s a) x # to :: Rep (FunctionBinding s a) x -> FunctionBinding s a # | |||||
| type Rep (FunctionBinding s a) | |||||
Defined in Dhall.Syntax.FunctionBinding type Rep (FunctionBinding s a) = D1 ('MetaData "FunctionBinding" "Dhall.Syntax.FunctionBinding" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) (C1 ('MetaCons "FunctionBinding" 'PrefixI 'True) ((S1 ('MetaSel ('Just "functionBindingSrc0") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe s)) :*: S1 ('MetaSel ('Just "functionBindingVariable") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Text)) :*: (S1 ('MetaSel ('Just "functionBindingSrc1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe s)) :*: (S1 ('MetaSel ('Just "functionBindingSrc2") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe s)) :*: S1 ('MetaSel ('Just "functionBindingAnnotation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Expr s a)))))) | |||||
makeFunctionBinding :: Text -> Expr s a -> FunctionBinding s a #
Smart constructor for FunctionBinding with no src information
functionBindingExprs :: Applicative f => (Expr s a -> f (Expr s b)) -> FunctionBinding s a -> f (FunctionBinding s b) #
Traverse over the immediate Expr children in a FunctionBinding.
makeBinding :: Text -> Expr s a -> Binding s a #
Construct a Binding with no source information and no type annotation.
bindingExprs :: Applicative f => (Expr s a -> f (Expr s b)) -> Binding s a -> f (Binding s b) #
chunkExprs :: Applicative f => (Expr s a -> f (Expr t b)) -> Chunks s a -> f (Chunks t b) #
A traversal over the immediate sub-expressions in Chunks.
wrapInLets :: Foldable f => f (Binding s a) -> Expr s a -> Expr s a #
Wrap let-Bindings around an Expr.
wrapInLets can be understood as an inverse for multiLet:
let MultiLet bs e1 = multiLet b e0 wrapInLets bs e1 == Let b e0
subExpressions :: Applicative f => (Expr s a -> f (Expr s a)) -> Expr s a -> f (Expr s a) #
A traversal over the immediate sub-expressions of an expression.
subExpressionsWith :: Applicative f => (a -> f (Expr s b)) -> (Expr s a -> f (Expr s b)) -> Expr s a -> f (Expr s b) #
A traversal over the immediate sub-expressions of an expression which allows mapping embedded values
shallowDenote :: Expr s a -> Expr s a #
reservedIdentifiers :: HashSet Text #
The set of reserved identifiers for the Dhall language | Contains also all keywords from "reservedKeywords"
The URI scheme
Instances
| Data Scheme | |
Defined in Dhall.Syntax.Import Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Scheme -> c Scheme # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Scheme # toConstr :: Scheme -> Constr # dataTypeOf :: Scheme -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Scheme) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Scheme) # gmapT :: (forall b. Data b => b -> b) -> Scheme -> Scheme # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Scheme -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Scheme -> r # gmapQ :: (forall d. Data d => d -> u) -> Scheme -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Scheme -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Scheme -> m Scheme # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Scheme -> m Scheme # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Scheme -> m Scheme # | |
| Generic Scheme | |
Defined in Dhall.Syntax.Import | |
| type Rep Scheme | |
data FilePrefix #
The beginning of a file path which anchors subsequent path components
Constructors
| Absolute | Absolute path |
| Here | Path relative to |
| Parent | Path relative to |
| Home | Path relative to |
Instances
| Data FilePrefix | |||||
Defined in Dhall.Syntax.Import Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FilePrefix -> c FilePrefix # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FilePrefix # toConstr :: FilePrefix -> Constr # dataTypeOf :: FilePrefix -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FilePrefix) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FilePrefix) # gmapT :: (forall b. Data b => b -> b) -> FilePrefix -> FilePrefix # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FilePrefix -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FilePrefix -> r # gmapQ :: (forall d. Data d => d -> u) -> FilePrefix -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FilePrefix -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FilePrefix -> m FilePrefix # | |||||
| Generic FilePrefix | |||||
Defined in Dhall.Syntax.Import Associated Types
| |||||
| type Rep FilePrefix | |||||
Defined in Dhall.Syntax.Import type Rep FilePrefix = D1 ('MetaData "FilePrefix" "Dhall.Syntax.Import" "dhall-1.42.2-AALQHV4FhMB9Vlk0NyXwcC" 'False) ((C1 ('MetaCons "Absolute" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Here" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "Parent" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Home" 'PrefixI 'False) (U1 :: Type -> Type))) | |||||
pathCharacter :: Char -> Bool #
Returns True if the given Char is valid within an unquoted path
component
This is exported for reuse within the Dhall.Parser.Token module
newtype ReifiedNormalizer a #
A reified Normalizer, which can be stored in structures without
running into impredicative polymorphism.
Constructors
| ReifiedNormalizer | |
Fields | |
type Normalizer a = NormalizerM Identity a #
An variation on NormalizerM for pure normalizers
type NormalizerM (m :: Type -> Type) a = forall s. Expr s a -> m (Maybe (Expr s a)) #
Use this to wrap you embedded functions (see normalizeWith) to make them
polymorphic enough to be used.
subst :: Var -> Expr s a -> Expr s a -> Expr s a #
Substitute all occurrences of a variable with an expression
subst x C B ~ B[x := C]
alphaNormalize :: Expr s a -> Expr s a #
α-normalize an expression by renaming all bound variables to "_" and
using De Bruijn indices to distinguish them
>>>mfb = Syntax.makeFunctionBinding>>>alphaNormalize (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)
normalizeWithM :: (Monad m, Eq a) => NormalizerM m a -> Expr s a -> m (Expr t a) #
This function generalizes normalizeWith by allowing the custom normalizer
to use an arbitrary Monad
normalizeWithM can fail with an error if you normalize an ill-typed
expression
isNormalizedWith :: (Eq s, Eq a) => Normalizer a -> Expr s a -> Bool #
Check if an expression is in a normal form given a context of evaluation.
Unlike isNormalized, this will fully normalize and traverse through the expression.
It is much more efficient to use isNormalized.
isNormalizedWith can fail with an error if you check an ill-typed
expression
isNormalized :: Eq a => Expr s a -> Bool #
Quickly check if an expression is in normal form
Given a well-typed expression e, is equivalent to
isNormalized ee == .normalize e
Given an ill-typed expression, isNormalized may fail with an error, or
evaluate to either False or True!
freeIn :: Eq a => Var -> Expr s a -> Bool #
Detect 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
escapeText :: Text -> Text #
Escape a Text literal using Dhall's escaping rules
Note that the result does not include surrounding quotes
censorText :: Text -> Text #
Utility used to censor Text by replacing all characters with a
space
data MultipleCheckFailed #
Exception thrown when the --check flag to a command-line subcommand fails
Instances
| Exception MultipleCheckFailed | |
Defined in Dhall.Util | |
| Show MultipleCheckFailed | |
Defined in Dhall.Util Methods showsPrec :: Int -> MultipleCheckFailed -> ShowS # show :: MultipleCheckFailed -> String # showList :: [MultipleCheckFailed] -> ShowS # | |
newtype CheckFailed #
A check failure corresponding to a single input.
This type is intended to be used with MultipleCheckFailed for error
reporting.
Constructors
| CheckFailed Input |
data Transitivity #
Specifies whether or not an input's transitive dependencies should also be processed. Transitive dependencies are restricted to relative file imports.
Constructors
| NonTransitive | Do not process transitive dependencies |
| Transitive | Process transitive dependencies in the same way |
Set to Censor if you want to censor error text that might include secrets
printWarning :: MonadIO m => String -> m () #
Output a warning message on stderr.
handleMultipleChecksFailed :: (Foldable t, Traversable t) => Text -> Text -> (a -> IO (Either CheckFailed ())) -> t a -> IO () #
Run IO for multiple inputs, then collate all the check failures before throwing if there was any failure
getExpression :: Censor -> Input -> IO (Expr Src Import) #
Convenient utility for retrieving an expression
getExpressionAndHeader :: Censor -> Input -> IO (Header, Expr Src Import) #
Convenient utility for retrieving an expression along with its header
getExpressionAndHeaderFromStdinText :: Censor -> String -> Text -> IO (Header, Expr Src Import) #
Convenient utility for retrieving an expression along with its header from | text already read from STDIN (so it's not re-read)
renderExpression :: Pretty a => CharacterSet -> Bool -> Maybe FilePath -> Expr Src a -> IO () #
Convenient utility to output an expression either to a file or to stdout.