Data.StarToStar

Fundamental * -> * types and (covariant) instances for the common classes: Functor, Foldable, and Traversable.

Documentation

data V a

Instances

Functor V

Foldable V

Traversable V

data U a

Constructors

U

Instances

Functor U

Foldable U

Traversable U

data C x a

Constructors

C x

Instances

Functor (C x)

Foldable (C x)

Traversable (C x)

onC :: (x -> b) -> C x a -> b

underC :: (x -> y) -> C x a -> C y b

toC :: x -> C x a

fromC :: C x a -> x

data I a

Constructors

I a

Instances

Functor I

Foldable I

Traversable I

onI :: (a -> b) -> I a -> b

underI :: (a -> b) -> I a -> I b

toI :: a -> I a

fromI :: I a -> a

newtype E e a

Constructors

E (e -> a)

Instances

Functor (E e)

onE :: ((e -> a) -> b) -> E e a -> b

underE :: ((e -> a) -> f -> b) -> E e a -> E f b

toE :: (e -> a) -> E e a

fromE :: E e a -> e -> a

type :-> = E

newtype K r a

Constructors

K (a -> r)

onK :: ((a -> r) -> b) -> K r a -> b

underK :: ((a -> r) -> b -> s) -> K r a -> K s b

toK :: (a -> r) -> K r a

fromK :: K r a -> a -> r

type :<- = K

newtype O f g a

Constructors

O (f (g a))

Instances

(Functor f, Functor g) => Functor (O f g)

(Foldable f, Foldable g) => Foldable (O f g)

(Traversable f, Traversable g) => Traversable (O f g)

onO :: (f (g a) -> b) -> O f g a -> b

underO :: (f (g a) -> h (i b)) -> O f g a -> O h i b

toO :: f (g a) -> O f g a

fromO :: O f g a -> f (g a)

type :. = O

data S f g a

Constructors

L (f a)

R (g a)

Instances

(Functor f, Functor g) => Functor (S f g)

(Foldable f, Foldable g) => Foldable (S f g)

(Traversable f, Traversable g) => Traversable (S f g)

onS :: (Either (f a) (g a) -> b) -> S f g a -> b

onS' :: (f a -> b) -> (g a -> b) -> S f g a -> b

underS :: (Either (f a) (g a) -> Either (h b) (i b)) -> S f g a -> S h i b

toS :: Either (f a) (g a) -> S f g a

fromS :: S f g a -> Either (f a) (g a)

type :+ = S

data P f g a

Constructors

P (f a) (g a)

Instances

(Functor f, Functor g) => Functor (P f g)

(Foldable f, Foldable g) => Foldable (P f g)

(Traversable f, Traversable g) => Traversable (P f g)

onP :: ((f a, g a) -> b) -> P f g a -> b

underP :: ((f a, g a) -> (h b, i b)) -> P f g a -> P h i b

toP :: (f a, g a) -> P f g a

fromP :: P f g a -> (f a, g a)

type :* = P

newtype F f g a

Constructors

F (f a -> g a)

onF :: ((f a -> g a) -> b) -> F f g a -> b

underF :: ((f a -> g a) -> h b -> i b) -> F f g a -> F h i b

toF :: (f a -> g a) -> F f g a

fromF :: F f g a -> f a -> g a

newtype Fix ff a

Constructors

In (ff (Fix ff) a)

Instances

Functor (ff (Fix ff)) => Functor (Fix ff)

Foldable (ff (Fix ff)) => Foldable (Fix ff)

Traversable (ff (Fix ff)) => Traversable (Fix ff)

underFix :: (ff (Fix ff) a -> gg (Fix gg) b) -> Fix ff a -> Fix gg b

toFix :: ff (Fix ff) a -> Fix ff a

fromFix :: Fix ff a -> ff (Fix ff) a

newtype Flip op f g a

Constructors

Flip (op g f a)

Instances

Functor (op g f) => Functor (Flip op f g)

Foldable (op g f) => Foldable (Flip op f g)

Traversable (op g f) => Traversable (Flip op f g)

onFlip :: (op g f a -> b) -> Flip op f g a -> b

underFlip :: (op g f a -> op' g' f' a') -> Flip op f g a -> Flip op' f' g' a'

toFlip :: op g f a -> Flip op f g a

fromFlip :: Flip op f g a -> op g f a