NLP.GenI.GeniVal

GenI values (variables, constants)

GeniVal

data GeniVal

• constant : no label, just constraints
• variable : label, with or without constraints
• anonymous : no label, no constraints

Instances

Eq GeniVal

Methods

(==) :: GeniVal -> GeniVal -> Bool

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

Data GeniVal

Methods

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

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

toConstr :: GeniVal -> Constr

dataTypeOf :: GeniVal -> DataType

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

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

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

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

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

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

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

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

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

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

Ord GeniVal

Methods

compare :: GeniVal -> GeniVal -> Ordering

(<) :: GeniVal -> GeniVal -> Bool

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

(>) :: GeniVal -> GeniVal -> Bool

(>=) :: GeniVal -> GeniVal -> Bool

max :: GeniVal -> GeniVal -> GeniVal

min :: GeniVal -> GeniVal -> GeniVal

Binary GeniVal

Methods

put :: GeniVal -> Put

get :: Get GeniVal

putList :: [GeniVal] -> Put

NFData GeniVal

Methods

rnf :: GeniVal -> ()

Pretty GeniVal

Methods

pretty :: GeniVal -> Text

prettyStr :: GeniVal -> String

Pretty SemInput

Methods

pretty :: SemInput -> Text

prettyStr :: SemInput -> String

Pretty Sem

Methods

pretty :: Sem -> Text

prettyStr :: Sem -> String

GeniShow GeniVal

Methods

geniShow :: GeniVal -> String

geniShowText :: GeniVal -> Text

GeniShow SemInput

Methods

geniShow :: SemInput -> String

geniShowText :: SemInput -> Text

GeniShow LitConstr

Methods

geniShow :: LitConstr -> String

geniShowText :: LitConstr -> Text

GeniShow Sem

Methods

geniShow :: Sem -> String

geniShowText :: Sem -> Text

DescendGeniVal GeniVal

Methods

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

Collectable GeniVal

Methods

collect :: GeniVal -> Map CollectedVar Int -> Map CollectedVar Int

HasConstants GeniVal

Methods

constants :: GeniVal -> Int

Pretty (AvPair GeniVal)

Methods

pretty :: AvPair GeniVal -> Text

prettyStr :: AvPair GeniVal -> String

Pretty (Flist GeniVal)

Methods

pretty :: Flist GeniVal -> Text

prettyStr :: Flist GeniVal -> String

Pretty (Literal GeniVal)

Methods

pretty :: Literal GeniVal -> Text

prettyStr :: Literal GeniVal -> String

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 (Literal GeniVal)

Methods

geniShow :: Literal GeniVal -> String

geniShowText :: Literal GeniVal -> Text

HasConstants (Literal GeniVal)

Methods

constants :: Literal GeniVal -> Int

gLabel :: GeniVal -> Maybe Text

Optional label (?X would have Just X)

gConstraints :: GeniVal -> Maybe (FullList Text)

Optional values/constraints Must have at least one if at all

Though it may seem a bit redudant, this is not quite the same as having '[Text]' because Nothing means no constraints; whereas Just [] (impossible here) would mean bottom.

mkGConst

Arguments

:: FullList Text

non-empty list

-> GeniVal

mkGConst x :! [] creates a single constant. mkGConst x :! xs creates an atomic disjunction. It makes no difference which of the values you supply for x and xs as they will be sorted and nubed anyway.

mkGConstNone :: Text -> GeniVal

Create a singleton constant (no disjunction here)

mkGVar

Arguments

:: Text

label

-> Maybe (FullList Text)

constraints

-> GeniVal

Create a variable

mkGVarNone :: Text -> GeniVal

Create a variable with no constraints

mkGAnon :: GeniVal

Create an anonymous value

queries and manipulation

isAnon :: GeniVal -> Bool

An anonymous GeniVal (_ or ?_) has no labels/constraints

singletonVal :: GeniVal -> Maybe Text

If v has exactly one value/constraint, returns it

fancy disjunction

newtype 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.

Constructors

SchemaVal [GeniVal]

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

crushOne :: SchemaVal -> Maybe GeniVal

Convert a fancy disjunction (allowing disjunction over variables) value into a plain old atomic disjunction. The idea is to support a limited notion of fancy disjunction by requiring that there be a single point where this disjunction can be converted into a plain old variable. Note that we currently convert these to constants only.

Unification and subsumption

Finalisation

finaliseVars :: (Collectable a, DescendGeniVal a) => Text -> a -> a

finaliseVars does the following:

• (if suffix is non-null) appends a suffix to all variable names to ensure global uniqueness
• intersects constraints for for all variables within the same object

finaliseVarsById :: (Collectable a, DescendGeniVal a, Idable a) => a -> a

finaliseVarsById appends a unique suffix to all variables in an object. This avoids us having to alpha convert all the time and relies on the assumption finding that a unique suffix is possible.

anonymiseSingletons :: (Collectable a, DescendGeniVal a) => a -> a

Anonymise any variable that occurs only once in the object

Unification

class (MonadPlus m, MonadError String m, Functor m) => MonadUnify m

Instances

MonadUnify (Either String)

unify :: MonadUnify m => [GeniVal] -> [GeniVal] -> m ([GeniVal], Subst)

unify performs unification on two lists of GeniVal. If unification succeeds, it returns Just (r,s) where r is the result of unification and verb!s! is a list of substitutions that this unification results in.

data UnificationResult

Unification can either…

Constructors

SuccessSans GeniVal

succeed for free (no substitutions),

SuccessRep Text GeniVal

succeed with a one-way substitution,

SuccessRep2 Text Text GeniVal

succeed w both vars needing substitution (constraint intersection),

Failure

or fail

type Subst = Map Text GeniVal

A variable substitution map. GenI unification works by rewriting variables

appendSubst :: Subst -> Subst -> Subst

Note that the first Subst is assumed to come chronologically before the second one; so merging { X -> Y } and { Y -> 3 } should give us { X -> 3; Y -> 3 };

See prependToSubst for a warning!

subsumption

subsumeOne :: GeniVal -> GeniVal -> UnificationResult

subsumeOne x y returns the same result as unifyOne x y if x subsumes y or Failure otherwise

allSubsume :: MonadUnify m => [GeniVal] -> [GeniVal] -> m ([GeniVal], Subst)

l1 allSubsume l2 returns the result of l1 unify l2 if doing a simultaneous traversal of both lists, each item in l1 subsumes the corresponding item in l2

Traversing GeniVal containers

class DescendGeniVal a where

A structure that can be traversed with a GeniVal-replacing function (typical use case: substitution after unification)

Approach suggested by Neil Mitchell after I found that Uniplate seemed to hurt GenI performance a bit.

Minimal complete definition

descendGeniVal

Methods

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

descendGeniVal f x applies f to all GeniVal in x

Instances

DescendGeniVal SchemaVal

Methods

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

DescendGeniVal GeniVal

Methods

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

DescendGeniVal LexEntry

Methods

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

DescendGeniVal TagElem

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> TagElem -> TagElem

DescendGeniVal TagSite

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> TagSite -> TagSite

DescendGeniVal UninflectedDisjunction

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> UninflectedDisjunction -> UninflectedDisjunction

DescendGeniVal SimpleItem

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> SimpleItem -> SimpleItem

(Functor f, DescendGeniVal a) => DescendGeniVal (f a)

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> f a -> f a

DescendGeniVal v => DescendGeniVal (AvPair v)

Methods

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

DescendGeniVal a => DescendGeniVal (Literal a)

Methods

descendGeniVal :: (GeniVal -> GeniVal) -> Literal a -> Literal a

DescendGeniVal v => DescendGeniVal (GNode v)

Methods

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

DescendGeniVal v => DescendGeniVal (Ttree v)

Methods

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

class Collectable a where

A Collectable is something which can return its variables as a map from the variable to the number of times that variable occurs in it.

Important invariant: if the variable does not occur, then it does not appear in the map (ie. all counts must be >= 1 or the item does not occur at all)

By variables, what I most had in mind was the GVar values in a GeniVal. This notion is probably not very useful outside the context of alpha-conversion task, but it seems general enough that I'll keep it around for a good bit, until either some use for it creeps up, or I find a more general notion that I can transform this into.

Minimal complete definition

collect

Methods

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

collect x m increments our count for any variables in x (adds not-yet-seen variables as needed)

Instances

Collectable SchemaVal

Methods

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

Collectable GeniVal

Methods

collect :: GeniVal -> Map CollectedVar Int -> Map CollectedVar Int

Collectable LexEntry

Methods

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

Collectable TagElem

Methods

collect :: TagElem -> Map CollectedVar Int -> Map CollectedVar Int

Collectable UninflectedDisjunction

Methods

collect :: UninflectedDisjunction -> Map CollectedVar Int -> Map CollectedVar Int

Collectable a => Collectable [a]

Methods

collect :: [a] -> Map CollectedVar Int -> Map CollectedVar Int

Collectable a => Collectable (Maybe a)

Methods

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

Collectable a => Collectable (AvPair a)

Methods

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

Collectable a => Collectable (Literal a)

Methods

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

Collectable gv => Collectable (GNode gv)

Methods

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

Collectable a => Collectable (Ttree a)

Methods

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

class Idable a where

An Idable is something that can be mapped to a unique id. You might consider using this to implement Ord, but I won't. Note that the only use I have for this so far (20 dec 2005) is in alpha-conversion.

Minimal complete definition

idOf

Methods

idOf :: a -> Integer

Instances

Idable TagElem

Methods

idOf :: TagElem -> Integer

replace :: DescendGeniVal a => Subst -> a -> a

Apply variable substitutions

replaceList :: DescendGeniVal a => [(Text, GeniVal)] -> a -> a

Here it is safe to say (X -> Y; Y -> Z) because this would be crushed down into a final value of (X -> Z; Y -> Z)