NLP.GenI.FeatureStructure

Feature structures in GenI can be seen as a simple mapping from attributes to values (no fancy recursion).

From an implementation standpoint, we do truck around lists of AvPair quite a bit which unfortunately means we don't guarantee things like uniqueness of attributes. We may phase this out over time in favour of FeatStruct

Documentation

type Flist a = [AvPair a]

A list of attribute-value pairs. It's not a great idea to represent feature structures with this because it allows for duplicates in the attributes. But maybe sometimes you really do mean a list.

data AvPair a

An attribute-value pair, the typical use being AvPair GeniVal or if you have something even simpler AvPair Text

Constructors

AvPair

Fields

• avAtt :: Text
• avVal :: a

Instances

Pretty SemInput

Methods

pretty :: SemInput -> Text

prettyStr :: SemInput -> String

GeniShow SemInput

Methods

geniShow :: SemInput -> String

geniShowText :: SemInput -> Text

Eq a => Eq (AvPair a)

Methods

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

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

Data a => Data (AvPair a)

Methods

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

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

toConstr :: AvPair a -> Constr

dataTypeOf :: AvPair a -> DataType

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

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

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

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

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

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

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

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

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

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

Ord a => Ord (AvPair a)

Methods

compare :: AvPair a -> AvPair a -> Ordering

(<) :: AvPair a -> AvPair a -> Bool

(<=) :: AvPair a -> AvPair a -> Bool

(>) :: AvPair a -> AvPair a -> Bool

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

max :: AvPair a -> AvPair a -> AvPair a

min :: AvPair a -> AvPair a -> AvPair a

Binary a => Binary (AvPair a)

Methods

put :: AvPair a -> Put

get :: Get (AvPair a)

putList :: [AvPair a] -> Put

NFData a => NFData (AvPair a)

Methods

rnf :: AvPair a -> ()

Pretty (AvPair GeniVal)

Methods

pretty :: AvPair GeniVal -> Text

prettyStr :: AvPair GeniVal -> String

Pretty (Flist GeniVal)

Methods

pretty :: Flist GeniVal -> Text

prettyStr :: Flist GeniVal -> String

GeniShow gv => GeniShow (AvPair gv)

Methods

geniShow :: AvPair gv -> String

geniShowText :: AvPair gv -> Text

GeniShow gv => GeniShow (Flist gv)

Methods

geniShow :: Flist gv -> String

geniShowText :: Flist gv -> Text

DescendGeniVal v => DescendGeniVal (AvPair v)

Methods

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

Collectable a => Collectable (AvPair a)

Methods

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

type FeatStruct a = Map Text a

Experimental, alternative representation of Flist which guarantees uniqueness of keys

emptyFeatStruct :: FeatStruct a

A feature structure with no pairs

mkFeatStruct :: Flist GeniVal -> FeatStruct GeniVal

Convert an Flist to a proper FeatStruct Unsafely assumes the keys are unique

fromFeatStruct :: FeatStruct a -> Flist a

Convert an FeatStruct to a simpler to process Flist

sortFlist :: Flist a -> Flist a

Sort an Flist according with its attributes

unifyFeat :: MonadUnify m => Flist GeniVal -> Flist GeniVal -> m (Flist GeniVal, Subst)

unifyFeat performs feature structure unification, under the these assumptions about the input:

• Features are ordered
• The Flists do not share variables (renaming has already been done.

The features are allowed to have different sets of attributes, beacuse we use alignFeat to realign them.

alignFeat :: Flist GeniVal -> Flist GeniVal -> [(Text, GeniVal, GeniVal)]

alignFeat is a pre-procesing step used to ensure that feature structures have the same set of keys. If a key is missing in one, we copy it to the other with an anonymous value.

The two feature structures must be sorted for this to work

alignFeatH :: Flist GeniVal -> Flist GeniVal -> [(Text, GeniVal, GeniVal)] -> [(Text, GeniVal, GeniVal)]

Helper for alignFeat; ignore

crushAvPair :: AvPair SchemaVal -> Maybe (AvPair GeniVal)

Flatten a fancy disjunction attribute-value pair

See crushOne for details

crushFlist :: Flist SchemaVal -> Maybe (Flist GeniVal)

Flatten a fancy-disjunction feature structure

See crushOne for details

Orphan instances

Pretty (FeatStruct GeniVal)

Methods

pretty :: FeatStruct GeniVal -> Text

prettyStr :: FeatStruct GeniVal -> String

GeniShow (FeatStruct GeniVal)

Methods

geniShow :: FeatStruct GeniVal -> String

geniShowText :: FeatStruct GeniVal -> Text

DescendGeniVal a => DescendGeniVal (String, a)

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> (String, a) -> (String, a)