Safe Haskell	None
Language	Haskell98

Language.LBNF.Compiletime

Contents

Happy and Alex
Pretty printing
Quasi quoting
- Helper functions for defining Anti-quotation

Description

Contains things needed by BNFC-meta language definitions and by the code generated from those. Typical users don't need to browse this module.

Synopsis

Happy and Alex

data HappyStk a :: * -> * infixr 9 #

Constructors

HappyStk a (HappyStk a) infixr 9

utf8Encode :: Char -> [Word8] Source #

data Posn Source #

Constructors

Pn !Int !Int !Int

Instances

Eq Posn Source #
Methods (==) :: Posn -> Posn -> Bool # (/=) :: Posn -> Posn -> Bool #
Ord Posn Source #
Methods compare :: Posn -> Posn -> Ordering # (<) :: Posn -> Posn -> Bool # (<=) :: Posn -> Posn -> Bool # (>) :: Posn -> Posn -> Bool # (>=) :: Posn -> Posn -> Bool # max :: Posn -> Posn -> Posn # min :: Posn -> Posn -> Posn #
Show Posn Source #
Methods showsPrec :: Int -> Posn -> ShowS # show :: Posn -> String # showList :: [Posn] -> ShowS #

type AlexInput = (Posn, Char, [Word8], String) Source #

alexGetByte :: AlexInput -> Maybe (Word8, AlexInput) Source #

ord :: Char -> Int #

The fromEnum method restricted to the type Char.

listArray :: Ix i => (i, i) -> [e] -> Array i e #

Construct an array from a pair of bounds and a list of values in index order.

(!) :: Ix i => Array i e -> i -> e infixl 9 #

The value at the given index in an array.

data Array i e :: * -> * -> * #

The type of immutable non-strict (boxed) arrays with indices in i and elements in e.

Instances

Functor (Array i)
Methods fmap :: (a -> b) -> Array i a -> Array i b # (<$) :: a -> Array i b -> Array i a #
Foldable (Array i)
Methods fold :: Monoid m => Array i m -> m # foldMap :: Monoid m => (a -> m) -> Array i a -> m # foldr :: (a -> b -> b) -> b -> Array i a -> b # foldr' :: (a -> b -> b) -> b -> Array i a -> b # foldl :: (b -> a -> b) -> b -> Array i a -> b # foldl' :: (b -> a -> b) -> b -> Array i a -> b # foldr1 :: (a -> a -> a) -> Array i a -> a # foldl1 :: (a -> a -> a) -> Array i a -> a # toList :: Array i a -> [a] # null :: Array i a -> Bool # length :: Array i a -> Int # elem :: Eq a => a -> Array i a -> Bool # maximum :: Ord a => Array i a -> a # minimum :: Ord a => Array i a -> a # sum :: Num a => Array i a -> a # product :: Num a => Array i a -> a #
Ix i => Traversable (Array i)
Methods traverse :: Applicative f => (a -> f b) -> Array i a -> f (Array i b) # sequenceA :: Applicative f => Array i (f a) -> f (Array i a) # mapM :: Monad m => (a -> m b) -> Array i a -> m (Array i b) # sequence :: Monad m => Array i (m a) -> m (Array i a) #
(Ix i, Eq e) => Eq (Array i e)
Methods (==) :: Array i e -> Array i e -> Bool # (/=) :: Array i e -> Array i e -> Bool #
(Data a, Data b, Ix a) => Data (Array a b)
Methods gfoldl :: (forall d c. Data d => c (d -> c) -> d -> c c) -> (forall g. g -> c g) -> Array a b -> c (Array a b) # gunfold :: (forall c r. Data c => c (c -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Array a b) # toConstr :: Array a b -> Constr # dataTypeOf :: Array a b -> DataType # dataCast1 :: Typeable (* -> ) t => (forall d. Data d => c (t d)) -> Maybe (c (Array a b)) # dataCast2 :: Typeable ( -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Array a b)) # gmapT :: (forall c. Data c => c -> c) -> Array a b -> Array a b # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Array a b -> r # gmapQ :: (forall d. Data d => d -> u) -> Array a b -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Array a b -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Array a b -> m (Array a b) #
(Ix i, Ord e) => Ord (Array i e)
Methods compare :: Array i e -> Array i e -> Ordering # (<) :: Array i e -> Array i e -> Bool # (<=) :: Array i e -> Array i e -> Bool # (>) :: Array i e -> Array i e -> Bool # (>=) :: Array i e -> Array i e -> Bool # max :: Array i e -> Array i e -> Array i e # min :: Array i e -> Array i e -> Array i e #
(Ix a, Read a, Read b) => Read (Array a b)
Methods readsPrec :: Int -> ReadS (Array a b) # readList :: ReadS [Array a b] # readPrec :: ReadPrec (Array a b) # readListPrec :: ReadPrec [Array a b] #
(Ix a, Show a, Show b) => Show (Array a b)
Methods showsPrec :: Int -> Array a b -> ShowS # show :: Array a b -> String # showList :: [Array a b] -> ShowS #

Pretty printing

printTree :: Print a => a -> String Source #

doc :: ShowS -> Doc Source #

concatD :: [Doc] -> Doc Source #

class Print a where Source #

Minimal complete definition

prt

Methods

prt :: Int -> a -> Doc Source #

prtList :: [a] -> Doc Source #

Instances

Print Char Source #
Methods prt :: Int -> Char -> Doc Source # prtList :: [Char] -> Doc Source #
Print Double Source #
Methods prt :: Int -> Double -> Doc Source # prtList :: [Double] -> Doc Source #
Print Integer Source #
Methods prt :: Int -> Integer -> Doc Source # prtList :: [Integer] -> Doc Source #
Print PrintPlain Source #
Methods prt :: Int -> PrintPlain -> Doc Source # prtList :: [PrintPlain] -> Doc Source #
Print Ident Source #
Methods prt :: Int -> Ident -> Doc Source # prtList :: [Ident] -> Doc Source #
Print Reg Source #
Methods prt :: Int -> Reg -> Doc Source # prtList :: [Reg] -> Doc Source #
Print MinimumSize Source #
Methods prt :: Int -> MinimumSize -> Doc Source # prtList :: [MinimumSize] -> Doc Source #
Print Exp Source #
Methods prt :: Int -> Exp -> Doc Source # prtList :: [Exp] -> Doc Source #
Print Arg Source #
Methods prt :: Int -> Arg -> Doc Source # prtList :: [Arg] -> Doc Source #
Print HsTyp Source #
Methods prt :: Int -> HsTyp -> Doc Source # prtList :: [HsTyp] -> Doc Source #
Print MIdent Source #
Methods prt :: Int -> MIdent -> Doc Source # prtList :: [MIdent] -> Doc Source #
Print Label Source #
Methods prt :: Int -> Label -> Doc Source # prtList :: [Label] -> Doc Source #
Print Cat Source #
Methods prt :: Int -> Cat -> Doc Source # prtList :: [Cat] -> Doc Source #
Print Item Source #
Methods prt :: Int -> Item -> Doc Source # prtList :: [Item] -> Doc Source #
Print RHS Source #
Methods prt :: Int -> RHS -> Doc Source # prtList :: [RHS] -> Doc Source #
Print Def Source #
Methods prt :: Int -> Def -> Doc Source # prtList :: [Def] -> Doc Source #
Print Grammar Source #
Methods prt :: Int -> Grammar -> Doc Source # prtList :: [Grammar] -> Doc Source #
Print a => Print [a] Source #
Methods prt :: Int -> [a] -> Doc Source # prtList :: [[a]] -> Doc Source #

prPrec :: Int -> Int -> Doc -> Doc Source #

newtype PrintPlain Source #

Constructors

MkPrintPlain String

Instances

Print PrintPlain Source #
Methods prt :: Int -> PrintPlain -> Doc Source # prtList :: [PrintPlain] -> Doc Source #

Quasi quoting

parseToQuoter :: (String -> ParseMonad BNFC_QQType) -> QuasiQuoter Source #

parseToMonQuoter :: (String -> ParseMonad BNFC_QQType) -> QuasiQuoter Source #

data ParseMonad a Source #

Constructors

Ok a
Bad String

Instances

Monad ParseMonad Source #
Methods (>>=) :: ParseMonad a -> (a -> ParseMonad b) -> ParseMonad b # (>>) :: ParseMonad a -> ParseMonad b -> ParseMonad b # return :: a -> ParseMonad a # fail :: String -> ParseMonad a #
Functor ParseMonad Source #
Methods fmap :: (a -> b) -> ParseMonad a -> ParseMonad b # (<$) :: a -> ParseMonad b -> ParseMonad a #
Applicative ParseMonad Source #
Methods pure :: a -> ParseMonad a # (<>) :: ParseMonad (a -> b) -> ParseMonad a -> ParseMonad b # (>) :: ParseMonad a -> ParseMonad b -> ParseMonad b # (<*) :: ParseMonad a -> ParseMonad b -> ParseMonad a #
Eq a => Eq (ParseMonad a) Source #
Methods (==) :: ParseMonad a -> ParseMonad a -> Bool # (/=) :: ParseMonad a -> ParseMonad a -> Bool #
Ord a => Ord (ParseMonad a) Source #
Methods compare :: ParseMonad a -> ParseMonad a -> Ordering # (<) :: ParseMonad a -> ParseMonad a -> Bool # (<=) :: ParseMonad a -> ParseMonad a -> Bool # (>) :: ParseMonad a -> ParseMonad a -> Bool # (>=) :: ParseMonad a -> ParseMonad a -> Bool # max :: ParseMonad a -> ParseMonad a -> ParseMonad a # min :: ParseMonad a -> ParseMonad a -> ParseMonad a #
Read a => Read (ParseMonad a) Source #
Methods readsPrec :: Int -> ReadS (ParseMonad a) # readList :: ReadS [ParseMonad a] # readPrec :: ReadPrec (ParseMonad a) # readListPrec :: ReadPrec [ParseMonad a] #
Show a => Show (ParseMonad a) Source #
Methods showsPrec :: Int -> ParseMonad a -> ShowS # show :: ParseMonad a -> String # showList :: [ParseMonad a] -> ShowS #

errq :: (String -> a) -> ParseMonad a -> Q a Source #

data Q a :: * -> * #

Instances

Monad Q
Methods (>>=) :: Q a -> (a -> Q b) -> Q b # (>>) :: Q a -> Q b -> Q b # return :: a -> Q a # fail :: String -> Q a #
Functor Q
Methods fmap :: (a -> b) -> Q a -> Q b # (<$) :: a -> Q b -> Q a #
MonadFail Q
Methods fail :: String -> Q a #
Applicative Q
Methods pure :: a -> Q a # (<>) :: Q (a -> b) -> Q a -> Q b # (>) :: Q a -> Q b -> Q b # (<*) :: Q a -> Q b -> Q a #
Quasi Q
Methods qNewName :: String -> Q Name # qReport :: Bool -> String -> Q () # qRecover :: Q a -> Q a -> Q a # qLookupName :: Bool -> String -> Q (Maybe Name) # qReify :: Name -> Q Info # qReifyFixity :: Name -> Q (Maybe Fixity) # qReifyInstances :: Name -> [Type] -> Q [Dec] # qReifyRoles :: Name -> Q [Role] # qReifyAnnotations :: Data a => AnnLookup -> Q [a] # qReifyModule :: Module -> Q ModuleInfo # qReifyConStrictness :: Name -> Q [DecidedStrictness] # qLocation :: Q Loc # qRunIO :: IO a -> Q a # qAddDependentFile :: FilePath -> Q () # qAddTopDecls :: [Dec] -> Q () # qAddModFinalizer :: Q () -> Q () # qGetQ :: Typeable * a => Q (Maybe a) # qPutQ :: Typeable * a => a -> Q () # qIsExtEnabled :: Extension -> Q Bool # qExtsEnabled :: Q [Extension] #

data BNFC_QQType Source #

Constructors

QQApp (String, LocType) [BNFC_QQType]
QQAq (Q Exp, Q Pat)
QQList [BNFC_QQType]
QQLit Lit
QQPosT (Int, Int) (String, LocType) String

appEPAll :: LocType -> String -> [BNFC_QQType] -> BNFC_QQType Source #

appEPAllL :: LocType -> [BNFC_QQType] -> BNFC_QQType Source #

fromString :: Literal a => LocType -> a -> BNFC_QQType Source #

fromLit :: Literal a => LocType -> a -> BNFC_QQType Source #

fromToken :: Literal a => LocType -> String -> a -> BNFC_QQType Source #

fromPositionToken :: LocType -> String -> ((Int, Int), String) -> BNFC_QQType Source #

class Lift t where #

A Lift instance can have any of its values turned into a Template Haskell expression. This is needed when a value used within a Template Haskell quotation is bound outside the Oxford brackets ([| ... |]) but not at the top level. As an example:

add1 :: Int -> Q Exp
add1 x = [| x + 1 |]

Template Haskell has no way of knowing what value x will take on at splice-time, so it requires the type of x to be an instance of Lift.

Lift instances can be derived automatically by use of the -XDeriveLift GHC language extension:

{-# LANGUAGE DeriveLift #-}
module Foo where

import Language.Haskell.TH.Syntax

data Bar a = Bar1 a (Bar a) | Bar2 String
  deriving Lift

Methods

lift :: t -> Q Exp #

Turn a value into a Template Haskell expression, suitable for use in a splice.

Instances

Lift Bool
Methods lift :: Bool -> Q Exp #
Lift Char
Methods lift :: Char -> Q Exp #
Lift Double
Methods lift :: Double -> Q Exp #
Lift Float
Methods lift :: Float -> Q Exp #
Lift Int
Methods lift :: Int -> Q Exp #
Lift Int8
Methods lift :: Int8 -> Q Exp #
Lift Int16
Methods lift :: Int16 -> Q Exp #
Lift Int32
Methods lift :: Int32 -> Q Exp #
Lift Int64
Methods lift :: Int64 -> Q Exp #
Lift Integer
Methods lift :: Integer -> Q Exp #
Lift Word
Methods lift :: Word -> Q Exp #
Lift Word8
Methods lift :: Word8 -> Q Exp #
Lift Word16
Methods lift :: Word16 -> Q Exp #
Lift Word32
Methods lift :: Word32 -> Q Exp #
Lift Word64
Methods lift :: Word64 -> Q Exp #
Lift ()
Methods lift :: () -> Q Exp #
Lift Natural
Methods lift :: Natural -> Q Exp #
Lift a => Lift [a]
Methods lift :: [a] -> Q Exp #
Lift a => Lift (Maybe a)
Methods lift :: Maybe a -> Q Exp #
Integral a => Lift (Ratio a)
Methods lift :: Ratio a -> Q Exp #
(Lift a, Lift b) => Lift (Either a b)
Methods lift :: Either a b -> Q Exp #
(Lift a, Lift b) => Lift (a, b)
Methods lift :: (a, b) -> Q Exp #
(Lift a, Lift b, Lift c) => Lift (a, b, c)
Methods lift :: (a, b, c) -> Q Exp #
(Lift a, Lift b, Lift c, Lift d) => Lift (a, b, c, d)
Methods lift :: (a, b, c, d) -> Q Exp #
(Lift a, Lift b, Lift c, Lift d, Lift e) => Lift (a, b, c, d, e)
Methods lift :: (a, b, c, d, e) -> Q Exp #
(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f) => Lift (a, b, c, d, e, f)
Methods lift :: (a, b, c, d, e, f) -> Q Exp #
(Lift a, Lift b, Lift c, Lift d, Lift e, Lift f, Lift g) => Lift (a, b, c, d, e, f, g)
Methods lift :: (a, b, c, d, e, f, g) -> Q Exp #

type LocType = (String, String) Source #

class Literal a where Source #

Minimal complete definition

lit

Methods

lit :: a -> Lit Source #

Instances

Literal Char Source #
Methods lit :: Char -> Lit Source #
Literal Double Source #
Methods lit :: Double -> Lit Source #
Literal Integer Source #
Methods lit :: Integer -> Lit Source #
IsChar a => Literal [a] Source #
Methods lit :: [a] -> Lit Source #

class IsChar a where Source #

Minimal complete definition

toChar

Methods

toChar :: a -> Char Source #

Instances

IsChar Char Source #
Methods toChar :: Char -> Char Source #

Helper functions for defining Anti-quotation

printAq :: Print a => a -> BNFC_QQType Source #

stringAq :: String -> BNFC_QQType Source #