Safe Haskell | None |
---|
- data GeniVal
- gLabel :: GeniVal -> Maybe Text
- gConstraints :: GeniVal -> Maybe (FullList Text)
- mkGConst :: FullList Text -> GeniVal
- mkGConstNone :: Text -> GeniVal
- mkGVar :: Text -> Maybe (FullList Text) -> GeniVal
- mkGVarNone :: Text -> GeniVal
- mkGAnon :: GeniVal
- isVar :: GeniVal -> Bool
- isAnon :: GeniVal -> Bool
- isConst :: GeniVal -> Bool
- singletonVal :: GeniVal -> Maybe Text
- crushOne :: [GeniVal] -> Maybe GeniVal
- finaliseVars :: (Collectable a, DescendGeniVal a) => Text -> a -> a
- finaliseVarsById :: (Collectable a, DescendGeniVal a, Idable a) => a -> a
- unify :: Monad m => [GeniVal] -> [GeniVal] -> m ([GeniVal], Subst)
- data UnificationResult
- type Subst = Map Text GeniVal
- appendSubst :: Subst -> Subst -> Subst
- subsumeOne :: GeniVal -> GeniVal -> UnificationResult
- allSubsume :: Monad m => [GeniVal] -> [GeniVal] -> m ([GeniVal], Subst)
- class DescendGeniVal a where
- descendGeniVal :: (GeniVal -> GeniVal) -> a -> a
- class Collectable a where
- collect :: a -> Map CollectedVar Int -> Map CollectedVar Int
- class Idable a where
- replace :: DescendGeniVal a => Subst -> a -> a
- replaceList :: DescendGeniVal a => [(Text, GeniVal)] -> a -> a
GeniVal
constant : no label, just constraints variable : label, with or without constraints anonymous : no label, no constraints
Eq GeniVal | |
Data GeniVal | |
Ord GeniVal | |
Typeable GeniVal | |
Binary GeniVal | |
NFData GeniVal | |
Pretty GeniVal | |
Pretty SemInput | |
Pretty Sem | |
GeniShow GeniVal | |
GeniShow SemInput | |
GeniShow Sem | |
DescendGeniVal GeniVal | |
Collectable GeniVal | |
HasConstants GeniVal | |
GeniValLike GeniVal | |
Loadable Macros | |
Pretty (FeatStruct GeniVal) | |
Pretty (AvPair GeniVal) | |
Pretty (Flist GeniVal) | |
Pretty (Literal GeniVal) | |
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 |
GeniShow (FeatStruct GeniVal) | |
GeniShow (AvPair GeniVal) | |
GeniShow (Flist GeniVal) | |
GeniShow (Literal GeniVal) | |
GeniShow (GNode GeniVal) | |
HasConstants (Literal GeniVal) | |
GeniValLike [GeniVal] |
mkGConstNone :: Text -> GeniValSource
mkGVarNone :: Text -> GeniValSource
queries and manipulation
singletonVal :: GeniVal -> Maybe TextSource
Unification and subsumption
Finalisation
finaliseVars :: (Collectable a, DescendGeniVal a) => Text -> a -> aSource
finaliseVars
does the following:
- (if suffix is non-null) appends a suffix to all variable names to ensure global uniqueness
- anonymises any singleton variables
finaliseVarsById :: (Collectable a, DescendGeniVal a, Idable a) => a -> aSource
Unification
data UnificationResult Source
appendSubst :: Subst -> Subst -> SubstSource
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 -> UnificationResultSource
subsumeOne
x y
returns the same result as unifyOne x y
if x
subsumes y
or Failure
otherwise
allSubsume :: Monad m => [GeniVal] -> [GeniVal] -> m ([GeniVal], Subst)Source
l1
returns the result of allSubsume
l2l1
if
doing a simultaneous traversal of both lists, each item in
unify
l2l1
subsumes the corresponding item in l2
Traversing GeniVal containers
class DescendGeniVal a whereSource
descendGeniVal :: (GeniVal -> GeniVal) -> a -> aSource
DescendGeniVal GeniVal | |
DescendGeniVal LexEntry | |
DescendGeniVal TagElem | |
DescendGeniVal TagSite | |
DescendGeniVal UninflectedDisjunction | |
DescendGeniVal SimpleItem | |
(Functor f, DescendGeniVal a) => DescendGeniVal (f a) | |
DescendGeniVal v => DescendGeniVal (AvPair v) | |
DescendGeniVal a => DescendGeniVal (Literal a) | |
DescendGeniVal v => DescendGeniVal (GNode v) | |
DescendGeniVal v => DescendGeniVal (Ttree v) | |
DescendGeniVal v => DescendGeniVal ([String], Flist v) | |
DescendGeniVal a => DescendGeniVal (String, a) | |
DescendGeniVal (Text, UninflectedDisjunction) | |
DescendGeniVal a => DescendGeniVal (Map k a) |
class Collectable a whereSource
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.
collect :: a -> Map CollectedVar Int -> Map CollectedVar IntSource
Collectable GeniVal | |
Collectable LexEntry | |
Collectable TagElem | |
Collectable UninflectedDisjunction | |
Collectable a => Collectable [a] | |
Collectable a => Collectable (Maybe a) | |
Collectable a => Collectable (Tree a) | |
Collectable a => Collectable (AvPair a) | |
Collectable a => Collectable (Literal a) | |
Collectable gv => Collectable (GNode gv) | |
Collectable a => Collectable (Ttree a) |
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.
replace :: DescendGeniVal a => Subst -> a -> aSource
replaceList :: DescendGeniVal a => [(Text, GeniVal)] -> a -> aSource
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)