Bound

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

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

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

class Bound :: ((Type -> Type) -> Type -> Type) -> Constraintclass Bound t  where

Members

• subst :: forall f a c. 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)

flipSubst :: forall f t a c. 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)

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

data Var b a

Constructors

• B b
• F a

Instances

• Generic (Var b a) _
• (Eq b, Eq a) => Eq (Var b a)
• (Ord b, Ord a) => Ord (Var b a)
• (Show b, Show 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 :: Type -> (Type -> Type) -> Type -> Typenewtype Scope b f a

Constructors

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

Instances

• Generic (Scope b f a) _
• (Eq b, Eq1 f, Eq (f a), Eq (f (Var b (f a))), Eq a) => Eq (Scope b f a)
• (Ord b, Ord1 f, Ord (f a), Ord (f (Var b (f a))), Ord a) => Ord (Scope b f a)
• (Show b, Show (f (Var b (f a))), Show 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 b f a. Scope b f a -> f (Var b (f a))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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