Language.Clafer.Common

Documentation

type Result = String

transIdent :: PosIdent -> String

mkIdent :: String -> PosIdent

mkInteger :: Read a => PosInteger -> a

type Ident = PosIdent

getSuper :: IClafer -> [String]

Returns only [] or [_]

getReference :: IClafer -> [String]

Returns only [] or [_]

getSuperAndReference :: IClafer -> [String]

Returns only [] or [_] or [_, _]

getSuperId :: PExp -> String

isEqClaferId :: String -> IClafer -> Bool

mkPLClaferId :: CName -> Bool -> ClaferBinding -> PExp

pExpDefPidPos :: IExp -> PExp

pExpDefPid :: Span -> IExp -> PExp

pExpDef :: String -> Span -> IExp -> PExp

isParent :: PExp -> Bool

isClaferName :: PExp -> Bool

isClaferName' :: PExp -> Bool

getClaferName :: PExp -> String

isTopLevel :: IClafer -> Bool

elemToClafer :: IElement -> Maybe IClafer

toClafers :: [IElement] -> [IClafer]

type UIDIClaferMap = StringMap IClafer

createUidIClaferMap :: IModule -> UIDIClaferMap

findIClafer :: UIDIClaferMap -> UID -> Maybe IClafer

findHierarchy :: (IClafer -> [String]) -> UIDIClaferMap -> IClafer -> [IClafer]

Finds all super clafers according to sFun

mapHierarchy :: (IClafer -> b) -> (IClafer -> [String]) -> UIDIClaferMap -> IClafer -> [b]

Finds hierarchy and transforms each element

findUIDinSupers :: UIDIClaferMap -> UID -> IClafer -> Maybe IClafer

traverse the inheritance hierarchy upwards to find a clafer with the given uidToFind

findUIDinParents :: UIDIClaferMap -> UID -> IClafer -> Maybe IClafer

traverse the containment hierarchy upwards to find a clafer with the given uidToFind

data NestedInheritanceMatch

Constructors

NestedInheritanceMatch

Fields

_headClafer :: IClafer

the clafer for which the match is computed

_parentClafer :: IClafer

parent of the head clafer

_parentsSuperClafer :: Maybe IClafer

parent of the super of the head clafer

_targetClafer :: Maybe IClafer

target of the head clafer

_targetsSuperClafer :: Maybe IClafer

super of the target of the head clafer

_superClafer :: IClafer

super of the head clafer (must exist, otherwise no match)

_superClafersParent :: IClafer

parent of the super of the head clafer

_superClafersTarget :: Maybe IClafer

target of the super of the head clafer

Instances

Show NestedInheritanceMatch

isProperNesting :: UIDIClaferMap -> Maybe NestedInheritanceMatch -> Bool

assumes that isProperNesting m == True

This represents a match of this shape

superClafersParent / <> ?1| * parentsSuperClafer / [=] superClafer --*-> superClafersTarget *| parentClafer | |?2 <> *| [=] targetsSuperClafer * | / | *| headClafer -----*-----> targetClafer

The clafers are obtained by navigating from the headClafer by following the links marked by * The link marked by ?1 is checked for correctness of nesting (isProperNesting): - _uid parentsSuperClafer == _parentUID superClafer The link marked by ?2 is checked for correctness of redefinition (isProperRefinement): - proper subtyping, bag to set, proper cardinality restriction Redefinition occurs when the name of headClafer is the same as the name of superClafer (isProperRedefinition): - isProperNesting && isProperRefinement && (_ident headClafer) == (_ident superClafer)

isProperRefinement :: UIDIClaferMap -> Maybe NestedInheritanceMatch -> (Bool, Bool, Bool)

assumes that isProperNesting m == True and isProperRefinement m == (True, True, True)

isRedefinition

Arguments

:: Maybe NestedInheritanceMatch

-> Bool

whether the name of headClafer is the same as superClafer

try to match the nested inheritance pattern ^ only available after the parentUIDs were computed

matchNestedInheritance :: UIDIClaferMap -> IClafer -> Maybe NestedInheritanceMatch

apply :: forall t t1. (t -> t1) -> t -> (t, t1)

bfs :: forall b b1. (b1 -> (b, [b1])) -> [b1] -> [b]

toNodeShallow :: IClafer -> (IClafer, [IClafer])

getSubclafers :: [IElement] -> [IClafer]

bfsClafers :: [IClafer] -> [IClafer]

lurry :: forall t t1. ([t1] -> t) -> t1 -> t1 -> t

fst3 :: forall t t1 t2. (t, t1, t2) -> t

snd3 :: forall t t1 t2. (t, t1, t2) -> t1

trd3 :: forall t t1 t2. (t, t1, t2) -> t2

toTriple :: forall t t1 t2. t -> (t1, t2) -> (t, t1, t2)

toMTriple :: forall t t1 t2. t -> (t1, t2) -> Maybe (t, t1, t2)

iNot :: String

iCSet :: String

iMin :: String

iGMax :: String

iGMin :: String

iSumSet :: String

iProdSet :: String

unOps :: [String]

iIff :: String

iImpl :: String

iOr :: String

iXor :: String

iAnd :: String

logBinOps :: [String]

iLt :: String

iGt :: String

iEq :: String

iLte :: String

iGte :: String

iNeq :: String

iIn :: String

iNin :: String

relGenBinOps :: [String]

relSetBinOps :: [String]

relBinOps :: [String]

iPlus :: String

iSub :: String

iMul :: String

iDiv :: String

iRem :: String

iSumSet' :: String

arithBinOps :: [String]

iUnion :: String

iDifference :: String

iIntersection :: String

iDomain :: String

iRange :: String

iJoin :: String

setBinOps :: [String]

binOps :: [String]

iIfThenElse :: String

mkIFunExp :: String -> [IExp] -> IExp

toLowerS :: String -> String

rootIdent :: String

rootUID :: String

thisIdent :: String

parentIdent :: String

refIdent :: String

childrenIdent :: String

specialNames :: [String]

isSpecial :: String -> Bool

stringType :: String

intType :: String

integerType :: String

realType :: String

booleanType :: String

baseClafer :: String

modSep :: String

primitiveTypes :: [String]

isPrimitive :: String -> Bool

keywordIdents :: [String]

reserved keywords which cannot be used as clafer identifiers

data GEnv

Constructors

GEnv

Fields

identCountMap :: Map String Int

expCount :: Int

stable :: Map UID [[UID]]

sClafers :: [IClafer]

uidClaferMap :: UIDIClaferMap

Instances

Eq GEnv

Show GEnv

voidf :: Monad m => m t -> m ()

safeTail :: [a] -> [a]