Safe Haskell | None |
---|
The scope monad with operations.
- type ScopeM = TCM
- isDatatypeModule :: ModuleName -> ScopeM Bool
- getCurrentModule :: ScopeM ModuleName
- setCurrentModule :: ModuleName -> ScopeM ()
- withCurrentModule :: ModuleName -> ScopeM a -> ScopeM a
- withCurrentModule' :: (MonadTrans t, Monad (t ScopeM)) => ModuleName -> t ScopeM a -> t ScopeM a
- getNamedScope :: ModuleName -> ScopeM Scope
- getCurrentScope :: ScopeM Scope
- createModule :: Bool -> ModuleName -> ScopeM ()
- modifyScopeInfo :: (ScopeInfo -> ScopeInfo) -> ScopeM ()
- modifyScopes :: (Map ModuleName Scope -> Map ModuleName Scope) -> ScopeM ()
- modifyNamedScope :: ModuleName -> (Scope -> Scope) -> ScopeM ()
- modifyCurrentScope :: (Scope -> Scope) -> ScopeM ()
- modifyNamedScopeM :: ModuleName -> (Scope -> ScopeM Scope) -> ScopeM ()
- modifyCurrentScopeM :: (Scope -> ScopeM Scope) -> ScopeM ()
- modifyCurrentNameSpace :: NameSpaceId -> (NameSpace -> NameSpace) -> ScopeM ()
- setContextPrecedence :: Precedence -> ScopeM ()
- getContextPrecedence :: ScopeM Precedence
- withContextPrecedence :: Precedence -> ScopeM a -> ScopeM a
- getLocalVars :: ScopeM LocalVars
- setLocalVars :: LocalVars -> ScopeM ()
- withLocalVars :: ScopeM a -> ScopeM a
- freshAbstractName :: Fixity' -> Name -> ScopeM Name
- freshAbstractName_ :: Name -> ScopeM Name
- freshAbstractQName :: Fixity' -> Name -> ScopeM QName
- data ResolvedName
- resolveName :: QName -> ScopeM ResolvedName
- resolveName' :: [KindOfName] -> QName -> ScopeM ResolvedName
- resolveModule :: QName -> ScopeM AbstractModule
- getFixity :: QName -> ScopeM Fixity'
- bindVariable :: Name -> Name -> ScopeM ()
- bindName :: Access -> KindOfName -> Name -> QName -> ScopeM ()
- bindModule :: Access -> Name -> ModuleName -> ScopeM ()
- bindQModule :: Access -> QName -> ModuleName -> ScopeM ()
- stripNoNames :: ScopeM ()
- type Ren a = Map a a
- type Out = (Ren ModuleName, Ren QName)
- type WSM = StateT Out ScopeM
- copyScope :: QName -> ModuleName -> Scope -> ScopeM (Scope, (Ren ModuleName, Ren QName))
- applyImportDirectiveM :: QName -> ImportDirective -> Scope -> ScopeM Scope
- openModule_ :: QName -> ImportDirective -> ScopeM ()
The scope checking monad
To simplify interaction between scope checking and type checking (in particular when chasing imports), we use the same monad.
Errors
General operations
setCurrentModule :: ModuleName -> ScopeM ()Source
withCurrentModule :: ModuleName -> ScopeM a -> ScopeM aSource
withCurrentModule' :: (MonadTrans t, Monad (t ScopeM)) => ModuleName -> t ScopeM a -> t ScopeM aSource
createModule :: Bool -> ModuleName -> ScopeM ()Source
Create a new module with an empty scope (Bool is True if it is a datatype module)
modifyScopeInfo :: (ScopeInfo -> ScopeInfo) -> ScopeM ()Source
Apply a function to the scope info.
modifyScopes :: (Map ModuleName Scope -> Map ModuleName Scope) -> ScopeM ()Source
Apply a function to the scope map.
modifyNamedScope :: ModuleName -> (Scope -> Scope) -> ScopeM ()Source
Apply a function to the given scope.
modifyCurrentScope :: (Scope -> Scope) -> ScopeM ()Source
Apply a function to the current scope.
modifyNamedScopeM :: ModuleName -> (Scope -> ScopeM Scope) -> ScopeM ()Source
Apply a monadic function to the top scope.
modifyCurrentNameSpace :: NameSpaceId -> (NameSpace -> NameSpace) -> ScopeM ()Source
Apply a function to the public or private name space.
setContextPrecedence :: Precedence -> ScopeM ()Source
withContextPrecedence :: Precedence -> ScopeM a -> ScopeM aSource
setLocalVars :: LocalVars -> ScopeM ()Source
withLocalVars :: ScopeM a -> ScopeM aSource
Run a computation without changing the local variables.
Names
freshAbstractName :: Fixity' -> Name -> ScopeM NameSource
Create a fresh abstract name from a concrete name.
freshAbstractName_ :: Name -> ScopeM NameSource
freshAbstractName_ = freshAbstractName defaultFixity
Resolving names
data ResolvedName Source
VarName Name | |
DefinedName Access AbstractName | |
FieldName AbstractName | record fields names need to be distinguished to parse copatterns |
ConstructorName [AbstractName] | |
PatternSynResName AbstractName | |
UnknownName |
resolveName :: QName -> ScopeM ResolvedNameSource
Look up the abstract name referred to by a given concrete name.
resolveName' :: [KindOfName] -> QName -> ScopeM ResolvedNameSource
Look up the abstract name corresponding to a concrete name of a certain kind. Sometimes we know already that we are dealing with a constructor or pattern synonym (e.g. when we have parsed a pattern). Then, we can ignore conflicting definitions of that name of a different kind. (See issue 822.)
resolveModule :: QName -> ScopeM AbstractModuleSource
Look up a module in the scope.
getFixity :: QName -> ScopeM Fixity'Source
Get the fixity of a name. The name is assumed to be in scope.
Binding names
bindVariable :: Name -> Name -> ScopeM ()Source
Bind a variable. The abstract name is supplied as the second argument.
bindName :: Access -> KindOfName -> Name -> QName -> ScopeM ()Source
Bind a defined name. Must not shadow anything.
bindModule :: Access -> Name -> ModuleName -> ScopeM ()Source
Bind a module name.
bindQModule :: Access -> QName -> ModuleName -> ScopeM ()Source
Bind a qualified module name. Adds it to the imports field of the scope.
Module manipulation operations
stripNoNames :: ScopeM ()Source
Clear the scope of any no names.
copyScope :: QName -> ModuleName -> Scope -> ScopeM (Scope, (Ren ModuleName, Ren QName))Source
Create a new scope with the given name from an old scope. Renames public names in the old scope to match the new name and returns the renamings.
applyImportDirectiveM :: QName -> ImportDirective -> Scope -> ScopeM ScopeSource
Apply an import directive and check that all the names mentioned actually exist.
openModule_ :: QName -> ImportDirective -> ScopeM ()Source
Open a module.