Bound

substitute :: forall a f. Monad f => Eq a => a -> f a -> f a -> f a

substituteVar :: forall a f. Functor f => Eq a => a -> a -> f a -> f a

closed :: forall b a f. Traversable f => f a -> Maybe (f b)

class Bound t  where

Members

• subst :: forall c a f. Monad f => (a -> f c) -> t f a -> t f c

Instances

• Bound (ContT r)
• Bound (ExceptT e)
• Bound ListT
• Bound MaybeT
• (Monoid w) => Bound (RWST r w s)
• Bound (ReaderT r)
• Bound (StateT s)
• (Monoid w) => Bound (WriterT w)
• Bound (Scope b)

substDefault :: forall c a f t. MonadTrans t => Monad f => Monad (t f) => (a -> f c) -> t f a -> t f c

flipSubst :: forall c a t f. Bound t => Monad f => t f a -> (a -> f c) -> t f c

Operator alias for Bound.subst (left-associative / precedence 1)

Operator alias for Bound.flipSubst (right-associative / precedence 1)

data Var b a

Constructors

• B b
• F a

Instances

• (Generic b, Generic a) => Generic (Var b a)
• (Eq b, Eq a) => Eq (Var b a)
• (Ord b, Ord a) => Ord (Var b a)
• (Generic b, Generic a) => Show (Var b a)
• Functor (Var b)
• Apply (Var b)
• Applicative (Var b)
• Bind (Var b)
• Monad (Var b)
• Foldable (Var b)
• Traversable (Var b)
• Bifunctor Var
• Bifoldable Var
• Bitraversable Var

newtype Scope b f a

Constructors

• Scope (f (Var b (f a)))

Instances

• (Generic b, Generic (f (Var b (f a))), Generic a) => Generic (Scope b f a)
• (Eq b, Eq (f (Var b (f a))), Eq a) => Eq (Scope b f a)
• (Ord b, Ord (f (Var b (f a))), Ord a) => Ord (Scope b f a)
• (Generic b, Generic (f (Var b (f a))), Generic a) => Show (Scope b f a)
• (Functor f) => Functor (Scope b f)
• (Monad f) => Apply (Scope b f)
• (Monad f) => Applicative (Scope b f)
• (Monad f) => Bind (Scope b f)
• (Monad f) => Monad (Scope b f)
• MonadTrans (Scope b)
• Bound (Scope b)
• (Foldable f) => Foldable (Scope b f)
• (Traversable f) => Traversable (Scope b f)

unScope :: forall a f b. Scope b f a -> f (Var b (f a))

fromScope :: forall a f b. Monad f => Scope b f a -> f (Var b a)

toScope :: forall a f b. Monad f => f (Var b a) -> Scope b f a

abstract :: forall f b a. Monad f => (a -> Maybe b) -> f a -> Scope b f a

abstract1 :: forall f a. Eq a => Monad f => a -> f a -> Scope Unit f a

instantiate :: forall f b a. Monad f => (b -> f a) -> Scope b f a -> f a

instantiate1 :: forall f b a. Monad f => f a -> Scope b f a -> f a

splat :: forall f c b a. Monad f => (a -> f c) -> (b -> f c) -> Scope b f a -> f c

bindings :: forall f b a. Foldable f => Scope b f a -> Array b

mapBound :: forall f c b a. Functor f => (b -> c) -> Scope b f a -> Scope c f a

mapScope :: forall f d c b a. Functor f => (b -> d) -> (a -> c) -> Scope b f a -> Scope d f c

foldMapBound :: forall f m b a. Foldable f => Monoid m => (b -> m) -> Scope b f a -> m

foldMapScope :: forall f m b a. Foldable f => Monoid m => (b -> m) -> (a -> m) -> Scope b f a -> m

traverseBound :: forall m f c b a. Traversable f => Applicative m => (b -> m c) -> Scope b f a -> m (Scope c f a)

traverseScope :: forall m f d c b a. Traversable f => Applicative m => (b -> m d) -> (a -> m c) -> Scope b f a -> m (Scope d f c)

traverseBound_ :: forall m f c b a. Foldable f => Applicative m => (b -> m c) -> Scope b f a -> m Unit

traverseScope_ :: forall m f d c b a. Foldable f => Applicative m => (b -> m d) -> (a -> m c) -> Scope b f a -> m Unit

hoistScope :: forall b a g f. Functor f => (forall x. f x -> g x) -> Scope b f a -> Scope b g a