Safe Haskell	None
Language	Haskell2010

Language.Haskell.Names.Open

Synopsis

class Typeable a => Resolvable a where
- rtraverse :: (Applicative f, ?alg :: Alg f) => a -> Scope -> f a
newtype Alg w = Alg {
- runAlg :: forall d. Resolvable d => d -> Scope -> w d
}
rmap :: Resolvable a => (forall b. Resolvable b => Scope -> b -> b) -> Scope -> a -> a
rfoldMap :: (Monoid r, Resolvable a) => (forall b. Resolvable b => Scope -> b -> r) -> Scope -> a -> r
data Scope
data NameContext
- = BindingT
- | BindingV
- | ReferenceT
- | ReferenceV
- | ReferenceUV
- | ReferenceUT
- | ReferenceRS
- | SignatureV
- | Other
initialScope :: ModuleName () -> Table -> Scope
gTable :: Lens Scope Table
lTable :: Lens Scope Table
nameCtx :: Lens Scope NameContext
type WcNames = [WcField]
data WcField = WcField {
- wcFieldName :: Name ()
- wcFieldSymbol :: Symbol
- wcExistsGlobalValue :: Bool
}
wcNames :: Lens Scope WcNames

Documentation

class Typeable a => Resolvable a where #

A type that implements Resolvable provides a way to perform a shallow scope-aware traversal.

Methods

rtraverse :: (Applicative f, ?alg :: Alg f) => a -> Scope -> f a #

Instances

(Typeable a, GTraversable Resolvable a) => Resolvable a #
Instance details Defined in Language.Haskell.Names.Open.Base Methods rtraverse :: (Applicative f, ?alg :: Alg f) => a -> Scope -> f a #
Resolvable SrcSpan #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => SrcSpan -> Scope -> f SrcSpan #
Resolvable SrcSpanInfo #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => SrcSpanInfo -> Scope -> f SrcSpanInfo #
(Resolvable l, SrcInfo l, Data l) => Resolvable [Stmt l] #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => [Stmt l] -> Scope -> f [Stmt l] #
(Resolvable l, SrcInfo l, Data l) => Resolvable (Op l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => Op l -> Scope -> f (Op l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (Decl l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => Decl l -> Scope -> f (Decl l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (DeclHead l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => DeclHead l -> Scope -> f (DeclHead l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (InstRule l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => InstRule l -> Scope -> f (InstRule l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (Binds l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => Binds l -> Scope -> f (Binds l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (Match l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => Match l -> Scope -> f (Match l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (ConDecl l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => ConDecl l -> Scope -> f (ConDecl l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (FieldDecl l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => FieldDecl l -> Scope -> f (FieldDecl l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (ClassDecl l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => ClassDecl l -> Scope -> f (ClassDecl l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (InstDecl l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => InstDecl l -> Scope -> f (InstDecl l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (GuardedRhs l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => GuardedRhs l -> Scope -> f (GuardedRhs l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (Type l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => Type l -> Scope -> f (Type l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (Context l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => Context l -> Scope -> f (Context l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (Exp l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => Exp l -> Scope -> f (Exp l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (Pat l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => Pat l -> Scope -> f (Pat l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (PatField l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => PatField l -> Scope -> f (PatField l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (QualStmt l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => QualStmt l -> Scope -> f (QualStmt l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (FieldUpdate l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => FieldUpdate l -> Scope -> f (FieldUpdate l) #
(Resolvable l, SrcInfo l, Data l) => Resolvable (Alt l) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => Alt l -> Scope -> f (Alt l) #
Typeable a => Resolvable (Scoped a) #
Instance details Defined in Language.Haskell.Names.Open.Instances Methods rtraverse :: (Applicative f, ?alg :: Alg f) => Scoped a -> Scope -> f (Scoped a) #

newtype Alg w #

The algebra for rtraverse. It's newtype-wrapped because an implicit parameter cannot be polymorphic.

Constructors

Alg
Fields runAlg :: forall d. Resolvable d => d -> Scope -> w d

rmap :: Resolvable a => (forall b. Resolvable b => Scope -> b -> b) -> Scope -> a -> a #

Analogous to gmap, but for Resolvable

rfoldMap :: (Monoid r, Resolvable a) => (forall b. Resolvable b => Scope -> b -> r) -> Scope -> a -> r #

Analogous to gmap, but for Resolvable

data Scope #

Contains information about the node's enclosing scope. Can be accessed through the lenses: gTable, lTable, nameCtx, instanceQualification, wcNames. If we enter an instance with a qualified class name we have to remember the qualification to resolve method names.

data NameContext #

Describes how we should treat names in the current context

Constructors

BindingT
BindingV
ReferenceT
ReferenceV
ReferenceUV	Reference a method in an instance declaration Unqualified names also match qualified names in scope https://www.haskell.org/pipermail/haskell-prime/2008-April/002569.html
ReferenceUT	Reference an associated type in an instance declaration Unqualified names also match qualified names in scope https://www.haskell.org/pipermail/haskell-prime/2008-April/002569.html
ReferenceRS	Reference a record field selector
SignatureV	A type signature contains an always unqualified `Name` that always refers to a value bound in the same module.
Other

initialScope :: ModuleName () -> Table -> Scope #

Create an initial scope

gTable :: Lens Scope Table #

lTable :: Lens Scope Table #

nameCtx :: Lens Scope NameContext #

type WcNames = [WcField] #

Information about the names being introduced by a record wildcard

During resolving traversal, we always (lazily) construct this list when we process PRec or RecConstr, even if it doesn't contain a wildcard.

Then, if the pattern or construction actually contains a wildcard, we use the computed value.

data WcField #

Information about a field in the wildcard

Constructors

WcField
Fields wcFieldName :: Name () the field's simple name wcFieldSymbol :: Symbol the field's selector symbol wcExistsGlobalValue :: Bool whether there is a global value in scope with the same name as the field but different from the field selector

wcNames :: Lens Scope WcNames #