Module

PureScript.CST.Traversal

Package
purescript-language-cst-parser
Repository
natefaubion/purescript-language-cst-parser

#Rewrite Source

type Rewrite :: Type -> (Type -> Type) -> (Type -> Type) -> Typetype Rewrite e f (g :: Type -> Type) = g e -> f (g e)

#defaultVisitorM Source

#rewriteModuleBottomUpM Source

#rewriteBinderBottomUpM Source

#rewriteExprBottomUpM Source

rewriteExprBottomUpM :: forall e m. Monad m => Record (OnPureScript (Rewrite e m)) -> Rewrite e m Expr

#rewriteDeclBottomUpM Source

#rewriteTypeBottomUpM Source

rewriteTypeBottomUpM :: forall e m. Monad m => Record (OnPureScript (Rewrite e m)) -> Rewrite e m Type

#rewriteModuleTopDownM Source

#rewriteBinderTopDownM Source

#rewriteExprTopDownM Source

rewriteExprTopDownM :: forall e m. Monad m => Record (OnPureScript (Rewrite e m)) -> Rewrite e m Expr

#rewriteDeclTopDownM Source

#rewriteTypeTopDownM Source

rewriteTypeTopDownM :: forall e m. Monad m => Record (OnPureScript (Rewrite e m)) -> Rewrite e m Type

#RewriteWithContext Source

type RewriteWithContext :: Type -> Type -> (Type -> Type) -> (Type -> Type) -> Typetype RewriteWithContext c e f (g :: Type -> Type) = c -> g e -> f (Tuple c (g e))

#defaultVisitorWithContextM Source

#rewriteModuleWithContextM Source

#rewriteBinderWithContextM Source

#rewriteExprWithContextM Source

#rewriteDeclWithContextM Source

#rewriteTypeWithContextM Source

#MonoidalRewrite Source

type MonoidalRewrite :: Type -> Type -> (Type -> Type) -> Typetype MonoidalRewrite e m (g :: Type -> Type) = g e -> m

#defaultMonoidalVisitor Source

#foldMapModule Source

#foldMapBinder Source

#foldMapExpr Source

#foldMapType Source

#PureRewrite Source

type PureRewrite :: Type -> (Type -> Type) -> Typetype PureRewrite e (g :: Type -> Type) = g e -> g e

#defaultVisitor Source

#rewriteModuleBottomUp Source

#rewriteBinderBottomUp Source

#rewriteExprBottomUp Source

#rewriteTypeBottomUp Source

#rewriteModuleTopDown Source

#rewriteBinderTopDown Source

#rewriteExprTopDown Source

#rewriteTypeTopDown Source

#PureRewriteWithContext Source

type PureRewriteWithContext :: Type -> Type -> (Type -> Type) -> Typetype PureRewriteWithContext c e (g :: Type -> Type) = c -> g e -> Tuple c (g e)

#defaultVisitorWithContext Source

#traverseModule Source

traverseModule :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnDecl (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f Module

#traverseModuleBody Source

traverseModuleBody :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnDecl (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f ModuleBody

#traverseDecl Source

traverseDecl :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnDecl (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f Declaration

#traverseForeign Source

traverseForeign :: forall e f r. Applicative f => Record (OnType (Rewrite e f)) + r -> Rewrite e f Foreign

#traverseInstance Source

traverseInstance :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f Instance

#traverseInstanceHead Source

#traverseInstanceBinding Source

#traverseClassHead Source

traverseClassHead :: forall e f r. Applicative f => Record (OnType (Rewrite e f)) + r -> Rewrite e f ClassHead

#traverseOneOrDelimited Source

traverseOneOrDelimited :: forall a f. Applicative f => (a -> f a) -> Rewrite a f OneOrDelimited

#traverseDataHead Source

traverseDataHead :: forall e f r. Applicative f => Record (OnType (Rewrite e f)) + r -> Rewrite e f DataHead

#traverseDataCtor Source

traverseDataCtor :: forall e f r. Applicative f => Record (OnType (Rewrite e f)) + r -> Rewrite e f DataCtor

#traverseType Source

traverseType :: forall e f r. Applicative f => Record (OnType (Rewrite e f)) + r -> Rewrite e f Type

#traverseRow Source

traverseRow :: forall e f r. Applicative f => Record (OnType (Rewrite e f)) + r -> Rewrite e f Row

#traverseTypeVarBinding Source

traverseTypeVarBinding :: forall e f r a. Applicative f => Record (OnType (Rewrite e f)) + r -> Rewrite e f (TypeVarBinding a)

#traverseExpr Source

traverseExpr :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f Expr

#traverseExprAppSpine Source

traverseExprAppSpine :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f (AppSpine Expr)

#traverseDelimited Source

traverseDelimited :: forall f a. Applicative f => (a -> f a) -> Rewrite a f Delimited

#traverseDelimitedNonEmpty Source

traverseDelimitedNonEmpty :: forall a f. Applicative f => (a -> f a) -> Rewrite a f DelimitedNonEmpty

#traverseSeparated Source

traverseSeparated :: forall f a. Applicative f => (a -> f a) -> Rewrite a f Separated

#traverseWrapped Source

traverseWrapped :: forall f a. Applicative f => (a -> f a) -> Rewrite a f Wrapped

#traverseRecordLabeled Source

traverseRecordLabeled :: forall f a. Applicative f => (a -> f a) -> Rewrite a f RecordLabeled

#traverseLabeled Source

traverseLabeled :: forall f a b. Applicative f => (b -> f b) -> Rewrite b f (Labeled a)

#traverseRecordAccessor Source

#traverseRecordUpdate Source

#traverseLambda Source

traverseLambda :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f Lambda

#traverseIfThenElse Source

traverseIfThenElse :: forall e f r. Applicative f => Record (OnExpr (Rewrite e f)) + r -> Rewrite e f IfThenElse

#traverseCaseOf Source

traverseCaseOf :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f CaseOf

#traverseGuarded Source

traverseGuarded :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f Guarded

#traverseGuardedExpr Source

traverseGuardedExpr :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f GuardedExpr

#traversePatternGuard Source

traversePatternGuard :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f PatternGuard

#traverseWhere Source

traverseWhere :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f Where

#traverseLetBinding Source

traverseLetBinding :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f LetBinding

#traverseValueBindingFields Source

#traverseLetIn Source

traverseLetIn :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f LetIn

#traverseDoStatement Source

traverseDoStatement :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f DoStatement

#traverseDoBlock Source

traverseDoBlock :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f DoBlock

#traverseAdoBlock Source

traverseAdoBlock :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnExpr (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f AdoBlock

#traverseBinder Source

traverseBinder :: forall e f r. Applicative f => Record (OnBinder (Rewrite e f)) + (OnType (Rewrite e f)) + r -> Rewrite e f Binder

#bottomUpTraversal Source

#rewriteBottomUpM Source

rewriteBottomUpM :: forall m e g. Monad m => (Record (OnPureScript (Rewrite e m)) -> Rewrite e m g) -> Record (OnPureScript (Rewrite e m)) -> Rewrite e m g

#topDownTraversal Source

#rewriteTopDownM Source

rewriteTopDownM :: forall m e g. Monad m => (Record (OnPureScript (Rewrite e m)) -> Rewrite e m g) -> Record (OnPureScript (Rewrite e m)) -> Rewrite e m g

#topDownTraversalWithContextM Source

#rewriteWithContextM Source

rewriteWithContextM :: forall c m e g. Monad m => (Record (OnPureScript (Rewrite e (ReaderT c m))) -> Rewrite e (ReaderT c m) g) -> Record (OnPureScript (RewriteWithContext c e m)) -> RewriteWithContext c e m g

#topDownMonoidalTraversal Source

#monoidalRewrite Source