Safe Haskell | None |
---|---|
Language | GHC2021 |
Source-language literals
Synopsis
- module Language.Haskell.Syntax.Lit
- convertLit :: forall (p :: Pass) (p' :: Pass). XXLit (GhcPass p) ~ DataConCantHappen => HsLit (GhcPass p) -> HsLit (GhcPass p')
- hsLitNeedsParens :: forall (x :: Pass). IsPass x => PprPrec -> HsLit (GhcPass x) -> Bool
- hsOverLitNeedsParens :: PprPrec -> HsOverLit x -> Bool
- negateOverLitVal :: OverLitVal -> OverLitVal
- overLitType :: HsOverLit GhcTc -> Type
- pmPprHsLit :: forall (p :: Pass). IsPass p => HsLit (GhcPass p) -> SDoc
- pprXOverLit :: forall (p :: Pass). GhcPass p -> XOverLit (GhcPass p) -> SDoc
- data HsLitTc
- data OverLitRn = OverLitRn {}
- data OverLitTc = OverLitTc {
- ol_rebindable :: Bool
- ol_witness :: HsExpr GhcTc
- ol_type :: Type
Documentation
module Language.Haskell.Syntax.Lit
convertLit :: forall (p :: Pass) (p' :: Pass). XXLit (GhcPass p) ~ DataConCantHappen => HsLit (GhcPass p) -> HsLit (GhcPass p') Source #
Convert a literal from one index type to another. The constraint XXLit (GhcPass p)~DataConCantHappen means that once the XLit constructor is inhabited, we can no longer go back to the case where its not. In practice it just means you can't just convertLit to go from (HsLit GhcTc) -> (HsLit GhcPs/GhcRn), while all other conversions are fine.
hsLitNeedsParens :: forall (x :: Pass). IsPass x => PprPrec -> HsLit (GhcPass x) -> Bool Source #
returns hsLitNeedsParens
p lTrue
if a literal l
needs
to be parenthesized under precedence p
.
See Note [Printing of literals in Core] in GHC.Types.Literal for the reasoning.
hsOverLitNeedsParens :: PprPrec -> HsOverLit x -> Bool Source #
returns hsOverLitNeedsParens
p olTrue
if an overloaded literal
ol
needs to be parenthesized under precedence p
.
pmPprHsLit :: forall (p :: Pass). IsPass p => HsLit (GhcPass p) -> SDoc Source #
pmPprHsLit pretty prints literals and is used when pretty printing pattern match warnings. All are printed the same (i.e., without hashes if they are primitive and not wrapped in constructors if they are boxed). This happens mainly for too reasons: * We do not want to expose their internal representation * The warnings become too messy
HsInteger SourceText Integer Type | Genuinely an integer; arises only from TRANSLATION (overloaded literals are done with HsOverLit) |
HsRat FractionalLit Type | Genuinely a rational; arises only from TRANSLATION (overloaded literals are done with HsOverLit) |
Instances
Data HsLitTc Source # | |
Defined in GHC.Hs.Instances gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsLitTc -> c HsLitTc # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsLitTc # toConstr :: HsLitTc -> Constr # dataTypeOf :: HsLitTc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c HsLitTc) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsLitTc) # gmapT :: (forall b. Data b => b -> b) -> HsLitTc -> HsLitTc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsLitTc -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsLitTc -> r # gmapQ :: (forall d. Data d => d -> u) -> HsLitTc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> HsLitTc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsLitTc -> m HsLitTc # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsLitTc -> m HsLitTc # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsLitTc -> m HsLitTc # | |
Eq HsLitTc Source # | |
Instances
Data OverLitRn Source # | |
Defined in GHC.Hs.Instances gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OverLitRn -> c OverLitRn # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OverLitRn # toConstr :: OverLitRn -> Constr # dataTypeOf :: OverLitRn -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OverLitRn) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OverLitRn) # gmapT :: (forall b. Data b => b -> b) -> OverLitRn -> OverLitRn # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OverLitRn -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OverLitRn -> r # gmapQ :: (forall d. Data d => d -> u) -> OverLitRn -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OverLitRn -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OverLitRn -> m OverLitRn # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitRn -> m OverLitRn # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitRn -> m OverLitRn # |
OverLitTc | |
|
Instances
Data OverLitTc Source # | |
Defined in GHC.Hs.Instances gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> OverLitTc -> c OverLitTc # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c OverLitTc # toConstr :: OverLitTc -> Constr # dataTypeOf :: OverLitTc -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c OverLitTc) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OverLitTc) # gmapT :: (forall b. Data b => b -> b) -> OverLitTc -> OverLitTc # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OverLitTc -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OverLitTc -> r # gmapQ :: (forall d. Data d => d -> u) -> OverLitTc -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> OverLitTc -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> OverLitTc -> m OverLitTc # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitTc -> m OverLitTc # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> OverLitTc -> m OverLitTc # |
Orphan instances
Outputable OverLitVal Source # | |
ppr :: OverLitVal -> SDoc Source # | |
IsPass p => Outputable (HsLit (GhcPass p)) Source # | |
OutputableBndrId p => Outputable (HsOverLit (GhcPass p)) Source # | |
Eq (XXOverLit p) => Eq (HsOverLit p) Source # | |
Ord (XXOverLit p) => Ord (HsOverLit p) Source # | |