Safe Haskell | None |
---|---|
Language | Haskell2010 |
Abstract names carry unique identifiers and stuff.
- data Name = Name {
- nameId :: !NameId
- nameConcrete :: Name
- nameBindingSite :: Range
- nameFixity :: Fixity'
- data QName = QName {}
- data QNamed a = QNamed {}
- newtype ModuleName = MName {
- mnameToList :: [Name]
- newtype AmbiguousQName = AmbQ {}
- class IsProjP a where
- isAnonymousModuleName :: ModuleName -> Bool
- withRangesOf :: ModuleName -> [Name] -> ModuleName
- withRangesOfQ :: ModuleName -> QName -> ModuleName
- mnameFromList :: [Name] -> ModuleName
- noModuleName :: ModuleName
- commonParentModule :: ModuleName -> ModuleName -> ModuleName
- class MkName a where
- qnameToList :: QName -> [Name]
- qnameFromList :: [Name] -> QName
- qnameToMName :: QName -> ModuleName
- mnameToQName :: ModuleName -> QName
- showQNameId :: QName -> String
- qnameToConcrete :: QName -> QName
- mnameToConcrete :: ModuleName -> QName
- toTopLevelModuleName :: ModuleName -> TopLevelModuleName
- qualifyM :: ModuleName -> ModuleName -> ModuleName
- qualifyQ :: ModuleName -> QName -> QName
- qualify :: ModuleName -> Name -> QName
- qualify_ :: Name -> QName
- isOperator :: QName -> Bool
- isSubModuleOf :: ModuleName -> ModuleName -> Bool
- isInModule :: QName -> ModuleName -> Bool
- nextName :: Name -> Name
- class IsNoName a where
Documentation
A name is a unique identifier and a suggestion for a concrete name. The concrete name contains the source location (if any) of the name. The source location of the binding site is also recorded.
Name | |
|
Qualified names are non-empty lists of names. Equality on qualified names are just equality on the last name, i.e. the module part is just for show.
The SetRange
instance for qualified names sets all individual
ranges (including those of the module prefix) to the given one.
QName | |
|
Eq QName Source # | |
Ord QName Source # | |
Show QName Source # | Only use this |
NFData QName Source # | |
Hashable QName Source # | |
Pretty QName Source # | |
Sized QName Source # | |
KillRange QName Source # | |
KillRange RewriteRuleMap Source # | |
KillRange Definitions Source # | |
SetRange QName Source # | |
HasRange QName Source # | |
NumHoles QName Source # | |
AllNames QName Source # | |
ExprLike QName Source # | |
TermLike QName Source # | |
NamesIn QName Source # | |
PrettyTCM QName Source # | |
InstantiateFull QName Source # | |
Occurs QName Source # | |
FromTerm QName Source # | |
ToTerm QName Source # | |
PrimTerm QName Source # | |
Unquote QName Source # | |
UniverseBi Declaration QName # | |
ToConcrete QName QName Source # | |
(Show a, ToQName a) => ToAbstract (OldName a) QName Source # | |
ToConcrete (Maybe QName) (Maybe Name) Source # | |
Something preceeded by a qualified name.
Functor QNamed Source # | |
Foldable QNamed Source # | |
Traversable QNamed Source # | |
Show a => Show (QNamed a) Source # | |
Pretty a => Pretty (QNamed a) Source # | |
PrettyTCM (QNamed Clause) Source # | |
ToAbstract (QNamed Clause) Clause Source # | |
Reify (QNamed Clause) Clause Source # | |
ToAbstract [QNamed Clause] [Clause] Source # | |
newtype ModuleName Source #
A module name is just a qualified name.
The SetRange
instance for module names sets all individual ranges
to the given one.
MName | |
|
Eq ModuleName Source # | |
Ord ModuleName Source # | |
Show ModuleName Source # | Only use this |
NFData ModuleName Source # | |
Pretty ModuleName Source # | |
Sized ModuleName Source # | |
KillRange ModuleName Source # | |
KillRange Sections Source # | |
SetRange ModuleName Source # | |
HasRange ModuleName Source # | |
SubstExpr ModuleName Source # | |
ExprLike ModuleName Source # | |
PrettyTCM ModuleName Source # | |
InstantiateFull ModuleName Source # | |
UniverseBi Declaration ModuleName # | |
ToConcrete ModuleName QName Source # | |
ToAbstract OldModuleName ModuleName Source # | |
ToAbstract NewModuleQName ModuleName Source # | |
ToAbstract NewModuleName ModuleName Source # | |
ToAbstract ModuleAssignment (ModuleName, [LetBinding]) Source # | |
newtype AmbiguousQName Source #
Ambiguous qualified names. Used for overloaded constructors.
Invariant: All the names in the list must have the same concrete,
unqualified name. (This implies that they all have the same Range
).
Eq AmbiguousQName Source # | |
Ord AmbiguousQName Source # | |
Show AmbiguousQName Source # | |
Pretty AmbiguousQName Source # | |
KillRange AmbiguousQName Source # | |
HasRange AmbiguousQName Source # | The range of an |
NumHoles AmbiguousQName Source # | We can have an instance for ambiguous names as all share a common concrete name. |
NamesIn AmbiguousQName Source # | |
UniverseBi Declaration AmbiguousQName # | |
class IsProjP a where Source #
Check whether we are a projection pattern.
isProjP :: a -> Maybe (ProjOrigin, AmbiguousQName) Source #
isAnonymousModuleName :: ModuleName -> Bool Source #
A module is anonymous if the qualification path ends in an underscore.
withRangesOf :: ModuleName -> [Name] -> ModuleName Source #
Sets the ranges of the individual names in the module name to
match those of the corresponding concrete names. If the concrete
names are fewer than the number of module name name parts, then the
initial name parts get the range noRange
.
C.D.E `withRangesOf` [A, B]
returns C.D.E
but with ranges set
as follows:
C
:noRange
.D
: the range ofA
.E
: the range ofB
.
Precondition: The number of module name name parts has to be at least as large as the length of the list.
withRangesOfQ :: ModuleName -> QName -> ModuleName Source #
Like withRangesOf
, but uses the name parts (qualifier + name)
of the qualified name as the list of concrete names.
mnameFromList :: [Name] -> ModuleName Source #
commonParentModule :: ModuleName -> ModuleName -> ModuleName Source #
Make a Name
from some kind of string.
qnameToList :: QName -> [Name] Source #
qnameFromList :: [Name] -> QName Source #
qnameToMName :: QName -> ModuleName Source #
mnameToQName :: ModuleName -> QName Source #
showQNameId :: QName -> String Source #
qnameToConcrete :: QName -> QName Source #
Turn a qualified name into a concrete name. This should only be used as a fallback when looking up the right concrete name in the scope fails.
mnameToConcrete :: ModuleName -> QName Source #
toTopLevelModuleName :: ModuleName -> TopLevelModuleName Source #
Computes the TopLevelModuleName
corresponding to the given
module name, which is assumed to represent a top-level module name.
Precondition: The module name must be well-formed.
qualifyM :: ModuleName -> ModuleName -> ModuleName Source #
isOperator :: QName -> Bool Source #
Is the name an operator?
isSubModuleOf :: ModuleName -> ModuleName -> Bool Source #
isInModule :: QName -> ModuleName -> Bool Source #
nextName :: Name -> Name Source #
Get the next version of the concrete name. For instance, nextName "x" = "x₁"
.
The name must not be a NoName
.