NLP.GenI.TreeSchema

This module provides basic datatypes specific to Tree Adjoining Grammar tree schemata.

Documentation

type Macros = [SchemaTree]

type SchemaTree = Ttree (GNode SchemaVal)

data Ttree a

Constructors

TT

Fields

• params :: [GeniVal]
• pfamily :: Text
• pidname :: Text
• pinterface :: Flist GeniVal
• ptype :: Ptype
• psemantics :: Maybe Sem
• ptrace :: [Text]
• tree :: Tree a

Instances

Loadable Macros

Methods

lParse :: FilePath -> Text -> Either Text Macros

lSet :: Macros -> ProgState -> ProgState

lSummarise :: Macros -> String

Eq a => Eq (Ttree a)

Methods

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

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

Data a => Data (Ttree a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ttree a -> c (Ttree a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ttree a)

toConstr :: Ttree a -> Constr

dataTypeOf :: Ttree a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Ttree a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ttree a))

gmapT :: (forall b. Data b => b -> b) -> Ttree a -> Ttree a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ttree a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ttree a -> r

gmapQ :: (forall d. Data d => d -> u) -> Ttree a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ttree a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ttree a -> m (Ttree a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ttree a -> m (Ttree a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ttree a -> m (Ttree a)

Binary a => Binary (Ttree a)

Methods

put :: Ttree a -> Put

get :: Get (Ttree a)

putList :: [Ttree a] -> Put

GeniShow a => GeniShow [Ttree a]

Methods

geniShow :: [Ttree a] -> String

geniShowText :: [Ttree a] -> Text

GeniShow a => GeniShow (Ttree a)

Methods

geniShow :: Ttree a -> String

geniShowText :: Ttree a -> Text

DescendGeniVal v => DescendGeniVal (Ttree v)

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> Ttree v -> Ttree v

Collectable a => Collectable (Ttree a)

Methods

collect :: Ttree a -> Map CollectedVar Int -> Map CollectedVar Int

data Ptype

Constructors

Initial

Auxiliar

Instances

Eq Ptype

Methods

(==) :: Ptype -> Ptype -> Bool

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

Data Ptype

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ptype -> c Ptype

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ptype

toConstr :: Ptype -> Constr

dataTypeOf :: Ptype -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Ptype)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ptype)

gmapT :: (forall b. Data b => b -> b) -> Ptype -> Ptype

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ptype -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ptype -> r

gmapQ :: (forall d. Data d => d -> u) -> Ptype -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Ptype -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ptype -> m Ptype

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptype -> m Ptype

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ptype -> m Ptype

Show Ptype

Methods

showsPrec :: Int -> Ptype -> ShowS

show :: Ptype -> String

showList :: [Ptype] -> ShowS

Binary Ptype

Methods

put :: Ptype -> Put

get :: Get Ptype

putList :: [Ptype] -> Put

NFData Ptype

Methods

rnf :: Ptype -> ()

GeniShow Ptype

Methods

geniShow :: Ptype -> String

geniShowText :: Ptype -> Text

root :: Tree a -> a

rootUpd :: Tree a -> a -> Tree a

foot :: Tree (GNode a) -> GNode a

setLexeme :: [Text] -> Tree (GNode a) -> Tree (GNode a)

Given a lexical item l and a tree node n (actually a subtree with no children), return the same node with the lexical item as its unique child. The idea is that it converts terminal lexeme nodes into preterminal nodes where the actual terminal is the given lexical item

setAnchor :: FullList Text -> Tree (GNode a) -> Tree (GNode a)

Given a lexical item s and a Tree GNode t, returns the tree t' where l has been assigned to the anchor node in t'

lexemeAttributes :: [Text]

Attributes recognised as lexemes, in order of preference

crushTreeGNode :: Tree (GNode SchemaVal) -> Maybe (Tree (GNode GeniVal))

data AdjunctionConstraint

Essentially boolean representation of adjunction constraint

Constructors

MaybeAdj

ExplicitNoAdj

hard-coded null-adjunction constraint

InferredNoAdj

inferred by GenI to be adjunction free (ie. during realisation)

Instances

Eq AdjunctionConstraint

Methods

(==) :: AdjunctionConstraint -> AdjunctionConstraint -> Bool

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

Data AdjunctionConstraint

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> AdjunctionConstraint -> c AdjunctionConstraint

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c AdjunctionConstraint

toConstr :: AdjunctionConstraint -> Constr

dataTypeOf :: AdjunctionConstraint -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c AdjunctionConstraint)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AdjunctionConstraint)

gmapT :: (forall b. Data b => b -> b) -> AdjunctionConstraint -> AdjunctionConstraint

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AdjunctionConstraint -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AdjunctionConstraint -> r

gmapQ :: (forall d. Data d => d -> u) -> AdjunctionConstraint -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> AdjunctionConstraint -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> AdjunctionConstraint -> m AdjunctionConstraint

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> AdjunctionConstraint -> m AdjunctionConstraint

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> AdjunctionConstraint -> m AdjunctionConstraint

Binary AdjunctionConstraint

Methods

put :: AdjunctionConstraint -> Put

get :: Get AdjunctionConstraint

putList :: [AdjunctionConstraint] -> Put

NFData AdjunctionConstraint

Methods

rnf :: AdjunctionConstraint -> ()

isAdjConstrained :: GNode gv -> Bool

addInferredAdjConstraint :: GNode gv -> GNode gv

Add an inferred adjunction constraint marker unless we already see an explicit one

data GNode gv

A single node of a TAG tree.

Constructors

GN

Fields

• gnname :: NodeName
• gup :: Flist gv

  top feature structure

• gdown :: Flist gv

  bottom feature structure

• ganchor :: Bool

  False for na nodes

• glexeme :: [Text]

  [] for na nodes

• gtype :: GType
• gaconstr :: AdjunctionConstraint
• gorigin :: Text

  for TAG, this would be the elementary tree that this node originally came from

Instances

Loadable Macros

Methods

lParse :: FilePath -> Text -> Either Text Macros

lSet :: Macros -> ProgState -> ProgState

lSummarise :: Macros -> String

Eq gv => Eq (GNode gv)

Methods

(==) :: GNode gv -> GNode gv -> Bool

(/=) :: GNode gv -> GNode gv -> Bool

Data gv => Data (GNode gv)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GNode gv -> c (GNode gv)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GNode gv)

toConstr :: GNode gv -> Constr

dataTypeOf :: GNode gv -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (GNode gv))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GNode gv))

gmapT :: (forall b. Data b => b -> b) -> GNode gv -> GNode gv

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GNode gv -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GNode gv -> r

gmapQ :: (forall d. Data d => d -> u) -> GNode gv -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GNode gv -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GNode gv -> m (GNode gv)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GNode gv -> m (GNode gv)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GNode gv -> m (GNode gv)

Binary gv => Binary (GNode gv)

Methods

put :: GNode gv -> Put

get :: Get (GNode gv)

putList :: [GNode gv] -> Put

NFData gv => NFData (GNode gv)

A single node of a TAG tree.

Methods

rnf :: GNode gv -> ()

Pretty (GNode GeniVal)

The default show for GNode tries to be very compact; it only shows the value for cat attribute and any flags which are marked on that node.

This is one the places where the pretty representation of a GenI object is different from its GenI-format one

Methods

pretty :: GNode GeniVal -> Text

prettyStr :: GNode GeniVal -> String

GeniShow gv => GeniShow (GNode gv)

Methods

geniShow :: GNode gv -> String

geniShowText :: GNode gv -> Text

DescendGeniVal v => DescendGeniVal (GNode v)

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> GNode v -> GNode v

Collectable gv => Collectable (GNode gv)

Methods

collect :: GNode gv -> Map CollectedVar Int -> Map CollectedVar Int

gnnameIs :: NodeName -> GNode gv -> Bool

type NodeName = Text

data GType

Constructors

Subs

Foot

Lex

Other

Instances

Eq GType

Methods

(==) :: GType -> GType -> Bool

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

Data GType

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GType -> c GType

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GType

toConstr :: GType -> Constr

dataTypeOf :: GType -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c GType)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GType)

gmapT :: (forall b. Data b => b -> b) -> GType -> GType

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GType -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GType -> r

gmapQ :: (forall d. Data d => d -> u) -> GType -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GType -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GType -> m GType

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GType -> m GType

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GType -> m GType

Show GType

Methods

showsPrec :: Int -> GType -> ShowS

show :: GType -> String

showList :: [GType] -> ShowS

Binary GType

Methods

put :: GType -> Put

get :: Get GType

putList :: [GType] -> Put

NFData GType

Methods

rnf :: GType -> ()

gCategory :: Flist GeniVal -> Maybe GeniVal

Return the value of the "cat" attribute, if available

showLexeme :: [Text] -> Text

Fancy disjunction

data SchemaVal

A schema value is a disjunction of GenI values. It allows us to express “fancy” disjunctions in tree schemata, ie. disjunctions over variables and not just atoms (?X;?Y).

Our rule is that that when a tree schema is instantiated, any fancy disjunctions must be “crushed” into a single GeniVal lest it be rejected (see crushOne)

Note that this is still not recursive; we don't have disjunction over schema values, nor can schema values refer to schema values. It just allows us to express the idea that in tree schemata, you can have either variable ?X or ?Y.

Instances

Eq SchemaVal

Methods

(==) :: SchemaVal -> SchemaVal -> Bool

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

Ord SchemaVal

Methods

compare :: SchemaVal -> SchemaVal -> Ordering

(<) :: SchemaVal -> SchemaVal -> Bool

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

(>) :: SchemaVal -> SchemaVal -> Bool

(>=) :: SchemaVal -> SchemaVal -> Bool

max :: SchemaVal -> SchemaVal -> SchemaVal

min :: SchemaVal -> SchemaVal -> SchemaVal

Binary SchemaVal

Methods

put :: SchemaVal -> Put

get :: Get SchemaVal

putList :: [SchemaVal] -> Put

NFData SchemaVal

Methods

rnf :: SchemaVal -> ()

GeniShow SchemaVal

Methods

geniShow :: SchemaVal -> String

geniShowText :: SchemaVal -> Text

DescendGeniVal SchemaVal

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> SchemaVal -> SchemaVal

Collectable SchemaVal

Methods

collect :: SchemaVal -> Map CollectedVar Int -> Map CollectedVar Int

Loadable Macros

Methods

lParse :: FilePath -> Text -> Either Text Macros

lSet :: Macros -> ProgState -> ProgState

lSummarise :: Macros -> String

crushGNode :: GNode SchemaVal -> Maybe (GNode GeniVal)

Orphan instances

Collectable a => Collectable (Tree a)

Methods

collect :: Tree a -> Map CollectedVar Int -> Map CollectedVar Int

DescendGeniVal a => DescendGeniVal (Map k a)

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> Map k a -> Map k a