Language.Haskell.Names.Open

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

Defined in Language.Haskell.Names.Open.Base

Methods

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

Resolvable SrcSpan

Defined in Language.Haskell.Names.Open.Instances

Methods

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

Resolvable SrcSpanInfo

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]

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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