NLP.GenI.Lexicon

Lexical entries

As a factorisation technique, LTAG grammars are commonly separated into tree schemata (see TreeSchema) and lexical entries. The grammar is what you get by “anchoring” each lexical entry to the relevant tree schemata.

Documentation

type Lexicon = [LexEntry]

Collection of lexical entries

data LexEntry

Lexical entry

Instances

Eq LexEntry

Methods

(==) :: LexEntry -> LexEntry -> Bool

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

Data LexEntry

Methods

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

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

toConstr :: LexEntry -> Constr

dataTypeOf :: LexEntry -> DataType

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

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

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

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

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

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

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

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

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

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

Binary LexEntry

Methods

put :: LexEntry -> Put

get :: Get LexEntry

putList :: [LexEntry] -> Put

NFData LexEntry

Methods

rnf :: LexEntry -> ()

Pretty LexEntry

Methods

pretty :: LexEntry -> Text

prettyStr :: LexEntry -> String

GeniShow LexEntry

Methods

geniShow :: LexEntry -> String

geniShowText :: LexEntry -> Text

DescendGeniVal LexEntry

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> LexEntry -> LexEntry

Collectable LexEntry

Methods

collect :: LexEntry -> Map CollectedVar Int -> Map CollectedVar Int

Loadable Lexicon

Methods

lParse :: FilePath -> Text -> Either Text Lexicon

lSet :: Lexicon -> ProgState -> ProgState

lSummarise :: Lexicon -> String

GeniShow [LexEntry]

Methods

geniShow :: [LexEntry] -> String

geniShowText :: [LexEntry] -> Text

mkLexEntry

Arguments

:: FullList Text

word

-> Text

family name

-> [GeniVal]

parameters list (deprecated)

-> Flist GeniVal

interface (use instead of params)

-> Flist GeniVal

filters

-> Flist GeniVal

equations

-> Sem

semantics

-> LexEntry

See also mkFullLexEntry This version comes with some sensible defaults.

mkFullLexEntry

Arguments

:: FullList Text

word

-> Text

family name

-> [GeniVal]

parameters list (deprecated)

-> Flist GeniVal

interface (use instead of params)

-> Flist GeniVal

filters

-> Flist GeniVal

equations

-> Sem

semantics

-> [SemPols]

semantic polarities

-> LexEntry

Variant of mkLexEntry but with more control

iword :: LexEntry -> FullList Text

normally just a singleton, useful for merging synonyms

ifamname :: LexEntry -> Text

tree family to anchor to

iparams :: LexEntry -> [GeniVal]

parameters (deprecrated; use the interface)

iinterface :: LexEntry -> Flist GeniVal

features to unify with tree schema interface

ifilters :: LexEntry -> Flist GeniVal

features to pick out family members we want

iequations :: LexEntry -> Flist GeniVal

path equations

isemantics :: LexEntry -> Sem

lexical semantics

isempols :: LexEntry -> [SemPols]

polarities (must be same length as isemantics)

Converting between lexical/normal semantics

type PolValue = (GeniVal, Int)

An annotated GeniVal. This is for a rather old, obscure variant on the polarity filtering optimisation. To account for zero literal semantics, we annotate each value in the semantics with a positive/negative marker. These markers are then counted up to determine with we need to insert more literals into the semantics or not. See the manual on polarity filtering for more details

fromLexSem :: [Literal PolValue] -> (Sem, [SemPols])

Separate an input lexical semantics into the actual semantics and the semantic polarity entries (which aren't used very much in practice, being a sort of experimental feature to solve an obscure-ish technical problem)

fromLexLiteral :: Literal PolValue -> (Literal GeniVal, SemPols)

Note that by convention we ignore the polarity associated with the predicate itself