Safe Haskell  None 

Language  Haskell2010 
Internals. You'd need to newtype ScopeW
to implement your own Blank
.
Documentation
type ScopeC t u n f g = (Adjunction t u, Applicative u, Functor f, NatNewtype (ScopeW t n f g) g) Source #
newtype ScopeW t n f g a Source #
ScopeW  

Instances
(Functor t, Functor f, Functor g) => Functor (ScopeW t n f g) Source #  
(Foldable t, Foldable f, Foldable g) => Foldable (ScopeW t n f g) Source #  
Defined in Blanks.ScopeW fold :: Monoid m => ScopeW t n f g m > m # foldMap :: Monoid m => (a > m) > ScopeW t n f g a > m # foldr :: (a > b > b) > b > ScopeW t n f g a > b # foldr' :: (a > b > b) > b > ScopeW t n f g a > b # foldl :: (b > a > b) > b > ScopeW t n f g a > b # foldl' :: (b > a > b) > b > ScopeW t n f g a > b # foldr1 :: (a > a > a) > ScopeW t n f g a > a # foldl1 :: (a > a > a) > ScopeW t n f g a > a # toList :: ScopeW t n f g a > [a] # null :: ScopeW t n f g a > Bool # length :: ScopeW t n f g a > Int # elem :: Eq a => a > ScopeW t n f g a > Bool # maximum :: Ord a => ScopeW t n f g a > a # minimum :: Ord a => ScopeW t n f g a > a #  
(Traversable t, Traversable f, Traversable g) => Traversable (ScopeW t n f g) Source #  
Defined in Blanks.ScopeW traverse :: Applicative f0 => (a > f0 b) > ScopeW t n f g a > f0 (ScopeW t n f g b) # sequenceA :: Applicative f0 => ScopeW t n f g (f0 a) > f0 (ScopeW t n f g a) # mapM :: Monad m => (a > m b) > ScopeW t n f g a > m (ScopeW t n f g b) # sequence :: Monad m => ScopeW t n f g (m a) > m (ScopeW t n f g a) #  
NatNewtype (ScopeW Identity n f (Scope n f)) (Scope n f) Source #  
Defined in Blanks.Scope  
NatNewtype (ScopeW (Located l) n f (LocScope l n f)) (LocScope l n f) Source #  
Defined in Blanks.LocScope  
Eq (t (UnderScope n f (g a) a)) => Eq (ScopeW t n f g a) Source #  
Show (t (UnderScope n f (g a) a)) => Show (ScopeW t n f g a) Source #  
NFData (t (UnderScope n f (g a) a)) => NFData (ScopeW t n f g a) Source #  
Defined in Blanks.ScopeW 
type ScopeWRawFold n f g a r = UnderScopeFold n f (g a) a r Source #
type ScopeWFold u n f g a r = ScopeWRawFold n f g a (u r) Source #
scopeWFree :: ScopeC t u n f g => a > u (g a) Source #
scopeWEmbed :: ScopeC t u n f g => f (g a) > u (g a) Source #
scopeWUnAbstract :: ScopeC t u n f g => Seq a > g a > g a Source #
scopeWInstantiate :: ScopeC t u n f g => Seq (u (g a)) > g a > g a Source #
scopeWBind :: ScopeC t u n f g => (a > u (g b)) > g a > g b Source #
scopeWBindOpt :: ScopeC t u n f g => (a > Maybe (u (g a))) > g a > g a Source #
scopeWLift :: (ScopeC t u n f g, Monad u, Traversable f) => f a > u (g a) Source #
scopeWRawFold :: (NatNewtype (ScopeW t n f g) g, Functor t) => ScopeWRawFold n f g a r > g a > t r Source #
scopeWFold :: (NatNewtype (ScopeW t n f g) g, Adjunction t u) => ScopeWFold u n f g a r > g a > r Source #
scopeWLiftAnno :: (NatNewtype (ScopeW t n f g) g, Functor t) => t a > g a Source #
scopeWHoistAnno :: (NatNewtype (ScopeW t n f g) g, NatNewtype (ScopeW w n f h) h, Functor t, Functor w, Functor f) => (forall x. t x > w x) > g a > h a Source #
scopeWMapAnno :: ScopeC t u n f g => (t a > t b) > g a > g b Source #