Safe Haskell | None |
---|---|
Language | Haskell2010 |
The data types that define a CFG.
Synopsis
- newtype IndexName = IndexName {}
- data Index = Index {
- _indexName :: IndexName
- _indexHere :: Integer
- _indexOp :: IOP
- _indexRange :: [Integer]
- _indexStep :: Integer
- data IOP
- getIndexName :: Iso' IndexName String
- newtype SymbolName = SymbolName {}
- indexHere :: Lens' Index Integer
- indexName :: Lens' Index IndexName
- indexOp :: Lens' Index IOP
- indexRange :: Lens' Index [Integer]
- indexStep :: Lens' Index Integer
- newtype Tape = Tape {}
- getSteName :: Iso' SymbolName String
- data SynTermEps
- getTape :: Iso' Tape Int
- index :: Traversal' SynTermEps [Index]
- name :: Traversal' SynTermEps SymbolName
- splitK :: Traversal' SynTermEps Integer
- splitN :: Traversal' SynTermEps Integer
- newtype Symbol = Symbol {
- _getSymbolList :: [SynTermEps]
- _SynVar :: Prism' SynTermEps (SymbolName, [Index], Integer, Integer)
- _SynTerm :: Prism' SynTermEps (SymbolName, [Index])
- _Term :: Prism' SynTermEps (SymbolName, [Index])
- _Deletion :: Prism' SynTermEps ()
- _Epsilon :: Prism' SynTermEps LocalGlobal
- newtype AttributeFunction = Attr {}
- getSymbolList :: Iso' Symbol [SynTermEps]
- data Rule = Rule {}
- getAttr :: Iso' AttributeFunction String
- data Grammar = Grammar {}
- data DerivedGrammar
- attr :: Lens' Rule [AttributeFunction]
- lhs :: Lens' Rule Symbol
- rhs :: Lens' Rule [Symbol]
- isOutside :: DerivedGrammar -> Bool
- fromInside :: Traversal' DerivedGrammar Grammar
- grammarName :: Lens' Grammar String
- indices :: Lens' Grammar (Map IndexName Index)
- outside :: Lens' Grammar DerivedGrammar
- params :: Lens' Grammar (Map IndexName Index)
- rules :: Lens' Grammar (Set Rule)
- start :: Lens' Grammar Symbol
- synterms :: Lens' Grammar (Map SymbolName SynTermEps)
- synvars :: Lens' Grammar (Map SymbolName SynTermEps)
- termvars :: Lens' Grammar (Map SymbolName SynTermEps)
- write :: Lens' Grammar Bool
- data LocalGlobal
Documentation
Instances
Eq IndexName Source # | |
Data IndexName Source # | |
Defined in FormalLanguage.CFG.Grammar.Types gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IndexName -> c IndexName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IndexName # toConstr :: IndexName -> Constr # dataTypeOf :: IndexName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IndexName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IndexName) # gmapT :: (forall b. Data b => b -> b) -> IndexName -> IndexName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IndexName -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IndexName -> r # gmapQ :: (forall d. Data d => d -> u) -> IndexName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IndexName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IndexName -> m IndexName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IndexName -> m IndexName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IndexName -> m IndexName # | |
Ord IndexName Source # | |
Defined in FormalLanguage.CFG.Grammar.Types | |
Show IndexName Source # | |
IsString IndexName Source # | |
Defined in FormalLanguage.CFG.Grammar.Types fromString :: String -> IndexName # |
Encode the index of the syntactic or terminal variable.
In case of grammar-based indexing, keep indexRange
empty. The
indexStep
keeps track of any +k
/ -k
given in the production
rules.
We allow indexing terminals now, too. When glueing together terminals, one might want to be able to differentiate between terminals.
Index | |
|
Instances
Eq Index Source # | |
Data Index Source # | |
Defined in FormalLanguage.CFG.Grammar.Types gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Index -> c Index # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Index # dataTypeOf :: Index -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Index) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Index) # gmapT :: (forall b. Data b => b -> b) -> Index -> Index # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Index -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Index -> r # gmapQ :: (forall d. Data d => d -> u) -> Index -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Index -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Index -> m Index # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Index -> m Index # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Index -> m Index # | |
Ord Index Source # | |
Show Index Source # | |
Instances
Eq IOP Source # | |
Data IOP Source # | |
Defined in FormalLanguage.CFG.Grammar.Types gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> IOP -> c IOP # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c IOP # dataTypeOf :: IOP -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c IOP) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IOP) # gmapT :: (forall b. Data b => b -> b) -> IOP -> IOP # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IOP -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IOP -> r # gmapQ :: (forall d. Data d => d -> u) -> IOP -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> IOP -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> IOP -> m IOP # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> IOP -> m IOP # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> IOP -> m IOP # | |
Ord IOP Source # | |
Show IOP Source # | |
newtype SymbolName Source #
Newtype wrapper for symbol names.
Instances
The tape, a terminal operates on. Terminals on different tapes could
still have the same SymbolName
but different type and input!
Instances
Enum Tape Source # | |
Eq Tape Source # | |
Data Tape Source # | |
Defined in FormalLanguage.CFG.Grammar.Types gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Tape -> c Tape # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Tape # dataTypeOf :: Tape -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Tape) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tape) # gmapT :: (forall b. Data b => b -> b) -> Tape -> Tape # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tape -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tape -> r # gmapQ :: (forall d. Data d => d -> u) -> Tape -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Tape -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Tape -> m Tape # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Tape -> m Tape # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Tape -> m Tape # | |
Num Tape Source # | |
Ord Tape Source # | |
Show Tape Source # | |
data SynTermEps Source #
Symbols, potentially with an index or more than one.
SynVar | Syntactic variables. |
SynTerm | |
| |
Term | Regular old terminal symbol -- reads stuff from the input. |
| |
Deletion | This sym denotes the case, where we have an |
Epsilon LocalGlobal | Finally, a real epsilon. Again, these are somewhat regular terminal symbols, but it is important to be able to recognize these, when trying to create outside variants of our algorithms. |
Instances
index :: Traversal' SynTermEps [Index] Source #
The length of the list encodes the dimension of the symbol. Forms a monoid over dimensional concatenation.
Instances
Eq Symbol Source # | |
Data Symbol Source # | |
Defined in FormalLanguage.CFG.Grammar.Types gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Symbol -> c Symbol # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Symbol # toConstr :: Symbol -> Constr # dataTypeOf :: Symbol -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Symbol) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Symbol) # gmapT :: (forall b. Data b => b -> b) -> Symbol -> Symbol # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Symbol -> r # gmapQ :: (forall d. Data d => d -> u) -> Symbol -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Symbol -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Symbol -> m Symbol # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Symbol -> m Symbol # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Symbol -> m Symbol # | |
Ord Symbol Source # | |
Show Symbol Source # | |
Semigroup Symbol Source # | |
Monoid Symbol Source # | |
_SynVar :: Prism' SynTermEps (SymbolName, [Index], Integer, Integer) Source #
_SynTerm :: Prism' SynTermEps (SymbolName, [Index]) Source #
_Term :: Prism' SynTermEps (SymbolName, [Index]) Source #
_Deletion :: Prism' SynTermEps () Source #
newtype AttributeFunction Source #
The name of an attribute function
Instances
getSymbolList :: Iso' Symbol [SynTermEps] Source #
Production rules for at-most CFGs.
Instances
Eq Rule Source # | |
Data Rule Source # | |
Defined in FormalLanguage.CFG.Grammar.Types gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Rule -> c Rule # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Rule # dataTypeOf :: Rule -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Rule) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Rule) # gmapT :: (forall b. Data b => b -> b) -> Rule -> Rule # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Rule -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Rule -> r # gmapQ :: (forall d. Data d => d -> u) -> Rule -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Rule -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Rule -> m Rule # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Rule -> m Rule # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Rule -> m Rule # | |
Ord Rule Source # | |
Show Rule Source # | |
Complete descrition of a grammar. In principle it would be enough to hold
_rules
and the _start
symbol name. We also store dimensionless names for
syntactiv variables, and terminals. This makes certain checks easier or
possible.
We store all single-tape symbol names dimensionless. This means that, for terminals, symbols with the same name have the same tape. This is slightly inconvenient for special applications (say Protein-DNA alignment) but one can easily rename terminals.
TODO better way to handle indexed symbols?
TODO include String name to handle sharing signatures (and thereby algebras!). This makes sense only when sharing the more complex signature, until I start allowing signature merges.
Grammar | |
|
Instances
Data Grammar Source # | |
Defined in FormalLanguage.CFG.Grammar.Types gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Grammar -> c Grammar # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Grammar # toConstr :: Grammar -> Constr # dataTypeOf :: Grammar -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Grammar) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Grammar) # gmapT :: (forall b. Data b => b -> b) -> Grammar -> Grammar # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Grammar -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Grammar -> r # gmapQ :: (forall d. Data d => d -> u) -> Grammar -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Grammar -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Grammar -> m Grammar # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Grammar -> m Grammar # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Grammar -> m Grammar # | |
Show Grammar Source # | |
Default Grammar Source # | |
Defined in FormalLanguage.CFG.Grammar.Types |
data DerivedGrammar Source #
Indicate wether we are a handwritten Inside
grammar, or an Outside
grammar derived fromInside
.
Instances
isOutside :: DerivedGrammar -> Bool Source #
data LocalGlobal #