Blanks.ScopeW

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)

newtype ScopeW t n f g a

Constructors

ScopeW

Fields

• unScopeW :: t (UnderScope n f (g a) a)

Instances

(Functor t, Functor f, Functor g) => Functor (ScopeW t n f g)

Defined in Blanks.ScopeW

Methods

fmap :: (a -> b) -> ScopeW t n f g a -> ScopeW t n f g b

(<$) :: a -> ScopeW t n f g b -> ScopeW t n f g a

(Foldable t, Foldable f, Foldable g) => Foldable (ScopeW t n f g)

Defined in Blanks.ScopeW

Methods

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

sum :: Num a => ScopeW t n f g a -> a

product :: Num a => ScopeW t n f g a -> a

(Traversable t, Traversable f, Traversable g) => Traversable (ScopeW t n f g)

Defined in Blanks.ScopeW

Methods

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)

Defined in Blanks.Scope

NatNewtype (ScopeW (Located l) n f (LocScope l n f)) (LocScope l n f)

Defined in Blanks.LocScope

Eq (t (UnderScope n f (g a) a)) => Eq (ScopeW t n f g a)

Defined in Blanks.ScopeW

Methods

(==) :: ScopeW t n f g a -> ScopeW t n f g a -> Bool

(/=) :: ScopeW t n f g a -> ScopeW t n f g a -> Bool

Show (t (UnderScope n f (g a) a)) => Show (ScopeW t n f g a)

Defined in Blanks.ScopeW

Methods

showsPrec :: Int -> ScopeW t n f g a -> ShowS

show :: ScopeW t n f g a -> String

showList :: [ScopeW t n f g a] -> ShowS

NFData (t (UnderScope n f (g a) a)) => NFData (ScopeW t n f g a)

Defined in Blanks.ScopeW

Methods

rnf :: ScopeW t n f g a -> ()

type ScopeWRawFold n f g a r = UnderScopeFold n f (g a) a r

type ScopeWFold u n f g a r = ScopeWRawFold n f g a (u r)

scopeWFree :: ScopeC t u n f g => a -> u (g a)

scopeWEmbed :: ScopeC t u n f g => f (g a) -> u (g a)

scopeWAbstract :: (ScopeC t u n f g, Eq a) => n -> Seq a -> g a -> u (g a)

scopeWUnAbstract :: ScopeC t u n f g => Seq a -> g a -> g a

scopeWInstantiate :: ScopeC t u n f g => Seq (u (g a)) -> g a -> g a

scopeWApply :: ScopeC t u n f g => Seq (u (g a)) -> g a -> Either SubError (g a)

scopeWBind :: ScopeC t u n f g => (a -> u (g b)) -> g a -> g b

scopeWBindOpt :: ScopeC t u n f g => (a -> Maybe (u (g a))) -> g a -> g a

scopeWLift :: (ScopeC t u n f g, Monad u, Traversable f) => f a -> u (g a)

scopeWRawFold :: (NatNewtype (ScopeW t n f g) g, Functor t) => ScopeWRawFold n f g a r -> g a -> t r

scopeWFold :: (NatNewtype (ScopeW t n f g) g, Adjunction t u) => ScopeWFold u n f g a r -> g a -> r

scopeWLiftAnno :: (NatNewtype (ScopeW t n f g) g, Functor t) => t a -> g a

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

scopeWMapAnno :: ScopeC t u n f g => (t a -> t b) -> g a -> g b