| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Agda.Syntax.Scope.Base
Description
This module defines the notion of a scope and operations on scopes.
Synopsis
- data Scope = Scope {}
- data DataOrRecordModule
- data NameSpaceId
- allNameSpaces :: [NameSpaceId]
- type ScopeNameSpaces = [(NameSpaceId, NameSpace)]
- localNameSpace :: Access -> NameSpaceId
- nameSpaceAccess :: NameSpaceId -> Access
- scopeNameSpace :: NameSpaceId -> Scope -> NameSpace
- updateScopeNameSpaces :: (ScopeNameSpaces -> ScopeNameSpaces) -> Scope -> Scope
- updateScopeNameSpacesM :: Functor m => (ScopeNameSpaces -> m ScopeNameSpaces) -> Scope -> m Scope
- data ScopeInfo = ScopeInfo {}
- data NameMapEntry = NameMapEntry {}
- type NameMap = Map QName NameMapEntry
- type ModuleMap = Map ModuleName [QName]
- type LocalVars = AssocList Name LocalVar
- data BindingSource
- data LocalVar = LocalVar {}
- shadowLocal :: List1 AbstractName -> LocalVar -> LocalVar
- patternToModuleBound :: LocalVar -> LocalVar
- notShadowedLocal :: LocalVar -> Maybe Name
- notShadowedLocals :: LocalVars -> AssocList Name Name
- scopeCurrent :: Lens' ScopeInfo ModuleName
- scopeModules :: Lens' ScopeInfo (Map ModuleName Scope)
- scopeVarsToBind :: Lens' ScopeInfo LocalVars
- scopeLocals :: Lens' ScopeInfo LocalVars
- scopePrecedence :: Lens' ScopeInfo PrecedenceStack
- scopeInverseName :: Lens' ScopeInfo NameMap
- scopeInverseModule :: Lens' ScopeInfo ModuleMap
- scopeInScope :: Lens' ScopeInfo InScopeSet
- scopeFixities :: Lens' ScopeInfo Fixities
- scopePolarities :: Lens' ScopeInfo Polarities
- scopeFixitiesAndPolarities :: Lens' ScopeInfo (Fixities, Polarities)
- updateVarsToBind :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo
- setVarsToBind :: LocalVars -> ScopeInfo -> ScopeInfo
- updateScopeLocals :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo
- setScopeLocals :: LocalVars -> ScopeInfo -> ScopeInfo
- data NameSpace = NameSpace {}
- type ThingsInScope a = Map Name (List1 a)
- type NamesInScope = ThingsInScope AbstractName
- type ModulesInScope = ThingsInScope AbstractModule
- type InScopeSet = Set QName
- data InScopeTag a where
- class Ord a => InScope a where
- inScopeTag :: InScopeTag a
- inNameSpace :: forall a. InScope a => NameSpace -> ThingsInScope a
- data NameOrModule
- data KindOfName
- isDefName :: KindOfName -> Bool
- isConName :: KindOfName -> Maybe Induction
- conKindOfName :: Induction -> KindOfName
- conKindOfName' :: Foldable t => t Induction -> KindOfName
- approxConInduction :: Foldable t => t Induction -> Induction
- exactConInduction :: Foldable t => t Induction -> Maybe Induction
- exactConName :: Foldable t => t Induction -> Maybe KindOfName
- data KindsOfNames
- elemKindsOfNames :: KindOfName -> KindsOfNames -> Bool
- allKindsOfNames :: KindsOfNames
- someKindsOfNames :: [KindOfName] -> KindsOfNames
- exceptKindsOfNames :: [KindOfName] -> KindsOfNames
- data WithKind a = WithKind {
- theKind :: KindOfName
- kindedThing :: a
- data WhyInScope
- data AbstractName = AbsName {}
- data NameMetadata
- data AbstractModule = AbsModule {}
- lensAnameName :: Lens' AbstractName QName
- lensAmodName :: Lens' AbstractModule ModuleName
- data ResolvedName
- data AmbiguousNameReason
- ambiguousNamesInReason :: AmbiguousNameReason -> List2 QName
- data WhyInScopeData = WhyInScopeData QName FilePath (Maybe LocalVar) [AbstractName] [AbstractModule]
- whyInScopeDataFromAmbiguousNameReason :: QName -> AmbiguousNameReason -> WhyInScopeData
- mergeNames :: Eq a => ThingsInScope a -> ThingsInScope a -> ThingsInScope a
- mergeNamesMany :: Eq a => [ThingsInScope a] -> ThingsInScope a
- emptyNameSpace :: NameSpace
- mapNameSpace :: (NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet) -> NameSpace -> NameSpace
- zipNameSpace :: (NamesInScope -> NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet -> InScopeSet) -> NameSpace -> NameSpace -> NameSpace
- mapNameSpaceM :: Applicative m => (NamesInScope -> m NamesInScope) -> (ModulesInScope -> m ModulesInScope) -> (InScopeSet -> m InScopeSet) -> NameSpace -> m NameSpace
- emptyScope :: Scope
- emptyScopeInfo :: ScopeInfo
- mapScope :: (NameSpaceId -> NamesInScope -> NamesInScope) -> (NameSpaceId -> ModulesInScope -> ModulesInScope) -> (NameSpaceId -> InScopeSet -> InScopeSet) -> Scope -> Scope
- mapScope_ :: (NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet) -> Scope -> Scope
- mapScopeNS :: NameSpaceId -> (NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet) -> Scope -> Scope
- mapScopeM :: Applicative m => (NameSpaceId -> NamesInScope -> m NamesInScope) -> (NameSpaceId -> ModulesInScope -> m ModulesInScope) -> (NameSpaceId -> InScopeSet -> m InScopeSet) -> Scope -> m Scope
- mapScopeM_ :: Applicative m => (NamesInScope -> m NamesInScope) -> (ModulesInScope -> m ModulesInScope) -> (InScopeSet -> m InScopeSet) -> Scope -> m Scope
- zipScope :: (NameSpaceId -> NamesInScope -> NamesInScope -> NamesInScope) -> (NameSpaceId -> ModulesInScope -> ModulesInScope -> ModulesInScope) -> (NameSpaceId -> InScopeSet -> InScopeSet -> InScopeSet) -> Scope -> Scope -> Scope
- zipScope_ :: (NamesInScope -> NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet -> InScopeSet) -> Scope -> Scope -> Scope
- recomputeInScopeSets :: Scope -> Scope
- filterScope :: (Name -> Bool) -> (Name -> Bool) -> Scope -> Scope
- allNamesInScope :: InScope a => Scope -> ThingsInScope a
- allNamesInScope' :: InScope a => Scope -> ThingsInScope (a, Access)
- findNameInScope :: InScope a => Name -> Scope -> [(a, Access)]
- exportedNamesInScope :: InScope a => Scope -> ThingsInScope a
- namesInScope :: InScope a => [NameSpaceId] -> Scope -> ThingsInScope a
- allThingsInScope :: Scope -> NameSpace
- thingsInScope :: [NameSpaceId] -> Scope -> NameSpace
- mergeScope :: Scope -> Scope -> Scope
- mergeScopes :: [Scope] -> Scope
- setScopeAccess :: NameSpaceId -> Scope -> Scope
- setNameSpace :: NameSpaceId -> NameSpace -> Scope -> Scope
- modifyNameSpace :: NameSpaceId -> (NameSpace -> NameSpace) -> Scope -> Scope
- addNameToScope :: NameSpaceId -> Name -> AbstractName -> Scope -> Scope
- removeNameFromScope :: NameSpaceId -> Name -> Scope -> Scope
- addModuleToScope :: NameSpaceId -> Name -> AbstractModule -> Scope -> Scope
- data UsingOrHiding
- usingOrHiding :: ImportDirective -> UsingOrHiding
- applyImportDirective :: ImportDirective -> Scope -> Scope
- applyImportDirective_ :: ImportDirective -> Scope -> (Scope, (Set Name, Set Name))
- renameCanonicalNames :: Map QName QName -> Map ModuleName ModuleName -> Scope -> Scope
- restrictPrivate :: Scope -> Scope
- restrictLocalPrivate :: ModuleName -> Scope -> Scope
- withoutPrivates :: ScopeInfo -> ScopeInfo
- disallowGeneralizedVars :: Scope -> Scope
- inScopeBecause :: (WhyInScope -> WhyInScope) -> Scope -> Scope
- publicModules :: ScopeInfo -> Map ModuleName Scope
- publicNames :: ScopeInfo -> Set AbstractName
- publicNamesOfModules :: Map ModuleName Scope -> [AbstractName]
- everythingInScope :: ScopeInfo -> NameSpace
- everythingInScopeQualified :: ScopeInfo -> NameSpace
- concreteNamesInScope :: ScopeInfo -> Set QName
- scopeLookup :: InScope a => QName -> ScopeInfo -> [a]
- scopeLookup' :: forall a. InScope a => QName -> ScopeInfo -> [(a, Access)]
- data AllowAmbiguousNames
- isNameInScope :: QName -> ScopeInfo -> Bool
- isNameInScopeUnqualified :: QName -> ScopeInfo -> Bool
- inverseScopeLookupName :: QName -> ScopeInfo -> [QName]
- inverseScopeLookupName' :: AllowAmbiguousNames -> QName -> ScopeInfo -> [QName]
- inverseScopeLookupName'' :: AllowAmbiguousNames -> QName -> ScopeInfo -> Maybe NameMapEntry
- inverseScopeLookupModule :: ModuleName -> ScopeInfo -> [QName]
- inverseScopeLookupModule' :: AllowAmbiguousNames -> ModuleName -> ScopeInfo -> [QName]
- recomputeInverseScopeMaps :: ScopeInfo -> ScopeInfo
- class SetBindingSite a where
- setBindingSite :: Range -> a -> a
- prettyNameSpace :: NameSpace -> [Doc]
- blockOfLines :: Doc -> [Doc] -> [Doc]
Scope representation
A scope is a named collection of names partitioned into public and private names.
Constructors
| Scope | |
Instances
data DataOrRecordModule Source #
Constructors
| IsDataModule | |
| IsRecordModule |
Instances
data NameSpaceId Source #
See Access.
Constructors
| PrivateNS | Things not exported by this module. |
| PublicNS | Things defined and exported by this module. |
| ImportedNS | Things from open public, exported by this module. |
Instances
allNameSpaces :: [NameSpaceId] Source #
type ScopeNameSpaces = [(NameSpaceId, NameSpace)] Source #
localNameSpace :: Access -> NameSpaceId Source #
nameSpaceAccess :: NameSpaceId -> Access Source #
scopeNameSpace :: NameSpaceId -> Scope -> NameSpace Source #
updateScopeNameSpaces :: (ScopeNameSpaces -> ScopeNameSpaces) -> Scope -> Scope Source #
A lens for scopeNameSpaces
updateScopeNameSpacesM :: Functor m => (ScopeNameSpaces -> m ScopeNameSpaces) -> Scope -> m Scope Source #
`Monadic' lens (Functor sufficient).
The complete information about the scope at a particular program point includes the scope stack, the local variables, and the context precedence.
Constructors
| ScopeInfo | |
Fields
| |
Instances
data NameMapEntry Source #
For the sake of highlighting, the _scopeInverseName map also stores
the KindOfName of an A.QName.
Constructors
| NameMapEntry | |
Fields
| |
Instances
data BindingSource Source #
For each bound variable, we want to know whether it was bound by a
λ, Π, module telescope, pattern, or let.
Constructors
| LambdaBound |
|
| PatternBound Hiding |
|
| LetBound | let ... in |
| WithBound | | ... in q |
Instances
A local variable can be shadowed by an import. In case of reference to a shadowed variable, we want to report a scope error.
Constructors
| LocalVar | |
Fields
| |
Instances
| Pretty LocalVar Source # | We show shadowed variables as prefixed by a ".", as not in scope. |
| EmbPrj LocalVar Source # | |
| Generic LocalVar Source # | |
| Show LocalVar Source # | |
| NFData LocalVar Source # | |
Defined in Agda.Syntax.Scope.Base | |
| Eq LocalVar Source # | |
| Ord LocalVar Source # | |
Defined in Agda.Syntax.Scope.Base | |
| type Rep LocalVar Source # | |
Defined in Agda.Syntax.Scope.Base type Rep LocalVar = D1 ('MetaData "LocalVar" "Agda.Syntax.Scope.Base" "Agda-2.7.0.1-LY5YwrqyXvw4P0XfI08pJQ" 'False) (C1 ('MetaCons "LocalVar" 'PrefixI 'True) (S1 ('MetaSel ('Just "localVar") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Name) :*: (S1 ('MetaSel ('Just "localBindingSource") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BindingSource) :*: S1 ('MetaSel ('Just "localShadowedBy") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [AbstractName])))) | |
shadowLocal :: List1 AbstractName -> LocalVar -> LocalVar Source #
Shadow a local name by a non-empty list of imports.
patternToModuleBound :: LocalVar -> LocalVar Source #
Treat patternBound variable as a module parameter
notShadowedLocals :: LocalVars -> AssocList Name Name Source #
Get all locals that are not shadowed by imports.
scopeCurrent :: Lens' ScopeInfo ModuleName Source #
Lenses for ScopeInfo components
updateVarsToBind :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo Source #
Lens for scopeVarsToBind.
updateScopeLocals :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo Source #
Lens for scopeLocals.
Name spaces
A NameSpace contains the mappings from concrete names that the user can
write to the abstract fully qualified names that the type checker wants to
read.
Constructors
| NameSpace | |
Fields
| |
Instances
| Pretty NameSpace Source # | |
| EmbPrj NameSpace Source # | |
| Generic NameSpace Source # | |
| Show NameSpace Source # | |
| NFData NameSpace Source # | |
Defined in Agda.Syntax.Scope.Base | |
| Eq NameSpace Source # | |
| type Rep NameSpace Source # | |
Defined in Agda.Syntax.Scope.Base type Rep NameSpace = D1 ('MetaData "NameSpace" "Agda.Syntax.Scope.Base" "Agda-2.7.0.1-LY5YwrqyXvw4P0XfI08pJQ" 'False) (C1 ('MetaCons "NameSpace" 'PrefixI 'True) (S1 ('MetaSel ('Just "nsNames") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NamesInScope) :*: (S1 ('MetaSel ('Just "nsModules") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ModulesInScope) :*: S1 ('MetaSel ('Just "nsInScope") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 InScopeSet)))) | |
type NamesInScope = ThingsInScope AbstractName Source #
type InScopeSet = Set QName Source #
data InScopeTag a where Source #
Set of types consisting of exactly AbstractName and AbstractModule.
A GADT just for some dependent-types trickery.
Constructors
| NameTag :: InScopeTag AbstractName | |
| ModuleTag :: InScopeTag AbstractModule |
class Ord a => InScope a where Source #
Type class for some dependent-types trickery.
Methods
inScopeTag :: InScopeTag a Source #
Instances
| InScope AbstractModule Source # | |
Defined in Agda.Syntax.Scope.Base Methods | |
| InScope AbstractName Source # | |
Defined in Agda.Syntax.Scope.Base Methods | |
inNameSpace :: forall a. InScope a => NameSpace -> ThingsInScope a Source #
inNameSpace selects either the name map or the module name map from
a NameSpace. What is selected is determined by result type
(using the dependent-type trickery).
data NameOrModule Source #
Non-dependent tag for name or module.
Constructors
| NameNotModule | |
| ModuleNotName |
Instances
Decorated names
data KindOfName Source #
For the sake of parsing left-hand sides, we distinguish constructor and record field names from defined names.
Constructors
| ConName | Constructor name ( |
| CoConName | Constructor name (definitely |
| FldName | Record field name. |
| PatternSynName | Name of a pattern synonym. |
| GeneralizeName | Name to be generalized |
| DisallowedGeneralizeName | Generalizable variable from a let open |
| MacroName | Name of a macro |
| QuotableName | A name that can only be quoted.
Previous category |
| DataName | Name of a |
| RecName | Name of a |
| FunName | Name of a defined function. |
| AxiomName | Name of a |
| PrimName | Name of a |
| OtherDefName | A |
Instances
isDefName :: KindOfName -> Bool Source #
conKindOfName :: Induction -> KindOfName Source #
conKindOfName' :: Foldable t => t Induction -> KindOfName Source #
exactConName :: Foldable t => t Induction -> Maybe KindOfName Source #
Only return [Co]ConName if no ambiguity.
data KindsOfNames Source #
A set of KindOfName, for the sake of elemKindsOfNames.
Constructors
| AllKindsOfNames | |
| SomeKindsOfNames (Set KindOfName) | Only these kinds. |
| ExceptKindsOfNames (Set KindOfName) | All but these Kinds. |
elemKindsOfNames :: KindOfName -> KindsOfNames -> Bool Source #
someKindsOfNames :: [KindOfName] -> KindsOfNames Source #
exceptKindsOfNames :: [KindOfName] -> KindsOfNames Source #
Decorate something with KindOfName
Constructors
| WithKind | |
Fields
| |
Instances
| DeclaredNames KName Source # | |
Defined in Agda.Syntax.Abstract.Views Methods declaredNames :: Collection KName m => KName -> m Source # | |
| Foldable WithKind Source # | |
Defined in Agda.Syntax.Scope.Base Methods fold :: Monoid m => WithKind m -> m # foldMap :: Monoid m => (a -> m) -> WithKind a -> m # foldMap' :: Monoid m => (a -> m) -> WithKind a -> m # foldr :: (a -> b -> b) -> b -> WithKind a -> b # foldr' :: (a -> b -> b) -> b -> WithKind a -> b # foldl :: (b -> a -> b) -> b -> WithKind a -> b # foldl' :: (b -> a -> b) -> b -> WithKind a -> b # foldr1 :: (a -> a -> a) -> WithKind a -> a # foldl1 :: (a -> a -> a) -> WithKind a -> a # elem :: Eq a => a -> WithKind a -> Bool # maximum :: Ord a => WithKind a -> a # minimum :: Ord a => WithKind a -> a # | |
| Traversable WithKind Source # | |
| Functor WithKind Source # | |
| Show a => Show (WithKind a) Source # | |
| Eq a => Eq (WithKind a) Source # | |
| Ord a => Ord (WithKind a) Source # | |
Defined in Agda.Syntax.Scope.Base | |
data WhyInScope Source #
Where does a name come from?
This information is solely for reporting to the user,
see whyInScope.
Constructors
| Defined | Defined in this module. |
| Opened QName WhyInScope | Imported from another module. |
| Applied QName WhyInScope | Imported by a module application. |
Instances
data AbstractName Source #
A decoration of QName.
Constructors
| AbsName | |
Fields
| |
Instances
data NameMetadata Source #
Constructors
| NoMetadata | |
| GeneralizedVarsMetadata (Map QName Name) |
Instances
| EmbPrj NameMetadata Source # | |
| Generic NameMetadata Source # | |
Defined in Agda.Syntax.Scope.Base Associated Types type Rep NameMetadata :: Type -> Type # | |
| Show NameMetadata Source # | |
Defined in Agda.Syntax.Scope.Base Methods showsPrec :: Int -> NameMetadata -> ShowS # show :: NameMetadata -> String # showList :: [NameMetadata] -> ShowS # | |
| NFData NameMetadata Source # | |
Defined in Agda.Syntax.Scope.Base Methods rnf :: NameMetadata -> () # | |
| type Rep NameMetadata Source # | |
Defined in Agda.Syntax.Scope.Base type Rep NameMetadata = D1 ('MetaData "NameMetadata" "Agda.Syntax.Scope.Base" "Agda-2.7.0.1-LY5YwrqyXvw4P0XfI08pJQ" 'False) (C1 ('MetaCons "NoMetadata" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "GeneralizedVarsMetadata" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Map QName Name)))) | |
data AbstractModule Source #
A decoration of abstract syntax module names.
Constructors
| AbsModule | |
Fields
| |
Instances
lensAnameName :: Lens' AbstractName QName Source #
Van Laarhoven lens on anameName.
lensAmodName :: Lens' AbstractModule ModuleName Source #
Van Laarhoven lens on amodName.
data ResolvedName Source #
Constructors
| VarName | Local variable bound by λ, Π, module telescope, pattern, |
Fields
| |
| DefinedName | Function, data/record type, postulate. |
Fields
| |
| FieldName | Record field name. Needs to be distinguished to parse copatterns. |
Fields | |
| ConstructorName | Data or record constructor name. |
| PatternSynResName | Name of pattern synonym. |
Fields
| |
| UnknownName | Unbound name. |
Instances
data AmbiguousNameReason Source #
Why is a resolved name ambiguous? What did it resolve to?
Invariant (statically enforced): At least two resolvents in total.
Constructors
| AmbiguousLocalVar LocalVar (List1 AbstractName) | The name resolves both to a local variable and some declared names. |
| AmbiguousDeclName (List2 AbstractName) | The name resolves to at least 2 declared names. |
Instances
ambiguousNamesInReason :: AmbiguousNameReason -> List2 QName Source #
The flat list of ambiguous names in AmbiguousNameReason.
data WhyInScopeData Source #
Constructors
| WhyInScopeData | |
Fields
| |
Operations on name and module maps.
mergeNames :: Eq a => ThingsInScope a -> ThingsInScope a -> ThingsInScope a Source #
mergeNamesMany :: Eq a => [ThingsInScope a] -> ThingsInScope a Source #
Operations on name spaces
emptyNameSpace :: NameSpace Source #
The empty name space.
mapNameSpace :: (NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet) -> NameSpace -> NameSpace Source #
Map functions over the names and modules in a name space.
zipNameSpace :: (NamesInScope -> NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet -> InScopeSet) -> NameSpace -> NameSpace -> NameSpace Source #
Zip together two name spaces.
mapNameSpaceM :: Applicative m => (NamesInScope -> m NamesInScope) -> (ModulesInScope -> m ModulesInScope) -> (InScopeSet -> m InScopeSet) -> NameSpace -> m NameSpace Source #
Map monadic function over a namespace.
General operations on scopes
emptyScope :: Scope Source #
The empty scope.
emptyScopeInfo :: ScopeInfo Source #
The empty scope info.
mapScope :: (NameSpaceId -> NamesInScope -> NamesInScope) -> (NameSpaceId -> ModulesInScope -> ModulesInScope) -> (NameSpaceId -> InScopeSet -> InScopeSet) -> Scope -> Scope Source #
Map functions over the names and modules in a scope.
mapScope_ :: (NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet) -> Scope -> Scope Source #
Same as mapScope but applies the same function to all name spaces.
mapScopeNS :: NameSpaceId -> (NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet) -> Scope -> Scope Source #
Same as mapScope but applies the function only on the given name space.
mapScopeM :: Applicative m => (NameSpaceId -> NamesInScope -> m NamesInScope) -> (NameSpaceId -> ModulesInScope -> m ModulesInScope) -> (NameSpaceId -> InScopeSet -> m InScopeSet) -> Scope -> m Scope Source #
Map monadic functions over the names and modules in a scope.
mapScopeM_ :: Applicative m => (NamesInScope -> m NamesInScope) -> (ModulesInScope -> m ModulesInScope) -> (InScopeSet -> m InScopeSet) -> Scope -> m Scope Source #
Same as mapScopeM but applies the same function to both the public and
private name spaces.
zipScope :: (NameSpaceId -> NamesInScope -> NamesInScope -> NamesInScope) -> (NameSpaceId -> ModulesInScope -> ModulesInScope -> ModulesInScope) -> (NameSpaceId -> InScopeSet -> InScopeSet -> InScopeSet) -> Scope -> Scope -> Scope Source #
Zip together two scopes. The resulting scope has the same name as the first scope.
zipScope_ :: (NamesInScope -> NamesInScope -> NamesInScope) -> (ModulesInScope -> ModulesInScope -> ModulesInScope) -> (InScopeSet -> InScopeSet -> InScopeSet) -> Scope -> Scope -> Scope Source #
Same as zipScope but applies the same function to both the public and
private name spaces.
recomputeInScopeSets :: Scope -> Scope Source #
Recompute the inScope sets of a scope.
filterScope :: (Name -> Bool) -> (Name -> Bool) -> Scope -> Scope Source #
Filter a scope keeping only concrete names matching the predicates. The first predicate is applied to the names and the second to the modules.
allNamesInScope :: InScope a => Scope -> ThingsInScope a Source #
Return all names in a scope.
allNamesInScope' :: InScope a => Scope -> ThingsInScope (a, Access) Source #
findNameInScope :: InScope a => Name -> Scope -> [(a, Access)] Source #
Look up a single name in the current scope.
This is equivalent to Map.lookup n . allNamesInScope', but more efficient
when only a single name needs to be looked up.
exportedNamesInScope :: InScope a => Scope -> ThingsInScope a Source #
Returns the scope's non-private names.
namesInScope :: InScope a => [NameSpaceId] -> Scope -> ThingsInScope a Source #
allThingsInScope :: Scope -> NameSpace Source #
thingsInScope :: [NameSpaceId] -> Scope -> NameSpace Source #
mergeScope :: Scope -> Scope -> Scope Source #
Merge two scopes. The result has the name of the first scope.
mergeScopes :: [Scope] -> Scope Source #
Merge a non-empty list of scopes. The result has the name of the first scope in the list.
Specific operations on scopes
setScopeAccess :: NameSpaceId -> Scope -> Scope Source #
Move all names in a scope to the given name space (except never move from Imported to Public).
setNameSpace :: NameSpaceId -> NameSpace -> Scope -> Scope Source #
Update a particular name space.
modifyNameSpace :: NameSpaceId -> (NameSpace -> NameSpace) -> Scope -> Scope Source #
Modify a particular name space.
addNameToScope :: NameSpaceId -> Name -> AbstractName -> Scope -> Scope Source #
Add a name to a scope.
removeNameFromScope :: NameSpaceId -> Name -> Scope -> Scope Source #
Remove a name from a scope. Caution: does not update the nsInScope set. This is only used by rebindName and in that case we add the name right back (but with a different kind).
addModuleToScope :: NameSpaceId -> Name -> AbstractModule -> Scope -> Scope Source #
Add a module to a scope.
data UsingOrHiding Source #
When we get here we cannot have both using and hiding.
Constructors
| UsingOnly [ImportedName] | |
| HidingOnly [ImportedName] |
applyImportDirective :: ImportDirective -> Scope -> Scope Source #
Apply an ImportDirective to a scope:
- rename keys (C.Name) according to
renaming; - for untouched keys, either of
a) remove keys according to hiding, or
b) filter keys according to using.
Both steps could be done in one pass, by first preparing key-filtering
functions C.Name -> Maybe C.Name for defined names and module names.
However, the penalty of doing it in two passes should not be too high.
(Doubling the run time.)
applyImportDirective_ Source #
Arguments
| :: ImportDirective | |
| -> Scope | |
| -> (Scope, (Set Name, Set Name)) | Merged scope, clashing names, clashing module names. |
Version of applyImportDirective that also returns sets of name
and module name clashes introduced by renaming to identifiers
that are already imported by using or lack of hiding.
renameCanonicalNames :: Map QName QName -> Map ModuleName ModuleName -> Scope -> Scope Source #
Rename the abstract names in a scope.
restrictPrivate :: Scope -> Scope Source #
Remove private name space of a scope.
Should be a right identity for exportedNamesInScope.
exportedNamesInScope . restrictPrivate == exportedNamesInScope.
restrictLocalPrivate :: ModuleName -> Scope -> Scope Source #
Remove private things from the given module from a scope.
disallowGeneralizedVars :: Scope -> Scope Source #
Disallow using generalized variables from the scope
inScopeBecause :: (WhyInScope -> WhyInScope) -> Scope -> Scope Source #
Add an explanation to why things are in scope.
publicModules :: ScopeInfo -> Map ModuleName Scope Source #
Get the public parts of the public modules of a scope
publicNames :: ScopeInfo -> Set AbstractName Source #
concreteNamesInScope :: ScopeInfo -> Set QName Source #
Get all concrete names in scope. Includes bound variables.
Inverse look-up
data AllowAmbiguousNames Source #
Constructors
| AmbiguousAnything | Used for instance arguments to check whether a name is in scope, but we do not care whether is is ambiguous |
| AmbiguousConProjs | Ambiguous constructors, projections, or pattern synonyms. |
| AmbiguousNothing |
Instances
| Eq AllowAmbiguousNames Source # | |
Defined in Agda.Syntax.Scope.Base Methods (==) :: AllowAmbiguousNames -> AllowAmbiguousNames -> Bool # (/=) :: AllowAmbiguousNames -> AllowAmbiguousNames -> Bool # | |
inverseScopeLookupName :: QName -> ScopeInfo -> [QName] Source #
Find the concrete names that map (uniquely) to a given abstract qualified name. Sort by number of modules in the qualified name, unqualified names first.
inverseScopeLookupName' :: AllowAmbiguousNames -> QName -> ScopeInfo -> [QName] Source #
inverseScopeLookupName'' :: AllowAmbiguousNames -> QName -> ScopeInfo -> Maybe NameMapEntry Source #
A version of inverseScopeLookupName that also delivers the KindOfName.
Used in highlighting.
inverseScopeLookupModule :: ModuleName -> ScopeInfo -> [QName] Source #
Find the concrete names that map (uniquely) to a given abstract module name. Sort by length, shortest first.
inverseScopeLookupModule' :: AllowAmbiguousNames -> ModuleName -> ScopeInfo -> [QName] Source #
Update binding site
class SetBindingSite a where Source #
Set the nameBindingSite in an abstract name.
Minimal complete definition
Nothing
Methods
setBindingSite :: Range -> a -> a Source #
default setBindingSite :: (SetBindingSite b, Functor t, t b ~ a) => Range -> a -> a Source #
Instances
| SetBindingSite ModuleName Source # | Sets the binding site of all names in the path. |
Defined in Agda.Syntax.Scope.Base Methods setBindingSite :: Range -> ModuleName -> ModuleName Source # | |
| SetBindingSite Name Source # | |
Defined in Agda.Syntax.Scope.Base | |
| SetBindingSite QName Source # | |
Defined in Agda.Syntax.Scope.Base | |
| SetBindingSite AbstractModule Source # | |
Defined in Agda.Syntax.Scope.Base Methods setBindingSite :: Range -> AbstractModule -> AbstractModule Source # | |
| SetBindingSite AbstractName Source # | |
Defined in Agda.Syntax.Scope.Base Methods setBindingSite :: Range -> AbstractName -> AbstractName Source # | |
| SetBindingSite a => SetBindingSite (List1 a) Source # | |
Defined in Agda.Syntax.Scope.Base | |
| SetBindingSite a => SetBindingSite [a] Source # | |
Defined in Agda.Syntax.Scope.Base Methods setBindingSite :: Range -> [a] -> [a] Source # | |
(Debug) printing
prettyNameSpace :: NameSpace -> [Doc] Source #