NLP.GenI.Tags

Documentation

type Tags = Map String [TagElem]

An anchored grammar. The grammar associates a set of semantic predicates to a list of trees each.

data TagElem

Constructors

TE

Fields

idname :: String

ttreename :: String

tidnum :: Integer

ttype :: !Ptype

ttree :: Tree GNode

tsemantics :: Sem

tpolarities :: Map String (Int, Int)

tinterface :: Flist

ttrace :: [String]

tsempols :: [SemPols]

Instances

Eq TagElem

Ord TagElem

Show TagElem

Idable TagElem

Replacable TagElem

Collectable TagElem

TagItem TagElem

GeniShow TagElem

ShowLite TagElem

class TagItem t where

TagItem is a generalisation of TagElem.

Methods

tgIdName :: t -> String

tgIdNum :: t -> Integer

tgSemantics :: t -> Sem

Instances

TagItem TagElem

data TagSite

Constructors

TagSite

Fields

tsName :: !String

tsUp :: !Flist

tsDown :: !Flist

tsOrigin :: !String

Instances

Eq TagSite

Ord TagSite

Show TagSite

Replacable TagSite

type TagDerivation = [(Char, String, (String, String))]

emptyTE :: TagElem

ts_synIncomplete :: String

ts_semIncomplete :: [Pred] -> String

ts_tbUnificationFailure :: String

ts_rootFeatureMismatch :: Flist -> String

addToTags :: Tags -> String -> TagElem -> Tags

addTags tags key elem adds elem to the the list of elements associated to the key

tagLeaves :: TagElem -> [(String, UninflectedDisjunction)]

setTidnums :: [TagElem] -> [TagElem]

Assigns a unique id to each element of this list, that is, an integer between 1 and the size of the list.

mapBySem :: TagItem t => [t] -> Map Pred [t]

Sorts trees into a Map.Map organised by the first literal of their semantics. This is useful in at least three places: the polarity optimisation, the gui display code, and code for measuring the efficiency of GenI. Note: trees with a null semantics are filed under an empty predicate, if any.

subsumedBy :: Sem -> Pred -> Bool

subsumedBy cs ts determines if the candidate semantics cs is subsumed by the proposition semantics ts. Notice how the proposition semantics is only a single item where as the candidate semantics is a list.

We assume

• most importantly that cs has already its semantics instatiated (all variables assigned)
• cs and ts are sorted
• the list in each element of cs and ts is itself sorted

showTagSites :: [TagSite] -> String

collect :: Collectable a => a -> Set String -> Set String

detectSites :: Tree GNode -> ([TagSite], [TagSite], [TagSite])

Given a tree(GNode) returns a list of substitution or adjunction nodes, as well as remaining nodes with a null adjunction constraint.