Language.LBNF.Compiletime

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

Happy and Alex

data HappyStk a :: * -> * infixr 9

Constructors

HappyStk a (HappyStk a) infixr 9

utf8Encode :: Char -> [Word8]

data Posn

Constructors

Pn !Int !Int !Int

Instances

Eq Posn

Methods

(==) :: Posn -> Posn -> Bool

(/=) :: Posn -> Posn -> Bool

Ord Posn

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

Methods

showsPrec :: Int -> Posn -> ShowS

show :: Posn -> String

showList :: [Posn] -> ShowS

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

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

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

doc :: ShowS -> Doc

concatD :: [Doc] -> Doc

class Print a where

Minimal complete definition

prt

Methods

prt :: Int -> a -> Doc

prtList :: [a] -> Doc

Instances

Print Char

Methods

prt :: Int -> Char -> Doc

prtList :: [Char] -> Doc

Print Double

Methods

prt :: Int -> Double -> Doc

prtList :: [Double] -> Doc

Print Integer

Methods

prt :: Int -> Integer -> Doc

prtList :: [Integer] -> Doc

Print PrintPlain

Methods

prt :: Int -> PrintPlain -> Doc

prtList :: [PrintPlain] -> Doc

Print Ident

Methods

prt :: Int -> Ident -> Doc

prtList :: [Ident] -> Doc

Print Reg

Methods

prt :: Int -> Reg -> Doc

prtList :: [Reg] -> Doc

Print MinimumSize

Methods

prt :: Int -> MinimumSize -> Doc

prtList :: [MinimumSize] -> Doc

Print Exp

Methods

prt :: Int -> Exp -> Doc

prtList :: [Exp] -> Doc

Print Arg

Methods

prt :: Int -> Arg -> Doc

prtList :: [Arg] -> Doc

Print HsTyp

Methods

prt :: Int -> HsTyp -> Doc

prtList :: [HsTyp] -> Doc

Print MIdent

Methods

prt :: Int -> MIdent -> Doc

prtList :: [MIdent] -> Doc

Print Label

Methods

prt :: Int -> Label -> Doc

prtList :: [Label] -> Doc

Print Cat

Methods

prt :: Int -> Cat -> Doc

prtList :: [Cat] -> Doc

Print Item

Methods

prt :: Int -> Item -> Doc

prtList :: [Item] -> Doc

Print RHS

Methods

prt :: Int -> RHS -> Doc

prtList :: [RHS] -> Doc

Print Def

Methods

prt :: Int -> Def -> Doc

prtList :: [Def] -> Doc

Print Grammar

Methods

prt :: Int -> Grammar -> Doc

prtList :: [Grammar] -> Doc

Print a => Print [a]

Methods

prt :: Int -> [a] -> Doc

prtList :: [[a]] -> Doc

prPrec :: Int -> Int -> Doc -> Doc

newtype PrintPlain

Constructors

MkPrintPlain String

Instances

Print PrintPlain

Methods

prt :: Int -> PrintPlain -> Doc

prtList :: [PrintPlain] -> Doc

Quasi quoting

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

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

data ParseMonad a

Constructors

Ok a

Bad String

Instances

Monad ParseMonad

Methods

(>>=) :: ParseMonad a -> (a -> ParseMonad b) -> ParseMonad b

(>>) :: ParseMonad a -> ParseMonad b -> ParseMonad b

return :: a -> ParseMonad a

fail :: String -> ParseMonad a

Functor ParseMonad

Methods

fmap :: (a -> b) -> ParseMonad a -> ParseMonad b

(<$) :: a -> ParseMonad b -> ParseMonad a

Applicative ParseMonad

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)

Methods

(==) :: ParseMonad a -> ParseMonad a -> Bool

(/=) :: ParseMonad a -> ParseMonad a -> Bool

Ord a => Ord (ParseMonad a)

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)

Methods

readsPrec :: Int -> ReadS (ParseMonad a)

readList :: ReadS [ParseMonad a]

readPrec :: ReadPrec (ParseMonad a)

readListPrec :: ReadPrec [ParseMonad a]

Show a => Show (ParseMonad a)

Methods

showsPrec :: Int -> ParseMonad a -> ShowS

show :: ParseMonad a -> String

showList :: [ParseMonad a] -> ShowS

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

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

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

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

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

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

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

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

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)

class Literal a where

Minimal complete definition

lit

Methods

lit :: a -> Lit

Instances

Literal Char

Methods

lit :: Char -> Lit

Literal Double

Methods

lit :: Double -> Lit

Literal Integer

Methods

lit :: Integer -> Lit

IsChar a => Literal [a]

Methods

lit :: [a] -> Lit

class IsChar a where

Minimal complete definition

toChar

Methods

toChar :: a -> Char

Instances

IsChar Char

Methods

toChar :: Char -> Char

Helper functions for defining Anti-quotation

printAq :: Print a => a -> BNFC_QQType

stringAq :: String -> BNFC_QQType