BNFC.Abs

The abstract syntax of language BNFC.

Documentation

type Grammar = Grammar' BNFC'Position

data Grammar' a

Constructors

Grammar a [Def' a]

Instances

Functor Grammar'

Defined in BNFC.Abs

Methods

fmap :: (a -> b) -> Grammar' a -> Grammar' b

(<$) :: a -> Grammar' b -> Grammar' a

Foldable Grammar'

Defined in BNFC.Abs

Methods

fold :: Monoid m => Grammar' m -> m

foldMap :: Monoid m => (a -> m) -> Grammar' a -> m

foldMap' :: Monoid m => (a -> m) -> Grammar' a -> m

foldr :: (a -> b -> b) -> b -> Grammar' a -> b

foldr' :: (a -> b -> b) -> b -> Grammar' a -> b

foldl :: (b -> a -> b) -> b -> Grammar' a -> b

foldl' :: (b -> a -> b) -> b -> Grammar' a -> b

foldr1 :: (a -> a -> a) -> Grammar' a -> a

foldl1 :: (a -> a -> a) -> Grammar' a -> a

toList :: Grammar' a -> [a]

null :: Grammar' a -> Bool

length :: Grammar' a -> Int

elem :: Eq a => a -> Grammar' a -> Bool

maximum :: Ord a => Grammar' a -> a

minimum :: Ord a => Grammar' a -> a

sum :: Num a => Grammar' a -> a

product :: Num a => Grammar' a -> a

Traversable Grammar'

Defined in BNFC.Abs

Methods

traverse :: Applicative f => (a -> f b) -> Grammar' a -> f (Grammar' b)

sequenceA :: Applicative f => Grammar' (f a) -> f (Grammar' a)

mapM :: Monad m => (a -> m b) -> Grammar' a -> m (Grammar' b)

sequence :: Monad m => Grammar' (m a) -> m (Grammar' a)

HasPosition Grammar

Defined in BNFC.Abs

Methods

hasPosition :: Grammar -> BNFC'Position

Eq a => Eq (Grammar' a)

Defined in BNFC.Abs

Methods

(==) :: Grammar' a -> Grammar' a -> Bool

(/=) :: Grammar' a -> Grammar' a -> Bool

Ord a => Ord (Grammar' a)

Defined in BNFC.Abs

Methods

compare :: Grammar' a -> Grammar' a -> Ordering

(<) :: Grammar' a -> Grammar' a -> Bool

(<=) :: Grammar' a -> Grammar' a -> Bool

(>) :: Grammar' a -> Grammar' a -> Bool

(>=) :: Grammar' a -> Grammar' a -> Bool

max :: Grammar' a -> Grammar' a -> Grammar' a

min :: Grammar' a -> Grammar' a -> Grammar' a

Read a => Read (Grammar' a)

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS (Grammar' a)

readList :: ReadS [Grammar' a]

readPrec :: ReadPrec (Grammar' a)

readListPrec :: ReadPrec [Grammar' a]

Show a => Show (Grammar' a)

Defined in BNFC.Abs

Methods

showsPrec :: Int -> Grammar' a -> ShowS

show :: Grammar' a -> String

showList :: [Grammar' a] -> ShowS

Print (Grammar' a)

Defined in BNFC.Print

Methods

prt :: Int -> Grammar' a -> Doc

type Def = Def' BNFC'Position

data Def' a

Constructors

Rule a (Label' a) (Cat' a) (RHS' a)

Comment a String

Comments a String String

Internal a (Label' a) (Cat' a) (RHS' a)

Token a Identifier (Reg' a)

PosToken a Identifier (Reg' a)

Entryp a [Cat' a]

Separator a (MinimumSize' a) (Cat' a) String

Terminator a (MinimumSize' a) (Cat' a) String

Delimiters a (Cat' a) String String (Separation' a) (MinimumSize' a)

Coercions a Identifier Integer

Rules a Identifier [RHS' a]

Function a Identifier [Arg' a] (Exp' a)

Layout a [String]

LayoutStop a [String]

LayoutTop a

Instances

Functor Def'

Defined in BNFC.Abs

Methods

fmap :: (a -> b) -> Def' a -> Def' b

(<$) :: a -> Def' b -> Def' a

Foldable Def'

Defined in BNFC.Abs

Methods

fold :: Monoid m => Def' m -> m

foldMap :: Monoid m => (a -> m) -> Def' a -> m

foldMap' :: Monoid m => (a -> m) -> Def' a -> m

foldr :: (a -> b -> b) -> b -> Def' a -> b

foldr' :: (a -> b -> b) -> b -> Def' a -> b

foldl :: (b -> a -> b) -> b -> Def' a -> b

foldl' :: (b -> a -> b) -> b -> Def' a -> b

foldr1 :: (a -> a -> a) -> Def' a -> a

foldl1 :: (a -> a -> a) -> Def' a -> a

toList :: Def' a -> [a]

null :: Def' a -> Bool

length :: Def' a -> Int

elem :: Eq a => a -> Def' a -> Bool

maximum :: Ord a => Def' a -> a

minimum :: Ord a => Def' a -> a

sum :: Num a => Def' a -> a

product :: Num a => Def' a -> a

Traversable Def'

Defined in BNFC.Abs

Methods

traverse :: Applicative f => (a -> f b) -> Def' a -> f (Def' b)

sequenceA :: Applicative f => Def' (f a) -> f (Def' a)

mapM :: Monad m => (a -> m b) -> Def' a -> m (Def' b)

sequence :: Monad m => Def' (m a) -> m (Def' a)

HasPosition Def

Defined in BNFC.Abs

Methods

hasPosition :: Def -> BNFC'Position

Eq a => Eq (Def' a)

Defined in BNFC.Abs

Methods

(==) :: Def' a -> Def' a -> Bool

(/=) :: Def' a -> Def' a -> Bool

Ord a => Ord (Def' a)

Defined in BNFC.Abs

Methods

compare :: Def' a -> Def' a -> Ordering

(<) :: Def' a -> Def' a -> Bool

(<=) :: Def' a -> Def' a -> Bool

(>) :: Def' a -> Def' a -> Bool

(>=) :: Def' a -> Def' a -> Bool

max :: Def' a -> Def' a -> Def' a

min :: Def' a -> Def' a -> Def' a

Read a => Read (Def' a)

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS (Def' a)

readList :: ReadS [Def' a]

readPrec :: ReadPrec (Def' a)

readListPrec :: ReadPrec [Def' a]

Show a => Show (Def' a)

Defined in BNFC.Abs

Methods

showsPrec :: Int -> Def' a -> ShowS

show :: Def' a -> String

showList :: [Def' a] -> ShowS

Print [Def' a]

Defined in BNFC.Print

Methods

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

Print (Def' a)

Defined in BNFC.Print

Methods

prt :: Int -> Def' a -> Doc

type Item = Item' BNFC'Position

data Item' a

Constructors

Terminal a String

NTerminal a (Cat' a)

Instances

Functor Item'

Defined in BNFC.Abs

Methods

fmap :: (a -> b) -> Item' a -> Item' b

(<$) :: a -> Item' b -> Item' a

Foldable Item'

Defined in BNFC.Abs

Methods

fold :: Monoid m => Item' m -> m

foldMap :: Monoid m => (a -> m) -> Item' a -> m

foldMap' :: Monoid m => (a -> m) -> Item' a -> m

foldr :: (a -> b -> b) -> b -> Item' a -> b

foldr' :: (a -> b -> b) -> b -> Item' a -> b

foldl :: (b -> a -> b) -> b -> Item' a -> b

foldl' :: (b -> a -> b) -> b -> Item' a -> b

foldr1 :: (a -> a -> a) -> Item' a -> a

foldl1 :: (a -> a -> a) -> Item' a -> a

toList :: Item' a -> [a]

null :: Item' a -> Bool

length :: Item' a -> Int

elem :: Eq a => a -> Item' a -> Bool

maximum :: Ord a => Item' a -> a

minimum :: Ord a => Item' a -> a

sum :: Num a => Item' a -> a

product :: Num a => Item' a -> a

Traversable Item'

Defined in BNFC.Abs

Methods

traverse :: Applicative f => (a -> f b) -> Item' a -> f (Item' b)

sequenceA :: Applicative f => Item' (f a) -> f (Item' a)

mapM :: Monad m => (a -> m b) -> Item' a -> m (Item' b)

sequence :: Monad m => Item' (m a) -> m (Item' a)

HasPosition Item

Defined in BNFC.Abs

Methods

hasPosition :: Item -> BNFC'Position

AddKeywords Item

Defined in BNFC.Check.Pass1

Methods

addKeywords :: Item -> M ()

AddCategories Item

Defined in BNFC.Check.Pass1

Methods

addCategories :: Item -> ReaderT Parseable M ()

Eq a => Eq (Item' a)

Defined in BNFC.Abs

Methods

(==) :: Item' a -> Item' a -> Bool

(/=) :: Item' a -> Item' a -> Bool

Ord a => Ord (Item' a)

Defined in BNFC.Abs

Methods

compare :: Item' a -> Item' a -> Ordering

(<) :: Item' a -> Item' a -> Bool

(<=) :: Item' a -> Item' a -> Bool

(>) :: Item' a -> Item' a -> Bool

(>=) :: Item' a -> Item' a -> Bool

max :: Item' a -> Item' a -> Item' a

min :: Item' a -> Item' a -> Item' a

Read a => Read (Item' a)

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS (Item' a)

readList :: ReadS [Item' a]

readPrec :: ReadPrec (Item' a)

readListPrec :: ReadPrec [Item' a]

Show a => Show (Item' a)

Defined in BNFC.Abs

Methods

showsPrec :: Int -> Item' a -> ShowS

show :: Item' a -> String

showList :: [Item' a] -> ShowS

Print [Item' a]

Defined in BNFC.Print

Methods

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

Print (Item' a)

Defined in BNFC.Print

Methods

prt :: Int -> Item' a -> Doc

type Cat = Cat' BNFC'Position

data Cat' a

Constructors

ListCat a (Cat' a)

IdCat a Identifier

Instances

Functor Cat'

Defined in BNFC.Abs

Methods

fmap :: (a -> b) -> Cat' a -> Cat' b

(<$) :: a -> Cat' b -> Cat' a

Foldable Cat'

Defined in BNFC.Abs

Methods

fold :: Monoid m => Cat' m -> m

foldMap :: Monoid m => (a -> m) -> Cat' a -> m

foldMap' :: Monoid m => (a -> m) -> Cat' a -> m

foldr :: (a -> b -> b) -> b -> Cat' a -> b

foldr' :: (a -> b -> b) -> b -> Cat' a -> b

foldl :: (b -> a -> b) -> b -> Cat' a -> b

foldl' :: (b -> a -> b) -> b -> Cat' a -> b

foldr1 :: (a -> a -> a) -> Cat' a -> a

foldl1 :: (a -> a -> a) -> Cat' a -> a

toList :: Cat' a -> [a]

null :: Cat' a -> Bool

length :: Cat' a -> Int

elem :: Eq a => a -> Cat' a -> Bool

maximum :: Ord a => Cat' a -> a

minimum :: Ord a => Cat' a -> a

sum :: Num a => Cat' a -> a

product :: Num a => Cat' a -> a

Traversable Cat'

Defined in BNFC.Abs

Methods

traverse :: Applicative f => (a -> f b) -> Cat' a -> f (Cat' b)

sequenceA :: Applicative f => Cat' (f a) -> f (Cat' a)

mapM :: Monad m => (a -> m b) -> Cat' a -> m (Cat' b)

sequence :: Monad m => Cat' (m a) -> m (Cat' a)

HasPosition Cat

Defined in BNFC.Abs

Methods

hasPosition :: Cat -> BNFC'Position

AddCategories Cat

Also adds for each list category its element category, transitively.

Defined in BNFC.Check.Pass1

Methods

addCategories :: Cat -> ReaderT Parseable M ()

Eq a => Eq (Cat' a)

Defined in BNFC.Abs

Methods

(==) :: Cat' a -> Cat' a -> Bool

(/=) :: Cat' a -> Cat' a -> Bool

Ord a => Ord (Cat' a)

Defined in BNFC.Abs

Methods

compare :: Cat' a -> Cat' a -> Ordering

(<) :: Cat' a -> Cat' a -> Bool

(<=) :: Cat' a -> Cat' a -> Bool

(>) :: Cat' a -> Cat' a -> Bool

(>=) :: Cat' a -> Cat' a -> Bool

max :: Cat' a -> Cat' a -> Cat' a

min :: Cat' a -> Cat' a -> Cat' a

Read a => Read (Cat' a)

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS (Cat' a)

readList :: ReadS [Cat' a]

readPrec :: ReadPrec (Cat' a)

readListPrec :: ReadPrec [Cat' a]

Show a => Show (Cat' a)

Defined in BNFC.Abs

Methods

showsPrec :: Int -> Cat' a -> ShowS

show :: Cat' a -> String

showList :: [Cat' a] -> ShowS

Print [Cat' a]

Defined in BNFC.Print

Methods

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

Print (Cat' a)

Defined in BNFC.Print

Methods

prt :: Int -> Cat' a -> Doc

type Label = Label' BNFC'Position

data Label' a

Constructors

Id a Identifier

Wild a

ListEmpty a

ListCons a

ListOne a

Instances

Functor Label'

Defined in BNFC.Abs

Methods

fmap :: (a -> b) -> Label' a -> Label' b

(<$) :: a -> Label' b -> Label' a

Foldable Label'

Defined in BNFC.Abs

Methods

fold :: Monoid m => Label' m -> m

foldMap :: Monoid m => (a -> m) -> Label' a -> m

foldMap' :: Monoid m => (a -> m) -> Label' a -> m

foldr :: (a -> b -> b) -> b -> Label' a -> b

foldr' :: (a -> b -> b) -> b -> Label' a -> b

foldl :: (b -> a -> b) -> b -> Label' a -> b

foldl' :: (b -> a -> b) -> b -> Label' a -> b

foldr1 :: (a -> a -> a) -> Label' a -> a

foldl1 :: (a -> a -> a) -> Label' a -> a

toList :: Label' a -> [a]

null :: Label' a -> Bool

length :: Label' a -> Int

elem :: Eq a => a -> Label' a -> Bool

maximum :: Ord a => Label' a -> a

minimum :: Ord a => Label' a -> a

sum :: Num a => Label' a -> a

product :: Num a => Label' a -> a

Traversable Label'

Defined in BNFC.Abs

Methods

traverse :: Applicative f => (a -> f b) -> Label' a -> f (Label' b)

sequenceA :: Applicative f => Label' (f a) -> f (Label' a)

mapM :: Monad m => (a -> m b) -> Label' a -> m (Label' b)

sequence :: Monad m => Label' (m a) -> m (Label' a)

HasPosition Label

Defined in BNFC.Abs

Methods

hasPosition :: Label -> BNFC'Position

Eq a => Eq (Label' a)

Defined in BNFC.Abs

Methods

(==) :: Label' a -> Label' a -> Bool

(/=) :: Label' a -> Label' a -> Bool

Ord a => Ord (Label' a)

Defined in BNFC.Abs

Methods

compare :: Label' a -> Label' a -> Ordering

(<) :: Label' a -> Label' a -> Bool

(<=) :: Label' a -> Label' a -> Bool

(>) :: Label' a -> Label' a -> Bool

(>=) :: Label' a -> Label' a -> Bool

max :: Label' a -> Label' a -> Label' a

min :: Label' a -> Label' a -> Label' a

Read a => Read (Label' a)

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS (Label' a)

readList :: ReadS [Label' a]

readPrec :: ReadPrec (Label' a)

readListPrec :: ReadPrec [Label' a]

Show a => Show (Label' a)

Defined in BNFC.Abs

Methods

showsPrec :: Int -> Label' a -> ShowS

show :: Label' a -> String

showList :: [Label' a] -> ShowS

Print (Label' a)

Defined in BNFC.Print

Methods

prt :: Int -> Label' a -> Doc

type Arg = Arg' BNFC'Position

data Arg' a

Constructors

Arg a Identifier

Instances

Functor Arg'

Defined in BNFC.Abs

Methods

fmap :: (a -> b) -> Arg' a -> Arg' b

(<$) :: a -> Arg' b -> Arg' a

Foldable Arg'

Defined in BNFC.Abs

Methods

fold :: Monoid m => Arg' m -> m

foldMap :: Monoid m => (a -> m) -> Arg' a -> m

foldMap' :: Monoid m => (a -> m) -> Arg' a -> m

foldr :: (a -> b -> b) -> b -> Arg' a -> b

foldr' :: (a -> b -> b) -> b -> Arg' a -> b

foldl :: (b -> a -> b) -> b -> Arg' a -> b

foldl' :: (b -> a -> b) -> b -> Arg' a -> b

foldr1 :: (a -> a -> a) -> Arg' a -> a

foldl1 :: (a -> a -> a) -> Arg' a -> a

toList :: Arg' a -> [a]

null :: Arg' a -> Bool

length :: Arg' a -> Int

elem :: Eq a => a -> Arg' a -> Bool

maximum :: Ord a => Arg' a -> a

minimum :: Ord a => Arg' a -> a

sum :: Num a => Arg' a -> a

product :: Num a => Arg' a -> a

Traversable Arg'

Defined in BNFC.Abs

Methods

traverse :: Applicative f => (a -> f b) -> Arg' a -> f (Arg' b)

sequenceA :: Applicative f => Arg' (f a) -> f (Arg' a)

mapM :: Monad m => (a -> m b) -> Arg' a -> m (Arg' b)

sequence :: Monad m => Arg' (m a) -> m (Arg' a)

HasPosition Arg

Defined in BNFC.Abs

Methods

hasPosition :: Arg -> BNFC'Position

Eq a => Eq (Arg' a)

Defined in BNFC.Abs

Methods

(==) :: Arg' a -> Arg' a -> Bool

(/=) :: Arg' a -> Arg' a -> Bool

Ord a => Ord (Arg' a)

Defined in BNFC.Abs

Methods

compare :: Arg' a -> Arg' a -> Ordering

(<) :: Arg' a -> Arg' a -> Bool

(<=) :: Arg' a -> Arg' a -> Bool

(>) :: Arg' a -> Arg' a -> Bool

(>=) :: Arg' a -> Arg' a -> Bool

max :: Arg' a -> Arg' a -> Arg' a

min :: Arg' a -> Arg' a -> Arg' a

Read a => Read (Arg' a)

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS (Arg' a)

readList :: ReadS [Arg' a]

readPrec :: ReadPrec (Arg' a)

readListPrec :: ReadPrec [Arg' a]

Show a => Show (Arg' a)

Defined in BNFC.Abs

Methods

showsPrec :: Int -> Arg' a -> ShowS

show :: Arg' a -> String

showList :: [Arg' a] -> ShowS

Print [Arg' a]

Defined in BNFC.Print

Methods

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

Print (Arg' a)

Defined in BNFC.Print

Methods

prt :: Int -> Arg' a -> Doc

type Separation = Separation' BNFC'Position

data Separation' a

Constructors

SepNone a

SepTerm a String

SepSepar a String

Instances

Functor Separation'

Defined in BNFC.Abs

Methods

fmap :: (a -> b) -> Separation' a -> Separation' b

(<$) :: a -> Separation' b -> Separation' a

Foldable Separation'

Defined in BNFC.Abs

Methods

fold :: Monoid m => Separation' m -> m

foldMap :: Monoid m => (a -> m) -> Separation' a -> m

foldMap' :: Monoid m => (a -> m) -> Separation' a -> m

foldr :: (a -> b -> b) -> b -> Separation' a -> b

foldr' :: (a -> b -> b) -> b -> Separation' a -> b

foldl :: (b -> a -> b) -> b -> Separation' a -> b

foldl' :: (b -> a -> b) -> b -> Separation' a -> b

foldr1 :: (a -> a -> a) -> Separation' a -> a

foldl1 :: (a -> a -> a) -> Separation' a -> a

toList :: Separation' a -> [a]

null :: Separation' a -> Bool

length :: Separation' a -> Int

elem :: Eq a => a -> Separation' a -> Bool

maximum :: Ord a => Separation' a -> a

minimum :: Ord a => Separation' a -> a

sum :: Num a => Separation' a -> a

product :: Num a => Separation' a -> a

Traversable Separation'

Defined in BNFC.Abs

Methods

traverse :: Applicative f => (a -> f b) -> Separation' a -> f (Separation' b)

sequenceA :: Applicative f => Separation' (f a) -> f (Separation' a)

mapM :: Monad m => (a -> m b) -> Separation' a -> m (Separation' b)

sequence :: Monad m => Separation' (m a) -> m (Separation' a)

HasPosition Separation

Defined in BNFC.Abs

Methods

hasPosition :: Separation -> BNFC'Position

Eq a => Eq (Separation' a)

Defined in BNFC.Abs

Methods

(==) :: Separation' a -> Separation' a -> Bool

(/=) :: Separation' a -> Separation' a -> Bool

Ord a => Ord (Separation' a)

Defined in BNFC.Abs

Methods

compare :: Separation' a -> Separation' a -> Ordering

(<) :: Separation' a -> Separation' a -> Bool

(<=) :: Separation' a -> Separation' a -> Bool

(>) :: Separation' a -> Separation' a -> Bool

(>=) :: Separation' a -> Separation' a -> Bool

max :: Separation' a -> Separation' a -> Separation' a

min :: Separation' a -> Separation' a -> Separation' a

Read a => Read (Separation' a)

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS (Separation' a)

readList :: ReadS [Separation' a]

readPrec :: ReadPrec (Separation' a)

readListPrec :: ReadPrec [Separation' a]

Show a => Show (Separation' a)

Defined in BNFC.Abs

Methods

showsPrec :: Int -> Separation' a -> ShowS

show :: Separation' a -> String

showList :: [Separation' a] -> ShowS

Print (Separation' a)

Defined in BNFC.Print

Methods

prt :: Int -> Separation' a -> Doc

type Exp = Exp' BNFC'Position

data Exp' a

Constructors

Cons a (Exp' a) (Exp' a)

App a Identifier [Exp' a]

Var a Identifier

LitInteger a Integer

LitChar a Char

LitString a String

LitDouble a Double

List a [Exp' a]

Instances

Functor Exp'

Defined in BNFC.Abs

Methods

fmap :: (a -> b) -> Exp' a -> Exp' b

(<$) :: a -> Exp' b -> Exp' a

Foldable Exp'

Defined in BNFC.Abs

Methods

fold :: Monoid m => Exp' m -> m

foldMap :: Monoid m => (a -> m) -> Exp' a -> m

foldMap' :: Monoid m => (a -> m) -> Exp' a -> m

foldr :: (a -> b -> b) -> b -> Exp' a -> b

foldr' :: (a -> b -> b) -> b -> Exp' a -> b

foldl :: (b -> a -> b) -> b -> Exp' a -> b

foldl' :: (b -> a -> b) -> b -> Exp' a -> b

foldr1 :: (a -> a -> a) -> Exp' a -> a

foldl1 :: (a -> a -> a) -> Exp' a -> a

toList :: Exp' a -> [a]

null :: Exp' a -> Bool

length :: Exp' a -> Int

elem :: Eq a => a -> Exp' a -> Bool

maximum :: Ord a => Exp' a -> a

minimum :: Ord a => Exp' a -> a

sum :: Num a => Exp' a -> a

product :: Num a => Exp' a -> a

Traversable Exp'

Defined in BNFC.Abs

Methods

traverse :: Applicative f => (a -> f b) -> Exp' a -> f (Exp' b)

sequenceA :: Applicative f => Exp' (f a) -> f (Exp' a)

mapM :: Monad m => (a -> m b) -> Exp' a -> m (Exp' b)

sequence :: Monad m => Exp' (m a) -> m (Exp' a)

HasPosition Exp

Defined in BNFC.Abs

Methods

hasPosition :: Exp -> BNFC'Position

Eq a => Eq (Exp' a)

Defined in BNFC.Abs

Methods

(==) :: Exp' a -> Exp' a -> Bool

(/=) :: Exp' a -> Exp' a -> Bool

Ord a => Ord (Exp' a)

Defined in BNFC.Abs

Methods

compare :: Exp' a -> Exp' a -> Ordering

(<) :: Exp' a -> Exp' a -> Bool

(<=) :: Exp' a -> Exp' a -> Bool

(>) :: Exp' a -> Exp' a -> Bool

(>=) :: Exp' a -> Exp' a -> Bool

max :: Exp' a -> Exp' a -> Exp' a

min :: Exp' a -> Exp' a -> Exp' a

Read a => Read (Exp' a)

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS (Exp' a)

readList :: ReadS [Exp' a]

readPrec :: ReadPrec (Exp' a)

readListPrec :: ReadPrec [Exp' a]

Show a => Show (Exp' a)

Defined in BNFC.Abs

Methods

showsPrec :: Int -> Exp' a -> ShowS

show :: Exp' a -> String

showList :: [Exp' a] -> ShowS

Print [Exp' a]

Defined in BNFC.Print

Methods

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

Print (Exp' a)

Defined in BNFC.Print

Methods

prt :: Int -> Exp' a -> Doc

type RHS = RHS' BNFC'Position

data RHS' a

Constructors

RHS a [Item' a]

Instances

Functor RHS'

Defined in BNFC.Abs

Methods

fmap :: (a -> b) -> RHS' a -> RHS' b

(<$) :: a -> RHS' b -> RHS' a

Foldable RHS'

Defined in BNFC.Abs

Methods

fold :: Monoid m => RHS' m -> m

foldMap :: Monoid m => (a -> m) -> RHS' a -> m

foldMap' :: Monoid m => (a -> m) -> RHS' a -> m

foldr :: (a -> b -> b) -> b -> RHS' a -> b

foldr' :: (a -> b -> b) -> b -> RHS' a -> b

foldl :: (b -> a -> b) -> b -> RHS' a -> b

foldl' :: (b -> a -> b) -> b -> RHS' a -> b

foldr1 :: (a -> a -> a) -> RHS' a -> a

foldl1 :: (a -> a -> a) -> RHS' a -> a

toList :: RHS' a -> [a]

null :: RHS' a -> Bool

length :: RHS' a -> Int

elem :: Eq a => a -> RHS' a -> Bool

maximum :: Ord a => RHS' a -> a

minimum :: Ord a => RHS' a -> a

sum :: Num a => RHS' a -> a

product :: Num a => RHS' a -> a

Traversable RHS'

Defined in BNFC.Abs

Methods

traverse :: Applicative f => (a -> f b) -> RHS' a -> f (RHS' b)

sequenceA :: Applicative f => RHS' (f a) -> f (RHS' a)

mapM :: Monad m => (a -> m b) -> RHS' a -> m (RHS' b)

sequence :: Monad m => RHS' (m a) -> m (RHS' a)

HasPosition RHS

Defined in BNFC.Abs

Methods

hasPosition :: RHS -> BNFC'Position

AddKeywords RHS

Defined in BNFC.Check.Pass1

Methods

addKeywords :: RHS -> M ()

AddCategories RHS

Defined in BNFC.Check.Pass1

Methods

addCategories :: RHS -> ReaderT Parseable M ()

Eq a => Eq (RHS' a)

Defined in BNFC.Abs

Methods

(==) :: RHS' a -> RHS' a -> Bool

(/=) :: RHS' a -> RHS' a -> Bool

Ord a => Ord (RHS' a)

Defined in BNFC.Abs

Methods

compare :: RHS' a -> RHS' a -> Ordering

(<) :: RHS' a -> RHS' a -> Bool

(<=) :: RHS' a -> RHS' a -> Bool

(>) :: RHS' a -> RHS' a -> Bool

(>=) :: RHS' a -> RHS' a -> Bool

max :: RHS' a -> RHS' a -> RHS' a

min :: RHS' a -> RHS' a -> RHS' a

Read a => Read (RHS' a)

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS (RHS' a)

readList :: ReadS [RHS' a]

readPrec :: ReadPrec (RHS' a)

readListPrec :: ReadPrec [RHS' a]

Show a => Show (RHS' a)

Defined in BNFC.Abs

Methods

showsPrec :: Int -> RHS' a -> ShowS

show :: RHS' a -> String

showList :: [RHS' a] -> ShowS

Print [RHS' a]

Defined in BNFC.Print

Methods

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

Print (RHS' a)

Defined in BNFC.Print

Methods

prt :: Int -> RHS' a -> Doc

type MinimumSize = MinimumSize' BNFC'Position

data MinimumSize' a

Constructors

MNonEmpty a

MEmpty a

Instances

Functor MinimumSize'

Defined in BNFC.Abs

Methods

fmap :: (a -> b) -> MinimumSize' a -> MinimumSize' b

(<$) :: a -> MinimumSize' b -> MinimumSize' a

Foldable MinimumSize'

Defined in BNFC.Abs

Methods

fold :: Monoid m => MinimumSize' m -> m

foldMap :: Monoid m => (a -> m) -> MinimumSize' a -> m

foldMap' :: Monoid m => (a -> m) -> MinimumSize' a -> m

foldr :: (a -> b -> b) -> b -> MinimumSize' a -> b

foldr' :: (a -> b -> b) -> b -> MinimumSize' a -> b

foldl :: (b -> a -> b) -> b -> MinimumSize' a -> b

foldl' :: (b -> a -> b) -> b -> MinimumSize' a -> b

foldr1 :: (a -> a -> a) -> MinimumSize' a -> a

foldl1 :: (a -> a -> a) -> MinimumSize' a -> a

toList :: MinimumSize' a -> [a]

null :: MinimumSize' a -> Bool

length :: MinimumSize' a -> Int

elem :: Eq a => a -> MinimumSize' a -> Bool

maximum :: Ord a => MinimumSize' a -> a

minimum :: Ord a => MinimumSize' a -> a

sum :: Num a => MinimumSize' a -> a

product :: Num a => MinimumSize' a -> a

Traversable MinimumSize'

Defined in BNFC.Abs

Methods

traverse :: Applicative f => (a -> f b) -> MinimumSize' a -> f (MinimumSize' b)

sequenceA :: Applicative f => MinimumSize' (f a) -> f (MinimumSize' a)

mapM :: Monad m => (a -> m b) -> MinimumSize' a -> m (MinimumSize' b)

sequence :: Monad m => MinimumSize' (m a) -> m (MinimumSize' a)

HasPosition MinimumSize

Defined in BNFC.Abs

Methods

hasPosition :: MinimumSize -> BNFC'Position

Eq a => Eq (MinimumSize' a)

Defined in BNFC.Abs

Methods

(==) :: MinimumSize' a -> MinimumSize' a -> Bool

(/=) :: MinimumSize' a -> MinimumSize' a -> Bool

Ord a => Ord (MinimumSize' a)

Defined in BNFC.Abs

Methods

compare :: MinimumSize' a -> MinimumSize' a -> Ordering

(<) :: MinimumSize' a -> MinimumSize' a -> Bool

(<=) :: MinimumSize' a -> MinimumSize' a -> Bool

(>) :: MinimumSize' a -> MinimumSize' a -> Bool

(>=) :: MinimumSize' a -> MinimumSize' a -> Bool

max :: MinimumSize' a -> MinimumSize' a -> MinimumSize' a

min :: MinimumSize' a -> MinimumSize' a -> MinimumSize' a

Read a => Read (MinimumSize' a)

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS (MinimumSize' a)

readList :: ReadS [MinimumSize' a]

readPrec :: ReadPrec (MinimumSize' a)

readListPrec :: ReadPrec [MinimumSize' a]

Show a => Show (MinimumSize' a)

Defined in BNFC.Abs

Methods

showsPrec :: Int -> MinimumSize' a -> ShowS

show :: MinimumSize' a -> String

showList :: [MinimumSize' a] -> ShowS

Print (MinimumSize' a)

Defined in BNFC.Print

Methods

prt :: Int -> MinimumSize' a -> Doc

type Reg = Reg' BNFC'Position

data Reg' a

Constructors

RAlt a (Reg' a) (Reg' a)

RMinus a (Reg' a) (Reg' a)

RSeq a (Reg' a) (Reg' a)

RStar a (Reg' a)

RPlus a (Reg' a)

ROpt a (Reg' a)

REps a

RChar a Char

RAlts a String

RSeqs a String

RDigit a

RLetter a

RUpper a

RLower a

RAny a

Instances

Functor Reg'

Defined in BNFC.Abs

Methods

fmap :: (a -> b) -> Reg' a -> Reg' b

(<$) :: a -> Reg' b -> Reg' a

Foldable Reg'

Defined in BNFC.Abs

Methods

fold :: Monoid m => Reg' m -> m

foldMap :: Monoid m => (a -> m) -> Reg' a -> m

foldMap' :: Monoid m => (a -> m) -> Reg' a -> m

foldr :: (a -> b -> b) -> b -> Reg' a -> b

foldr' :: (a -> b -> b) -> b -> Reg' a -> b

foldl :: (b -> a -> b) -> b -> Reg' a -> b

foldl' :: (b -> a -> b) -> b -> Reg' a -> b

foldr1 :: (a -> a -> a) -> Reg' a -> a

foldl1 :: (a -> a -> a) -> Reg' a -> a

toList :: Reg' a -> [a]

null :: Reg' a -> Bool

length :: Reg' a -> Int

elem :: Eq a => a -> Reg' a -> Bool

maximum :: Ord a => Reg' a -> a

minimum :: Ord a => Reg' a -> a

sum :: Num a => Reg' a -> a

product :: Num a => Reg' a -> a

Traversable Reg'

Defined in BNFC.Abs

Methods

traverse :: Applicative f => (a -> f b) -> Reg' a -> f (Reg' b)

sequenceA :: Applicative f => Reg' (f a) -> f (Reg' a)

mapM :: Monad m => (a -> m b) -> Reg' a -> m (Reg' b)

sequence :: Monad m => Reg' (m a) -> m (Reg' a)

HasPosition Reg

Defined in BNFC.Abs

Methods

hasPosition :: Reg -> BNFC'Position

Eq a => Eq (Reg' a)

Defined in BNFC.Abs

Methods

(==) :: Reg' a -> Reg' a -> Bool

(/=) :: Reg' a -> Reg' a -> Bool

Ord a => Ord (Reg' a)

Defined in BNFC.Abs

Methods

compare :: Reg' a -> Reg' a -> Ordering

(<) :: Reg' a -> Reg' a -> Bool

(<=) :: Reg' a -> Reg' a -> Bool

(>) :: Reg' a -> Reg' a -> Bool

(>=) :: Reg' a -> Reg' a -> Bool

max :: Reg' a -> Reg' a -> Reg' a

min :: Reg' a -> Reg' a -> Reg' a

Read a => Read (Reg' a)

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS (Reg' a)

readList :: ReadS [Reg' a]

readPrec :: ReadPrec (Reg' a)

readListPrec :: ReadPrec [Reg' a]

Show a => Show (Reg' a)

Defined in BNFC.Abs

Methods

showsPrec :: Int -> Reg' a -> ShowS

show :: Reg' a -> String

showList :: [Reg' a] -> ShowS

Print (Reg' a)

Defined in BNFC.Print

Methods

prt :: Int -> Reg' a -> Doc

newtype Identifier

Constructors

Identifier ((Int, Int), String)

Instances

Eq Identifier

Defined in BNFC.Abs

Methods

(==) :: Identifier -> Identifier -> Bool

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

Ord Identifier

Defined in BNFC.Abs

Methods

compare :: Identifier -> Identifier -> Ordering

(<) :: Identifier -> Identifier -> Bool

(<=) :: Identifier -> Identifier -> Bool

(>) :: Identifier -> Identifier -> Bool

(>=) :: Identifier -> Identifier -> Bool

max :: Identifier -> Identifier -> Identifier

min :: Identifier -> Identifier -> Identifier

Read Identifier

Defined in BNFC.Abs

Methods

readsPrec :: Int -> ReadS Identifier

readList :: ReadS [Identifier]

readPrec :: ReadPrec Identifier

readListPrec :: ReadPrec [Identifier]

Show Identifier

Defined in BNFC.Abs

Methods

showsPrec :: Int -> Identifier -> ShowS

show :: Identifier -> String

showList :: [Identifier] -> ShowS

HasPosition Identifier

Defined in BNFC.Abs

Methods

hasPosition :: Identifier -> BNFC'Position

Print Identifier

Defined in BNFC.Print

Methods

prt :: Int -> Identifier -> Doc

type BNFC'Position = Maybe (Int, Int)

Start position (line, column) of something.

pattern BNFC'NoPosition :: BNFC'Position

pattern BNFC'Position :: Int -> Int -> BNFC'Position

class HasPosition a where

Get the start position of something.

Methods

hasPosition :: a -> BNFC'Position

Instances

HasPosition Identifier

Defined in BNFC.Abs

Methods

hasPosition :: Identifier -> BNFC'Position

HasPosition Reg

Defined in BNFC.Abs

Methods

hasPosition :: Reg -> BNFC'Position

HasPosition MinimumSize

Defined in BNFC.Abs

Methods

hasPosition :: MinimumSize -> BNFC'Position

HasPosition RHS

Defined in BNFC.Abs

Methods

hasPosition :: RHS -> BNFC'Position

HasPosition Exp

Defined in BNFC.Abs

Methods

hasPosition :: Exp -> BNFC'Position

HasPosition Separation

Defined in BNFC.Abs

Methods

hasPosition :: Separation -> BNFC'Position

HasPosition Arg

Defined in BNFC.Abs

Methods

hasPosition :: Arg -> BNFC'Position

HasPosition Label

Defined in BNFC.Abs

Methods

hasPosition :: Label -> BNFC'Position

HasPosition Cat

Defined in BNFC.Abs

Methods

hasPosition :: Cat -> BNFC'Position

HasPosition Item

Defined in BNFC.Abs

Methods

hasPosition :: Item -> BNFC'Position

HasPosition Def

Defined in BNFC.Abs

Methods

hasPosition :: Def -> BNFC'Position

HasPosition Grammar

Defined in BNFC.Abs

Methods

hasPosition :: Grammar -> BNFC'Position