Language.Haskell.Exts.Util

Types annotated with source code locations

class Located a where

Class of types containing source code locations

Minimal complete definition

location

Associated Types

type LocType a

Methods

location :: forall f. Applicative f => (LocType a -> f (LocType a)) -> a -> f a

Traversal providing access to the location details

Instances

Located a => Located [a]

Associated Types

type LocType [a] :: *

Methods

location :: Applicative f => (LocType [a] -> f (LocType [a])) -> [a] -> f [a]

Located a => Located (Maybe a)

Associated Types

type LocType (Maybe a) :: *

Methods

location :: Applicative f => (LocType (Maybe a) -> f (LocType (Maybe a))) -> Maybe a -> f (Maybe a)

(Located a, Ord a) => Located (Set a)

Associated Types

type LocType (Set a) :: *

Methods

location :: Applicative f => (LocType (Set a) -> f (LocType (Set a))) -> Set a -> f (Set a)

Located (Name s)

Associated Types

type LocType (Name s) :: *

Methods

location :: Applicative f => (LocType (Name s) -> f (LocType (Name s))) -> Name s -> f (Name s)

Located (QOp s)

Associated Types

type LocType (QOp s) :: *

Methods

location :: Applicative f => (LocType (QOp s) -> f (LocType (QOp s))) -> QOp s -> f (QOp s)

Located (Decl s)

Associated Types

type LocType (Decl s) :: *

Methods

location :: Applicative f => (LocType (Decl s) -> f (LocType (Decl s))) -> Decl s -> f (Decl s)

Located (Binds s)

Associated Types

type LocType (Binds s) :: *

Methods

location :: Applicative f => (LocType (Binds s) -> f (LocType (Binds s))) -> Binds s -> f (Binds s)

Located (IPBind s)

Associated Types

type LocType (IPBind s) :: *

Methods

location :: Applicative f => (LocType (IPBind s) -> f (LocType (IPBind s))) -> IPBind s -> f (IPBind s)

Located (Match s)

Associated Types

type LocType (Match s) :: *

Methods

location :: Applicative f => (LocType (Match s) -> f (LocType (Match s))) -> Match s -> f (Match s)

Located (Rhs s)

Associated Types

type LocType (Rhs s) :: *

Methods

location :: Applicative f => (LocType (Rhs s) -> f (LocType (Rhs s))) -> Rhs s -> f (Rhs s)

Located (GuardedRhs s)

Associated Types

type LocType (GuardedRhs s) :: *

Methods

location :: Applicative f => (LocType (GuardedRhs s) -> f (LocType (GuardedRhs s))) -> GuardedRhs s -> f (GuardedRhs s)

Located (Exp s)

Associated Types

type LocType (Exp s) :: *

Methods

location :: Applicative f => (LocType (Exp s) -> f (LocType (Exp s))) -> Exp s -> f (Exp s)

Located (Pat s)

Associated Types

type LocType (Pat s) :: *

Methods

location :: Applicative f => (LocType (Pat s) -> f (LocType (Pat s))) -> Pat s -> f (Pat s)

Located (Stmt s)

Associated Types

type LocType (Stmt s) :: *

Methods

location :: Applicative f => (LocType (Stmt s) -> f (LocType (Stmt s))) -> Stmt s -> f (Stmt s)

Located (QualStmt s)

Associated Types

type LocType (QualStmt s) :: *

Methods

location :: Applicative f => (LocType (QualStmt s) -> f (LocType (QualStmt s))) -> QualStmt s -> f (QualStmt s)

Located (Alt s)

Associated Types

type LocType (Alt s) :: *

Methods

location :: Applicative f => (LocType (Alt s) -> f (LocType (Alt s))) -> Alt s -> f (Alt s)

Ord s => Located (Vars s)

Associated Types

type LocType (Vars s) :: *

Methods

location :: Applicative f => (LocType (Vars s) -> f (LocType (Vars s))) -> Vars s -> f (Vars s)

(Located a, Located b, (~) * (LocType a) (LocType b)) => Located (a, b)

Associated Types

type LocType (a, b) :: *

Methods

location :: Applicative f => (LocType (a, b) -> f (LocType (a, b))) -> (a, b) -> f (a, b)

Free variables of ASTs

class Located a => FreeVars a where

Minimal complete definition

freeVars

Methods

freeVars :: a -> Set (Name (LocType a))

Return the variables, erring on the side of more free variables

Instances

(Data s, Ord s) => FreeVars [IPBind s]

Methods

freeVars :: [IPBind s] -> Set (Name (LocType [IPBind s]))

(Data s, Ord s) => FreeVars [Exp s]

Methods

freeVars :: [Exp s] -> Set (Name (LocType [Exp s]))

(Data s, Ord s) => FreeVars [Alt s]

Methods

freeVars :: [Alt s] -> Set (Name (LocType [Alt s]))

(Data s, Ord s) => FreeVars (Set (Name s))

Methods

freeVars :: Set (Name s) -> Set (Name (LocType (Set (Name s))))

(Data s, Ord s) => FreeVars (IPBind s)

Methods

freeVars :: IPBind s -> Set (Name (LocType (IPBind s)))

(Data s, Ord s) => FreeVars (Rhs s)

Methods

freeVars :: Rhs s -> Set (Name (LocType (Rhs s)))

(Data s, Ord s) => FreeVars (GuardedRhs s)

Methods

freeVars :: GuardedRhs s -> Set (Name (LocType (GuardedRhs s)))

(Data s, Ord s) => FreeVars (Exp s)

Methods

freeVars :: Exp s -> Set (Name (LocType (Exp s)))

(Data s, Ord s) => FreeVars (Alt s)

Methods

freeVars :: Alt s -> Set (Name (LocType (Alt s)))

data Vars s

Constructors

Vars

Fields

• bound :: Set (Name s)
• free :: Set (Name s)

Instances

(Data s, Ord s) => Monoid (Vars s)

Methods

mempty :: Vars s

mappend :: Vars s -> Vars s -> Vars s

mconcat :: [Vars s] -> Vars s

Ord s => Located (Vars s)

Associated Types

type LocType (Vars s) :: *

Methods

location :: Applicative f => (LocType (Vars s) -> f (LocType (Vars s))) -> Vars s -> f (Vars s)

(Data s, Ord s) => AllVars (Vars s)

Methods

allVars :: Vars s -> Vars (LocType (Vars s))

type LocType (Vars s)

type LocType (Vars s) = s

class Located a => AllVars a where

Minimal complete definition

allVars

Methods

allVars :: a -> Vars (LocType a)

Return the variables, erring on the side of more free variables

Instances

(Data s, Ord s) => AllVars [Decl s]

Methods

allVars :: [Decl s] -> Vars (LocType [Decl s])

(Data s, Ord s) => AllVars [Match s]

Methods

allVars :: [Match s] -> Vars (LocType [Match s])

(Data s, Ord s) => AllVars [Pat s]

Methods

allVars :: [Pat s] -> Vars (LocType [Pat s])

(Data s, Ord s) => AllVars [Stmt s]

Methods

allVars :: [Stmt s] -> Vars (LocType [Stmt s])

(Data s, Ord s) => AllVars [QualStmt s]

Methods

allVars :: [QualStmt s] -> Vars (LocType [QualStmt s])

(Data s, Ord s) => AllVars (Maybe (Binds s))

Methods

allVars :: Maybe (Binds s) -> Vars (LocType (Maybe (Binds s)))

(Data s, Ord s) => AllVars (Decl s)

Methods

allVars :: Decl s -> Vars (LocType (Decl s))

(Data s, Ord s) => AllVars (Binds s)

Methods

allVars :: Binds s -> Vars (LocType (Binds s))

(Data s, Ord s) => AllVars (Match s)

Methods

allVars :: Match s -> Vars (LocType (Match s))

(Data s, Ord s) => AllVars (Pat s)

Methods

allVars :: Pat s -> Vars (LocType (Pat s))

(Data s, Ord s) => AllVars (Stmt s)

Methods

allVars :: Stmt s -> Vars (LocType (Stmt s))

(Data s, Ord s) => AllVars (QualStmt s)

Methods

allVars :: QualStmt s -> Vars (LocType (QualStmt s))

(Data s, Ord s) => AllVars (Vars s)

Methods

allVars :: Vars s -> Vars (LocType (Vars s))

Rebracketing of ASTs

class Brackets a where

Minimal complete definition

remParen, addParen, isAtom, needBracket

Methods

remParen :: a -> Maybe a

addParen :: a -> a

isAtom :: a -> Bool

Is this item lexically requiring no bracketing ever i.e. is totally atomic

needBracket :: Int -> a -> a -> Bool

Is the child safe free from brackets in the parent position. Err on the side of caution, True = don't know

Instances

Default l => Brackets (Type l)

Methods

remParen :: Type l -> Maybe (Type l)

addParen :: Type l -> Type l

isAtom :: Type l -> Bool

needBracket :: Int -> Type l -> Type l -> Bool

(Data l, Default l) => Brackets (Exp l)

Methods

remParen :: Exp l -> Maybe (Exp l)

addParen :: Exp l -> Exp l

isAtom :: Exp l -> Bool

needBracket :: Int -> Exp l -> Exp l -> Bool

Default l => Brackets (Pat l)

Methods

remParen :: Pat l -> Maybe (Pat l)

addParen :: Pat l -> Pat l

isAtom :: Pat l -> Bool

needBracket :: Int -> Pat l -> Pat l -> Bool

paren :: (Data l, Default l) => Exp l -> Exp l

Add a Paren around something if it is not atomic

transformBracket :: (Data l, Default l) => (Exp l -> Maybe (Exp l)) -> Exp l -> Exp l

rebracket1 :: (Data l, Default l) => Exp l -> Exp l

Add/remove brackets as suggested needBracket at 1-level of depth

appsBracket :: (Data l, Default l) => [Exp l] -> Exp l