Language.Clafer.Intermediate.Analysis

Documentation

newtype AnalysisT m a

Constructors

AnalysisT (ReaderT Info m a)

Instances

MonadTrans AnalysisT

MonadError e m => MonadError e (AnalysisT m)

Monad m => MonadReader Info (AnalysisT m)

MonadState s m => MonadState s (AnalysisT m)

Monad m => Monad (AnalysisT m)

Functor m => Functor (AnalysisT m)

MonadPlus m => MonadPlus (AnalysisT m)

Applicative m => Applicative (AnalysisT m)

(Monad m, Functor m) => MonadAnalysis (AnalysisT m)

type Analysis = AnalysisT Identity

class (Monad m, Functor m) => MonadAnalysis m where

Methods

clafers :: m [SClafer]

withClafers :: [SClafer] -> m a -> m a

Instances

MonadAnalysis m => MonadAnalysis (MaybeT m)

MonadAnalysis m => MonadAnalysis (VSupplyT m)

MonadAnalysis m => MonadAnalysis (ListT m)

(Monad m, Functor m) => MonadAnalysis (AnalysisT m)

(Error e, MonadAnalysis m) => MonadAnalysis (ErrorT e m)

MonadAnalysis m => MonadAnalysis (ReaderT r m)

(Monoid w, MonadAnalysis m) => MonadAnalysis (WriterT w m)

withExtraClafers :: MonadAnalysis m => [SClafer] -> m a -> m a

isConcrete :: SClafer -> Bool

isBase :: SClafer -> Bool

isDerived :: SClafer -> Bool

data SSuper

Constructors

Ref String

Colon String

Instances

Show SSuper

data SClafer

Easier to work with. IClafers have links from parents to children. SClafers have links from children to parent.

Constructors

SClafer

Fields

uid :: String

origUid :: String

isAbstract :: Bool

low :: Integer

high :: Integer

groupLow :: Integer

groupHigh :: Integer

parent :: Maybe String

super :: Maybe SSuper

constraints :: [PExp]

Instances

Show SClafer

Matchable SClafer

Uidable SClafer

data Info

Constructors

Info

Fields

sclafers :: [SClafer]

Instances

Show Info

Monad m => MonadReader Info (AnalysisT m)

runAnalysis :: Analysis a -> Info -> a

runAnalysisT :: AnalysisT m a -> Info -> m a

claferWithUid :: MonadAnalysis m => String -> m SClafer

parentUid :: Monad m => SClafer -> m String

parentOf :: (Uidable c, MonadAnalysis m) => c -> m c

parentsOf :: (Uidable c, MonadAnalysis m) => c -> m [c]

ancestorsOf :: (Uidable c, MonadAnalysis m) => c -> m [c]

directChildrenOf :: (Uidable c, MonadAnalysis m) => c -> m [c]

directDescendantsOf :: (Uidable c, MonadAnalysis m) => c -> m [c]

topNonRootAncestor :: (Uidable c, MonadAnalysis m) => c -> m c

refUid :: Monad m => SClafer -> m String

refOf :: (Uidable c, MonadAnalysis m) => c -> m c

refsOf :: (Uidable c, MonadAnalysis m) => c -> m [c]

colonUid :: (Uidable c, MonadAnalysis m) => c -> m String

colonOf :: (Uidable c, MonadAnalysis m) => c -> m c

colonsOf :: (Uidable c, MonadAnalysis m) => c -> m [c]

colonsTo :: (Uidable c, MonadAnalysis m) => c -> m [c]

hierarchy :: (Uidable c, MonadAnalysis m) => c -> m [c]

isDirectChild :: (Uidable c, MonadAnalysis m) => c -> c -> m Bool

isIndirectChild :: (Uidable c, MonadAnalysis m) => c -> c -> m Bool

isChild :: (Uidable c, MonadAnalysis m) => c -> c -> m Bool

class Matchable c => Uidable c where

Methods

toClafer :: MonadAnalysis m => c -> m SClafer

fromClafer :: MonadAnalysis m => SClafer -> m c

toUid :: MonadAnalysis m => c -> m String

fromUid :: MonadAnalysis m => String -> m c

Instances

Uidable String

Uidable SClafer

data Anything

Constructors

Anything

Instances

Matchable Anything

class Matchable u where

Methods

matches :: u -> SClafer -> Bool

Instances

Matchable String

Matchable Anything

Matchable SClafer

anything :: Anything

(|^) :: (MonadAnalysis m, Matchable a, Matchable b) => a -> b -> m [(SClafer, SClafer)]

(|->) :: (MonadAnalysis m, Matchable a, Matchable b) => a -> b -> m [(SClafer, SClafer)]

(|:) :: (MonadAnalysis m, Matchable a, Matchable b) => a -> b -> m [(SClafer, SClafer)]

constraintsUnder :: (MonadAnalysis m, Matchable a) => a -> m [(SClafer, PExp)]

rootUid :: String

convertClafer :: IClafer -> [SClafer]

gatherInfo :: IModule -> Info

liftMaybe :: Monad m => Maybe a -> MaybeT m a

liftList :: Monad m => [a] -> ListT m a

runListT_ :: Monad m => ListT m a -> m ()

foreach :: m [a] -> ListT m a

foreachM :: Monad m => [a] -> ListT m a

subClafers :: (a, b) -> a

superClafers :: (a, b) -> b

findAll :: Monad m => m a -> ListT m a

select :: Monad m => m [a] -> (a -> b) -> m [b]

suchThat :: Monad m => m [a] -> (a -> Bool) -> m [a]

concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]

whenM :: Monad m => m Bool -> m () -> m ()

unlessM :: Monad m => m Bool -> m () -> m ()

fromMaybeT :: Monad m => a -> MaybeT m a -> m a

mapMaybeT :: (m1 (Maybe a1) -> m (Maybe a)) -> MaybeT m1 a1 -> MaybeT m a

mapVSupplyT :: (Monad m, Monad m1) => (m1 a1 -> m a) -> VSupplyT m1 a1 -> VSupplyT m a

mapLeft :: (t -> a) -> Either t b -> Either a b

mapRight :: (t -> b) -> Either a t -> Either a b

(<:>) :: Monad m => m a -> m [a] -> m [a]

testing :: Eq b => (a -> b) -> a -> a -> Bool

comparing :: Ord b => (a -> b) -> a -> a -> Ordering

syntaxOf :: PExp -> String

combine :: Ord a => [(a, b)] -> [(a, [b])]

sameAs :: PExp -> PExp -> Bool