Safe Haskell	Safe
Language	Haskell2010

Papa.Semigroupoids.Export

Synopsis

Documentation

class Bifunctor p where #

Formally, the class Bifunctor represents a bifunctor from Hask -> Hask.

Intuitively it is a bifunctor where both the first and second arguments are covariant.

You can define a Bifunctor by either defining bimap or by defining both first and second.

If you supply bimap, you should ensure that:

bimap id id ≡ id

If you supply first and second, ensure:

first id ≡ id
second id ≡ id

If you supply both, you should also ensure:

bimap f g ≡ first f . second g

These ensure by parametricity:

bimap  (f . g) (h . i) ≡ bimap f h . bimap g i
first  (f . g) ≡ first  f . first  g
second (f . g) ≡ second f . second g

Since: 4.8.0.0

Minimal complete definition

bimap | first, second

Methods

bimap :: (a -> b) -> (c -> d) -> p a c -> p b d #

Map over both arguments at the same time.

bimap f g ≡ first f . second g

first :: (a -> b) -> p a c -> p b c #

Map covariantly over the first argument.

first f ≡ bimap f id

second :: (b -> c) -> p a b -> p a c #

Map covariantly over the second argument.

second ≡ bimap id

Instances

Bifunctor Either
Methods bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d # first :: (a -> b) -> Either a c -> Either b c # second :: (b -> c) -> Either a b -> Either a c #
Bifunctor (,)
Methods bimap :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) # first :: (a -> b) -> (a, c) -> (b, c) # second :: (b -> c) -> (a, b) -> (a, c) #
Bifunctor Arg
Methods bimap :: (a -> b) -> (c -> d) -> Arg a c -> Arg b d # first :: (a -> b) -> Arg a c -> Arg b c # second :: (b -> c) -> Arg a b -> Arg a c #
Bifunctor (K1 i)
Methods bimap :: (a -> b) -> (c -> d) -> K1 i a c -> K1 i b d # first :: (a -> b) -> K1 i a c -> K1 i b c # second :: (b -> c) -> K1 i a b -> K1 i a c #
Bifunctor ((,,) x1)
Methods bimap :: (a -> b) -> (c -> d) -> (x1, a, c) -> (x1, b, d) # first :: (a -> b) -> (x1, a, c) -> (x1, b, c) # second :: (b -> c) -> (x1, a, b) -> (x1, a, c) #
Bifunctor (Const *)
Methods bimap :: (a -> b) -> (c -> d) -> Const * a c -> Const * b d # first :: (a -> b) -> Const * a c -> Const * b c # second :: (b -> c) -> Const * a b -> Const * a c #
Bifunctor ((,,,) x1 x2)
Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, a, c) -> (x1, x2, b, d) # first :: (a -> b) -> (x1, x2, a, c) -> (x1, x2, b, c) # second :: (b -> c) -> (x1, x2, a, b) -> (x1, x2, a, c) #
Bifunctor ((,,,,) x1 x2 x3)
Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, d) # first :: (a -> b) -> (x1, x2, x3, a, c) -> (x1, x2, x3, b, c) # second :: (b -> c) -> (x1, x2, x3, a, b) -> (x1, x2, x3, a, c) #
Bifunctor ((,,,,,) x1 x2 x3 x4)
Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, d) # first :: (a -> b) -> (x1, x2, x3, x4, a, c) -> (x1, x2, x3, x4, b, c) # second :: (b -> c) -> (x1, x2, x3, x4, a, b) -> (x1, x2, x3, x4, a, c) #
Bifunctor ((,,,,,,) x1 x2 x3 x4 x5)
Methods bimap :: (a -> b) -> (c -> d) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, d) # first :: (a -> b) -> (x1, x2, x3, x4, x5, a, c) -> (x1, x2, x3, x4, x5, b, c) # second :: (b -> c) -> (x1, x2, x3, x4, x5, a, b) -> (x1, x2, x3, x4, x5, a, c) #

class Bifunctor p => Biapply p where #

Minimal complete definition

(<<.>>)

Methods

(<<.>>) :: p (a -> b) (c -> d) -> p a c -> p b d infixl 4 #

(.>>) :: p a b -> p c d -> p c d infixl 4 #

a .> b ≡ const id <$> a <.> b

(<<.) :: p a b -> p c d -> p a b infixl 4 #

a <. b ≡ const <$> a <.> b

Instances

Biapply (,)
Methods (<<.>>) :: (a -> b, c -> d) -> (a, c) -> (b, d) # (.>>) :: (a, b) -> (c, d) -> (c, d) # (<<.) :: (a, b) -> (c, d) -> (a, b) #
Biapply Arg
Methods (<<.>>) :: Arg (a -> b) (c -> d) -> Arg a c -> Arg b d # (.>>) :: Arg a b -> Arg c d -> Arg c d # (<<.) :: Arg a b -> Arg c d -> Arg a b #
Semigroup x => Biapply ((,,) x)
Methods (<<.>>) :: (x, a -> b, c -> d) -> (x, a, c) -> (x, b, d) # (.>>) :: (x, a, b) -> (x, c, d) -> (x, c, d) # (<<.) :: (x, a, b) -> (x, c, d) -> (x, a, b) #
Biapply (Const *)
Methods (<<.>>) :: Const * (a -> b) (c -> d) -> Const * a c -> Const * b d # (.>>) :: Const * a b -> Const * c d -> Const * c d # (<<.) :: Const * a b -> Const * c d -> Const * a b #
Biapply (Tagged *)
Methods (<<.>>) :: Tagged * (a -> b) (c -> d) -> Tagged * a c -> Tagged * b d # (.>>) :: Tagged * a b -> Tagged * c d -> Tagged * c d # (<<.) :: Tagged * a b -> Tagged * c d -> Tagged * a b #
(Semigroup x, Semigroup y) => Biapply ((,,,) x y)
Methods (<<.>>) :: (x, y, a -> b, c -> d) -> (x, y, a, c) -> (x, y, b, d) # (.>>) :: (x, y, a, b) -> (x, y, c, d) -> (x, y, c, d) # (<<.) :: (x, y, a, b) -> (x, y, c, d) -> (x, y, a, b) #
(Semigroup x, Semigroup y, Semigroup z) => Biapply ((,,,,) x y z)
Methods (<<.>>) :: (x, y, z, a -> b, c -> d) -> (x, y, z, a, c) -> (x, y, z, b, d) # (.>>) :: (x, y, z, a, b) -> (x, y, z, c, d) -> (x, y, z, c, d) # (<<.) :: (x, y, z, a, b) -> (x, y, z, c, d) -> (x, y, z, a, b) #
Biapply p => Biapply (WrappedBifunctor * * p)
Methods (<<.>>) :: WrappedBifunctor * * p (a -> b) (c -> d) -> WrappedBifunctor * * p a c -> WrappedBifunctor * * p b d # (.>>) :: WrappedBifunctor * * p a b -> WrappedBifunctor * * p c d -> WrappedBifunctor * * p c d # (<<.) :: WrappedBifunctor * * p a b -> WrappedBifunctor * * p c d -> WrappedBifunctor * * p a b #
Apply g => Biapply (Joker * * g)
Methods (<<.>>) :: Joker * * g (a -> b) (c -> d) -> Joker * * g a c -> Joker * * g b d # (.>>) :: Joker * * g a b -> Joker * * g c d -> Joker * * g c d # (<<.) :: Joker * * g a b -> Joker * * g c d -> Joker * * g a b #
Biapply p => Biapply (Flip * * p)
Methods (<<.>>) :: Flip * * p (a -> b) (c -> d) -> Flip * * p a c -> Flip * * p b d # (.>>) :: Flip * * p a b -> Flip * * p c d -> Flip * * p c d # (<<.) :: Flip * * p a b -> Flip * * p c d -> Flip * * p a b #
Apply f => Biapply (Clown * * f)
Methods (<<.>>) :: Clown * * f (a -> b) (c -> d) -> Clown * * f a c -> Clown * * f b d # (.>>) :: Clown * * f a b -> Clown * * f c d -> Clown * * f c d # (<<.) :: Clown * * f a b -> Clown * * f c d -> Clown * * f a b #
(Biapply p, Biapply q) => Biapply (Product * * p q)
Methods (<<.>>) :: Product * * p q (a -> b) (c -> d) -> Product * * p q a c -> Product * * p q b d # (.>>) :: Product * * p q a b -> Product * * p q c d -> Product * * p q c d # (<<.) :: Product * * p q a b -> Product * * p q c d -> Product * * p q a b #
(Apply f, Biapply p) => Biapply (Tannen * * * f p)
Methods (<<.>>) :: Tannen * * * f p (a -> b) (c -> d) -> Tannen * * * f p a c -> Tannen * * * f p b d # (.>>) :: Tannen * * * f p a b -> Tannen * * * f p c d -> Tannen * * * f p c d # (<<.) :: Tannen * * * f p a b -> Tannen * * * f p c d -> Tannen * * * f p a b #
(Biapply p, Apply f, Apply g) => Biapply (Biff * * * * p f g)
Methods (<<.>>) :: Biff * * * * p f g (a -> b) (c -> d) -> Biff * * * * p f g a c -> Biff * * * * p f g b d # (.>>) :: Biff * * * * p f g a b -> Biff * * * * p f g c d -> Biff * * * * p f g c d # (<<.) :: Biff * * * * p f g a b -> Biff * * * * p f g c d -> Biff * * * * p f g a b #

(<<$>>) :: (a -> b) -> a -> b infixl 4 #

(<<..>>) :: Biapply p => p a c -> p (a -> b) (c -> d) -> p b d infixl 4 #

bilift2 :: Biapply w => (a -> b -> c) -> (d -> e -> f) -> w a d -> w b e -> w c f #

Lift binary functions

bilift3 :: Biapply w => (a -> b -> c -> d) -> (e -> f -> g -> h) -> w a e -> w b f -> w c g -> w d h #

Lift ternary functions

class Functor f => Alt f where #

Laws:

<!> is associative:             (a <!> b) <!> c = a <!> (b <!> c)
<$> left-distributes over <!>:  f <$> (a <!> b) = (f <$> a) <!> (f <$> b)

If extended to an Alternative then <!> should equal <|>.

Ideally, an instance of Alt also satisfies the "left distributon" law of MonadPlus with respect to <.>:

<.> right-distributes over <!>: (a <!> b) <.> c = (a <.> c) <!> (b <.> c)

But Maybe, IO, Either a, ErrorT e m, and STM satisfy the alternative "left catch" law instead:

pure a <!> b = pure a

However, this variation cannot be stated purely in terms of the dependencies of Alt.

When and if MonadPlus is successfully refactored, this class should also be refactored to remove these instances.

The right distributive law should extend in the cases where the a Bind or Monad is provided to yield variations of the right distributive law:

(m <!> n) >>- f = (m >>- f) <!> (m >>- f)
(m <!> n) >>= f = (m >>= f) <!> (m >>= f)

Minimal complete definition

(<!>)

Methods

(<!>) :: f a -> f a -> f a infixl 3 #

<|> without a required empty

Instances

Alt []
Methods (<!>) :: [a] -> [a] -> [a] # some :: Applicative [] => [a] -> [[a]] # many :: Applicative [] => [a] -> [[a]] #
Alt Maybe
Methods (<!>) :: Maybe a -> Maybe a -> Maybe a # some :: Applicative Maybe => Maybe a -> Maybe [a] # many :: Applicative Maybe => Maybe a -> Maybe [a] #
Alt IO	This instance does not actually satisfy the (`<.>`) right distributive law It instead satisfies the Left-Catch law
Methods (<!>) :: IO a -> IO a -> IO a # some :: Applicative IO => IO a -> IO [a] # many :: Applicative IO => IO a -> IO [a] #
Alt V1
Methods (<!>) :: V1 a -> V1 a -> V1 a # some :: Applicative V1 => V1 a -> V1 [a] # many :: Applicative V1 => V1 a -> V1 [a] #
Alt U1
Methods (<!>) :: U1 a -> U1 a -> U1 a # some :: Applicative U1 => U1 a -> U1 [a] # many :: Applicative U1 => U1 a -> U1 [a] #
Alt Option
Methods (<!>) :: Option a -> Option a -> Option a # some :: Applicative Option => Option a -> Option [a] # many :: Applicative Option => Option a -> Option [a] #
Alt NonEmpty
Methods (<!>) :: NonEmpty a -> NonEmpty a -> NonEmpty a # some :: Applicative NonEmpty => NonEmpty a -> NonEmpty [a] # many :: Applicative NonEmpty => NonEmpty a -> NonEmpty [a] #
Alt IntMap
Methods (<!>) :: IntMap a -> IntMap a -> IntMap a # some :: Applicative IntMap => IntMap a -> IntMap [a] # many :: Applicative IntMap => IntMap a -> IntMap [a] #
Alt Seq
Methods (<!>) :: Seq a -> Seq a -> Seq a # some :: Applicative Seq => Seq a -> Seq [a] # many :: Applicative Seq => Seq a -> Seq [a] #
Alt (Either a)
Methods (<!>) :: Either a a -> Either a a -> Either a a # some :: Applicative (Either a) => Either a a -> Either a [a] # many :: Applicative (Either a) => Either a a -> Either a [a] #
Alt f => Alt (Rec1 f)
Methods (<!>) :: Rec1 f a -> Rec1 f a -> Rec1 f a # some :: Applicative (Rec1 f) => Rec1 f a -> Rec1 f [a] # many :: Applicative (Rec1 f) => Rec1 f a -> Rec1 f [a] #
MonadPlus m => Alt (WrappedMonad m)
Methods (<!>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a # some :: Applicative (WrappedMonad m) => WrappedMonad m a -> WrappedMonad m [a] # many :: Applicative (WrappedMonad m) => WrappedMonad m a -> WrappedMonad m [a] #
Alt (Proxy *)
Methods (<!>) :: Proxy * a -> Proxy * a -> Proxy * a # some :: Applicative (Proxy ) => Proxy a -> Proxy * [a] # many :: Applicative (Proxy ) => Proxy a -> Proxy * [a] #
Ord k => Alt (Map k)
Methods (<!>) :: Map k a -> Map k a -> Map k a # some :: Applicative (Map k) => Map k a -> Map k [a] # many :: Applicative (Map k) => Map k a -> Map k [a] #
Alternative f => Alt (WrappedApplicative f)
Methods (<!>) :: WrappedApplicative f a -> WrappedApplicative f a -> WrappedApplicative f a # some :: Applicative (WrappedApplicative f) => WrappedApplicative f a -> WrappedApplicative f [a] # many :: Applicative (WrappedApplicative f) => WrappedApplicative f a -> WrappedApplicative f [a] #
Alt f => Alt (Lift f)
Methods (<!>) :: Lift f a -> Lift f a -> Lift f a # some :: Applicative (Lift f) => Lift f a -> Lift f [a] # many :: Applicative (Lift f) => Lift f a -> Lift f [a] #
(Bind f, Monad f) => Alt (MaybeT f)
Methods (<!>) :: MaybeT f a -> MaybeT f a -> MaybeT f a # some :: Applicative (MaybeT f) => MaybeT f a -> MaybeT f [a] # many :: Applicative (MaybeT f) => MaybeT f a -> MaybeT f [a] #
Apply f => Alt (ListT f)
Methods (<!>) :: ListT f a -> ListT f a -> ListT f a # some :: Applicative (ListT f) => ListT f a -> ListT f [a] # many :: Applicative (ListT f) => ListT f a -> ListT f [a] #
(Alt f, Alt g) => Alt ((:*:) f g)
Methods (<!>) :: (f :: g) a -> (f :: g) a -> (f :: g) a # some :: Applicative (f :: g) => (f :: g) a -> (f :: g) [a] # many :: Applicative (f :: g) => (f :: g) a -> (f :*: g) [a] #
ArrowPlus a => Alt (WrappedArrow a b)
Methods (<!>) :: WrappedArrow a b a -> WrappedArrow a b a -> WrappedArrow a b a # some :: Applicative (WrappedArrow a b) => WrappedArrow a b a -> WrappedArrow a b [a] # many :: Applicative (WrappedArrow a b) => WrappedArrow a b a -> WrappedArrow a b [a] #
Alt f => Alt (IdentityT * f)
Methods (<!>) :: IdentityT * f a -> IdentityT * f a -> IdentityT * f a # some :: Applicative (IdentityT * f) => IdentityT * f a -> IdentityT * f [a] # many :: Applicative (IdentityT * f) => IdentityT * f a -> IdentityT * f [a] #
(Bind f, Monad f) => Alt (ErrorT e f)
Methods (<!>) :: ErrorT e f a -> ErrorT e f a -> ErrorT e f a # some :: Applicative (ErrorT e f) => ErrorT e f a -> ErrorT e f [a] # many :: Applicative (ErrorT e f) => ErrorT e f a -> ErrorT e f [a] #
Alt f => Alt (Static f a)
Methods (<!>) :: Static f a a -> Static f a a -> Static f a a # some :: Applicative (Static f a) => Static f a a -> Static f a [a] # many :: Applicative (Static f a) => Static f a a -> Static f a [a] #
Alt f => Alt (Reverse * f)
Methods (<!>) :: Reverse * f a -> Reverse * f a -> Reverse * f a # some :: Applicative (Reverse * f) => Reverse * f a -> Reverse * f [a] # many :: Applicative (Reverse * f) => Reverse * f a -> Reverse * f [a] #
Alt f => Alt (Backwards * f)
Methods (<!>) :: Backwards * f a -> Backwards * f a -> Backwards * f a # some :: Applicative (Backwards * f) => Backwards * f a -> Backwards * f [a] # many :: Applicative (Backwards * f) => Backwards * f a -> Backwards * f [a] #
Alt f => Alt (WriterT w f)
Methods (<!>) :: WriterT w f a -> WriterT w f a -> WriterT w f a # some :: Applicative (WriterT w f) => WriterT w f a -> WriterT w f [a] # many :: Applicative (WriterT w f) => WriterT w f a -> WriterT w f [a] #
Alt f => Alt (WriterT w f)
Methods (<!>) :: WriterT w f a -> WriterT w f a -> WriterT w f a # some :: Applicative (WriterT w f) => WriterT w f a -> WriterT w f [a] # many :: Applicative (WriterT w f) => WriterT w f a -> WriterT w f [a] #
Alt f => Alt (StateT e f)
Methods (<!>) :: StateT e f a -> StateT e f a -> StateT e f a # some :: Applicative (StateT e f) => StateT e f a -> StateT e f [a] # many :: Applicative (StateT e f) => StateT e f a -> StateT e f [a] #
Alt f => Alt (StateT e f)
Methods (<!>) :: StateT e f a -> StateT e f a -> StateT e f a # some :: Applicative (StateT e f) => StateT e f a -> StateT e f [a] # many :: Applicative (StateT e f) => StateT e f a -> StateT e f [a] #
(Bind f, Monad f, Semigroup e) => Alt (ExceptT e f)
Methods (<!>) :: ExceptT e f a -> ExceptT e f a -> ExceptT e f a # some :: Applicative (ExceptT e f) => ExceptT e f a -> ExceptT e f [a] # many :: Applicative (ExceptT e f) => ExceptT e f a -> ExceptT e f [a] #
Alt f => Alt (M1 i c f)
Methods (<!>) :: M1 i c f a -> M1 i c f a -> M1 i c f a # some :: Applicative (M1 i c f) => M1 i c f a -> M1 i c f [a] # many :: Applicative (M1 i c f) => M1 i c f a -> M1 i c f [a] #
(Alt f, Alt g) => Alt (Product * f g)
Methods (<!>) :: Product * f g a -> Product * f g a -> Product * f g a # some :: Applicative (Product * f g) => Product * f g a -> Product * f g [a] # many :: Applicative (Product * f g) => Product * f g a -> Product * f g [a] #
Alt f => Alt (ReaderT * e f)
Methods (<!>) :: ReaderT * e f a -> ReaderT * e f a -> ReaderT * e f a # some :: Applicative (ReaderT * e f) => ReaderT * e f a -> ReaderT * e f [a] # many :: Applicative (ReaderT * e f) => ReaderT * e f a -> ReaderT * e f [a] #
(Alt f, Functor g) => Alt (Compose * * f g)
Methods (<!>) :: Compose * * f g a -> Compose * * f g a -> Compose * * f g a # some :: Applicative (Compose * * f g) => Compose * * f g a -> Compose * * f g [a] # many :: Applicative (Compose * * f g) => Compose * * f g a -> Compose * * f g [a] #
Alt f => Alt (RWST r w s f)
Methods (<!>) :: RWST r w s f a -> RWST r w s f a -> RWST r w s f a # some :: Applicative (RWST r w s f) => RWST r w s f a -> RWST r w s f [a] # many :: Applicative (RWST r w s f) => RWST r w s f a -> RWST r w s f [a] #
Alt f => Alt (RWST r w s f)
Methods (<!>) :: RWST r w s f a -> RWST r w s f a -> RWST r w s f a # some :: Applicative (RWST r w s f) => RWST r w s f a -> RWST r w s f [a] # many :: Applicative (RWST r w s f) => RWST r w s f a -> RWST r w s f [a] #

class Functor f => Apply f where #

A strong lax semi-monoidal endofunctor. This is equivalent to an Applicative without pure.

Laws:

(.) <$> u <.> v <.> w = u <.> (v <.> w)
x <.> (f <$> y) = (. f) <$> x <.> y
f <$> (x <.> y) = (f .) <$> x <.> y

The laws imply that .> and <. really ignore their left and right results, respectively, and really return their right and left results, respectively. Specifically,

(mf <$> m) .> (nf <$> n) = nf <$> (m .> n)
(mf <$> m) <. (nf <$> n) = mf <$> (m <. n)

Minimal complete definition

(<.>)

Methods

(<.>) :: f (a -> b) -> f a -> f b infixl 4 #

(.>) :: f a -> f b -> f b infixl 4 #

 a .> b = const id <$> a <.> b

(<.) :: f a -> f b -> f a infixl 4 #

 a <. b = const <$> a <.> b

Instances

Apply []
Methods (<.>) :: [a -> b] -> [a] -> [b] # (.>) :: [a] -> [b] -> [b] # (<.) :: [a] -> [b] -> [a] #
Apply Maybe
Methods (<.>) :: Maybe (a -> b) -> Maybe a -> Maybe b # (.>) :: Maybe a -> Maybe b -> Maybe b # (<.) :: Maybe a -> Maybe b -> Maybe a #
Apply IO
Methods (<.>) :: IO (a -> b) -> IO a -> IO b # (.>) :: IO a -> IO b -> IO b # (<.) :: IO a -> IO b -> IO a #
Apply Identity
Methods (<.>) :: Identity (a -> b) -> Identity a -> Identity b # (.>) :: Identity a -> Identity b -> Identity b # (<.) :: Identity a -> Identity b -> Identity a #
Apply Option
Methods (<.>) :: Option (a -> b) -> Option a -> Option b # (.>) :: Option a -> Option b -> Option b # (<.) :: Option a -> Option b -> Option a #
Apply NonEmpty
Methods (<.>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b # (.>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # (<.) :: NonEmpty a -> NonEmpty b -> NonEmpty a #
Apply Complex
Methods (<.>) :: Complex (a -> b) -> Complex a -> Complex b # (.>) :: Complex a -> Complex b -> Complex b # (<.) :: Complex a -> Complex b -> Complex a #
Apply ZipList
Methods (<.>) :: ZipList (a -> b) -> ZipList a -> ZipList b # (.>) :: ZipList a -> ZipList b -> ZipList b # (<.) :: ZipList a -> ZipList b -> ZipList a #
Apply IntMap	An IntMap is not `Applicative`, but it is an instance of `Apply`
Methods (<.>) :: IntMap (a -> b) -> IntMap a -> IntMap b # (.>) :: IntMap a -> IntMap b -> IntMap b # (<.) :: IntMap a -> IntMap b -> IntMap a #
Apply Tree
Methods (<.>) :: Tree (a -> b) -> Tree a -> Tree b # (.>) :: Tree a -> Tree b -> Tree b # (<.) :: Tree a -> Tree b -> Tree a #
Apply Seq
Methods (<.>) :: Seq (a -> b) -> Seq a -> Seq b # (.>) :: Seq a -> Seq b -> Seq b # (<.) :: Seq a -> Seq b -> Seq a #
Apply ((->) m)
Methods (<.>) :: (m -> a -> b) -> (m -> a) -> m -> b # (.>) :: (m -> a) -> (m -> b) -> m -> b # (<.) :: (m -> a) -> (m -> b) -> m -> a #
Apply (Either a)
Methods (<.>) :: Either a (a -> b) -> Either a a -> Either a b # (.>) :: Either a a -> Either a b -> Either a b # (<.) :: Either a a -> Either a b -> Either a a #
Semigroup m => Apply ((,) m)
Methods (<.>) :: (m, a -> b) -> (m, a) -> (m, b) # (.>) :: (m, a) -> (m, b) -> (m, b) # (<.) :: (m, a) -> (m, b) -> (m, a) #
Monad m => Apply (WrappedMonad m)
Methods (<.>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (.>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<.) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a #
Apply (Proxy *)
Methods (<.>) :: Proxy * (a -> b) -> Proxy * a -> Proxy * b # (.>) :: Proxy * a -> Proxy * b -> Proxy * b # (<.) :: Proxy * a -> Proxy * b -> Proxy * a #
Ord k => Apply (Map k)	A Map is not `Applicative`, but it is an instance of `Apply`
Methods (<.>) :: Map k (a -> b) -> Map k a -> Map k b # (.>) :: Map k a -> Map k b -> Map k b # (<.) :: Map k a -> Map k b -> Map k a #
(Hashable k, Eq k) => Apply (HashMap k)	A `HashMap` is not `Applicative`, but it is an instance of `Apply`
Methods (<.>) :: HashMap k (a -> b) -> HashMap k a -> HashMap k b # (.>) :: HashMap k a -> HashMap k b -> HashMap k b # (<.) :: HashMap k a -> HashMap k b -> HashMap k a #
Applicative f => Apply (WrappedApplicative f)
Methods (<.>) :: WrappedApplicative f (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b # (.>) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f b # (<.) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f a #
Apply f => Apply (MaybeApply f)
Methods (<.>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b # (.>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b # (<.) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a #
Apply f => Apply (Lift f)
Methods (<.>) :: Lift f (a -> b) -> Lift f a -> Lift f b # (.>) :: Lift f a -> Lift f b -> Lift f b # (<.) :: Lift f a -> Lift f b -> Lift f a #
(Functor m, Monad m) => Apply (MaybeT m)
Methods (<.>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b # (.>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # (<.) :: MaybeT m a -> MaybeT m b -> MaybeT m a #
Apply m => Apply (ListT m)
Methods (<.>) :: ListT m (a -> b) -> ListT m a -> ListT m b # (.>) :: ListT m a -> ListT m b -> ListT m b # (<.) :: ListT m a -> ListT m b -> ListT m a #
Arrow a => Apply (WrappedArrow a b)
Methods (<.>) :: WrappedArrow a b (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b # (.>) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b b # (<.) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b a #
Semigroup m => Apply (Const * m)
Methods (<.>) :: Const * m (a -> b) -> Const * m a -> Const * m b # (.>) :: Const * m a -> Const * m b -> Const * m b # (<.) :: Const * m a -> Const * m b -> Const * m a #
Biapply p => Apply (Join * p)
Methods (<.>) :: Join * p (a -> b) -> Join * p a -> Join * p b # (.>) :: Join * p a -> Join * p b -> Join * p b # (<.) :: Join * p a -> Join * p b -> Join * p a #
Apply w => Apply (TracedT m w)
Methods (<.>) :: TracedT m w (a -> b) -> TracedT m w a -> TracedT m w b # (.>) :: TracedT m w a -> TracedT m w b -> TracedT m w b # (<.) :: TracedT m w a -> TracedT m w b -> TracedT m w a #
(Apply w, Semigroup s) => Apply (StoreT s w)
Methods (<.>) :: StoreT s w (a -> b) -> StoreT s w a -> StoreT s w b # (.>) :: StoreT s w a -> StoreT s w b -> StoreT s w b # (<.) :: StoreT s w a -> StoreT s w b -> StoreT s w a #
(Semigroup e, Apply w) => Apply (EnvT e w)
Methods (<.>) :: EnvT e w (a -> b) -> EnvT e w a -> EnvT e w b # (.>) :: EnvT e w a -> EnvT e w b -> EnvT e w b # (<.) :: EnvT e w a -> EnvT e w b -> EnvT e w a #
Apply (Cokleisli w a)
Methods (<.>) :: Cokleisli w a (a -> b) -> Cokleisli w a a -> Cokleisli w a b # (.>) :: Cokleisli w a a -> Cokleisli w a b -> Cokleisli w a b # (<.) :: Cokleisli w a a -> Cokleisli w a b -> Cokleisli w a a #
Apply w => Apply (IdentityT * w)
Methods (<.>) :: IdentityT * w (a -> b) -> IdentityT * w a -> IdentityT * w b # (.>) :: IdentityT * w a -> IdentityT * w b -> IdentityT * w b # (<.) :: IdentityT * w a -> IdentityT * w b -> IdentityT * w a #
(Functor m, Monad m) => Apply (ErrorT e m)
Methods (<.>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b # (.>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b # (<.) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a #
Apply f => Apply (Static f a)
Methods (<.>) :: Static f a (a -> b) -> Static f a a -> Static f a b # (.>) :: Static f a a -> Static f a b -> Static f a b # (<.) :: Static f a a -> Static f a b -> Static f a a #
Apply (Tagged * a)
Methods (<.>) :: Tagged * a (a -> b) -> Tagged * a a -> Tagged * a b # (.>) :: Tagged * a a -> Tagged * a b -> Tagged * a b # (<.) :: Tagged * a a -> Tagged * a b -> Tagged * a a #
Apply f => Apply (Reverse * f)
Methods (<.>) :: Reverse * f (a -> b) -> Reverse * f a -> Reverse * f b # (.>) :: Reverse * f a -> Reverse * f b -> Reverse * f b # (<.) :: Reverse * f a -> Reverse * f b -> Reverse * f a #
Apply f => Apply (Backwards * f)
Methods (<.>) :: Backwards * f (a -> b) -> Backwards * f a -> Backwards * f b # (.>) :: Backwards * f a -> Backwards * f b -> Backwards * f b # (<.) :: Backwards * f a -> Backwards * f b -> Backwards * f a #
(Apply m, Semigroup w) => Apply (WriterT w m)
Methods (<.>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b # (.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # (<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a #
(Apply m, Semigroup w) => Apply (WriterT w m)
Methods (<.>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b # (.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # (<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a #
Bind m => Apply (StateT s m)
Methods (<.>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # (.>) :: StateT s m a -> StateT s m b -> StateT s m b # (<.) :: StateT s m a -> StateT s m b -> StateT s m a #
Bind m => Apply (StateT s m)
Methods (<.>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # (.>) :: StateT s m a -> StateT s m b -> StateT s m b # (<.) :: StateT s m a -> StateT s m b -> StateT s m a #
(Functor m, Monad m) => Apply (ExceptT e m)
Methods (<.>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b # (.>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # (<.) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a #
Semigroup f => Apply (Constant * f)
Methods (<.>) :: Constant * f (a -> b) -> Constant * f a -> Constant * f b # (.>) :: Constant * f a -> Constant * f b -> Constant * f b # (<.) :: Constant * f a -> Constant * f b -> Constant * f a #
(Apply f, Apply g) => Apply (Product * f g)
Methods (<.>) :: Product * f g (a -> b) -> Product * f g a -> Product * f g b # (.>) :: Product * f g a -> Product * f g b -> Product * f g b # (<.) :: Product * f g a -> Product * f g b -> Product * f g a #
Apply m => Apply (ReaderT * e m)
Methods (<.>) :: ReaderT * e m (a -> b) -> ReaderT * e m a -> ReaderT * e m b # (.>) :: ReaderT * e m a -> ReaderT * e m b -> ReaderT * e m b # (<.) :: ReaderT * e m a -> ReaderT * e m b -> ReaderT * e m a #
Apply (ContT * r m)
Methods (<.>) :: ContT * r m (a -> b) -> ContT * r m a -> ContT * r m b # (.>) :: ContT * r m a -> ContT * r m b -> ContT * r m b # (<.) :: ContT * r m a -> ContT * r m b -> ContT * r m a #
(Apply f, Apply g) => Apply (Compose * * f g)
Methods (<.>) :: Compose * * f g (a -> b) -> Compose * * f g a -> Compose * * f g b # (.>) :: Compose * * f g a -> Compose * * f g b -> Compose * * f g b # (<.) :: Compose * * f g a -> Compose * * f g b -> Compose * * f g a #
(Bind m, Semigroup w) => Apply (RWST r w s m)
Methods (<.>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b # (.>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # (<.) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a #
(Bind m, Semigroup w) => Apply (RWST r w s m)
Methods (<.>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b # (.>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # (<.) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a #

(<..>) :: Apply w => w a -> w (a -> b) -> w b infixl 4 #

A variant of <.> with the arguments reversed.

liftF2 :: Apply w => (a -> b -> c) -> w a -> w b -> w c #

Lift a binary function into a comonad with zipping

liftF3 :: Apply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d #

Lift a ternary function into a comonad with zipping

data WrappedApplicative f a :: (* -> *) -> * -> * #

Wrap an Applicative to be used as a member of Apply

Instances

Functor f => Functor (WrappedApplicative f)
Methods fmap :: (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b # (<$) :: a -> WrappedApplicative f b -> WrappedApplicative f a #
Applicative f => Applicative (WrappedApplicative f)
Methods pure :: a -> WrappedApplicative f a # (<>) :: WrappedApplicative f (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b # (>) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f b # (<*) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f a #
Alternative f => Alternative (WrappedApplicative f)
Methods empty :: WrappedApplicative f a # (<\|>) :: WrappedApplicative f a -> WrappedApplicative f a -> WrappedApplicative f a # some :: WrappedApplicative f a -> WrappedApplicative f [a] # many :: WrappedApplicative f a -> WrappedApplicative f [a] #
Alternative f => Plus (WrappedApplicative f)
Methods zero :: WrappedApplicative f a #
Alternative f => Alt (WrappedApplicative f)
Methods (<!>) :: WrappedApplicative f a -> WrappedApplicative f a -> WrappedApplicative f a # some :: Applicative (WrappedApplicative f) => WrappedApplicative f a -> WrappedApplicative f [a] # many :: Applicative (WrappedApplicative f) => WrappedApplicative f a -> WrappedApplicative f [a] #
Applicative f => Apply (WrappedApplicative f)
Methods (<.>) :: WrappedApplicative f (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b # (.>) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f b # (<.) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f a #

data MaybeApply f a :: (* -> *) -> * -> * #

Transform a Apply into an Applicative by adding a unit.

Instances

Functor f => Functor (MaybeApply f)
Methods fmap :: (a -> b) -> MaybeApply f a -> MaybeApply f b # (<$) :: a -> MaybeApply f b -> MaybeApply f a #
Apply f => Applicative (MaybeApply f)
Methods pure :: a -> MaybeApply f a # (<>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b # (>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b # (<*) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a #
Comonad f => Comonad (MaybeApply f)
Methods extract :: MaybeApply f a -> a # duplicate :: MaybeApply f a -> MaybeApply f (MaybeApply f a) # extend :: (MaybeApply f a -> b) -> MaybeApply f a -> MaybeApply f b #
Apply f => Apply (MaybeApply f)
Methods (<.>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b # (.>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b # (<.) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a #
Extend f => Extend (MaybeApply f)
Methods duplicated :: MaybeApply f a -> MaybeApply f (MaybeApply f a) # extended :: (MaybeApply f a -> b) -> MaybeApply f a -> MaybeApply f b #

class Apply m => Bind m where #

A Monad sans return.

Minimal definition: Either join or >>-

If defining both, then the following laws (the default definitions) must hold:

join = (>>- id)
m >>- f = join (fmap f m)

Laws:

induced definition of <.>: f <.> x = f >>- (<$> x)

Finally, there are two associativity conditions:

associativity of (>>-):    (m >>- f) >>- g == m >>- (\x -> f x >>- g)
associativity of join:     join . join = join . fmap join

These can both be seen as special cases of the constraint that

associativity of (->-): (f ->- g) ->- h = f ->- (g ->- h)

Minimal complete definition

(>>-) | join

Methods

(>>-) :: m a -> (a -> m b) -> m b infixl 1 #

join :: m (m a) -> m a #

Instances

Bind []
Methods (>>-) :: [a] -> (a -> [b]) -> [b] # join :: [[a]] -> [a] #
Bind Maybe
Methods (>>-) :: Maybe a -> (a -> Maybe b) -> Maybe b # join :: Maybe (Maybe a) -> Maybe a #
Bind IO
Methods (>>-) :: IO a -> (a -> IO b) -> IO b # join :: IO (IO a) -> IO a #
Bind Identity
Methods (>>-) :: Identity a -> (a -> Identity b) -> Identity b # join :: Identity (Identity a) -> Identity a #
Bind Option
Methods (>>-) :: Option a -> (a -> Option b) -> Option b # join :: Option (Option a) -> Option a #
Bind NonEmpty
Methods (>>-) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # join :: NonEmpty (NonEmpty a) -> NonEmpty a #
Bind Complex
Methods (>>-) :: Complex a -> (a -> Complex b) -> Complex b # join :: Complex (Complex a) -> Complex a #
Bind IntMap	An `IntMap` is not a `Monad`, but it is an instance of `Bind`
Methods (>>-) :: IntMap a -> (a -> IntMap b) -> IntMap b # join :: IntMap (IntMap a) -> IntMap a #
Bind Tree
Methods (>>-) :: Tree a -> (a -> Tree b) -> Tree b # join :: Tree (Tree a) -> Tree a #
Bind Seq
Methods (>>-) :: Seq a -> (a -> Seq b) -> Seq b # join :: Seq (Seq a) -> Seq a #
Bind ((->) m)
Methods (>>-) :: (m -> a) -> (a -> m -> b) -> m -> b # join :: (m -> m -> a) -> m -> a #
Bind (Either a)
Methods (>>-) :: Either a a -> (a -> Either a b) -> Either a b # join :: Either a (Either a a) -> Either a a #
Semigroup m => Bind ((,) m)
Methods (>>-) :: (m, a) -> (a -> (m, b)) -> (m, b) # join :: (m, (m, a)) -> (m, a) #
Monad m => Bind (WrappedMonad m)
Methods (>>-) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # join :: WrappedMonad m (WrappedMonad m a) -> WrappedMonad m a #
Bind (Proxy *)
Methods (>>-) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b # join :: Proxy * (Proxy * a) -> Proxy * a #
Ord k => Bind (Map k)	A `Map` is not a `Monad`, but it is an instance of `Bind`
Methods (>>-) :: Map k a -> (a -> Map k b) -> Map k b # join :: Map k (Map k a) -> Map k a #
(Hashable k, Eq k) => Bind (HashMap k)	A `HashMap` is not a `Monad`, but it is an instance of `Bind`
Methods (>>-) :: HashMap k a -> (a -> HashMap k b) -> HashMap k b # join :: HashMap k (HashMap k a) -> HashMap k a #
(Functor m, Monad m) => Bind (MaybeT m)
Methods (>>-) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b # join :: MaybeT m (MaybeT m a) -> MaybeT m a #
(Apply m, Monad m) => Bind (ListT m)
Methods (>>-) :: ListT m a -> (a -> ListT m b) -> ListT m b # join :: ListT m (ListT m a) -> ListT m a #
Bind m => Bind (IdentityT * m)
Methods (>>-) :: IdentityT * m a -> (a -> IdentityT * m b) -> IdentityT * m b # join :: IdentityT * m (IdentityT * m a) -> IdentityT * m a #
(Functor m, Monad m) => Bind (ErrorT e m)
Methods (>>-) :: ErrorT e m a -> (a -> ErrorT e m b) -> ErrorT e m b # join :: ErrorT e m (ErrorT e m a) -> ErrorT e m a #
Bind (Tagged * a)
Methods (>>-) :: Tagged * a a -> (a -> Tagged * a b) -> Tagged * a b # join :: Tagged * a (Tagged * a a) -> Tagged * a a #
(Bind m, Semigroup w) => Bind (WriterT w m)
Methods (>>-) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # join :: WriterT w m (WriterT w m a) -> WriterT w m a #
(Bind m, Semigroup w) => Bind (WriterT w m)
Methods (>>-) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # join :: WriterT w m (WriterT w m a) -> WriterT w m a #
Bind m => Bind (StateT s m)
Methods (>>-) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # join :: StateT s m (StateT s m a) -> StateT s m a #
Bind m => Bind (StateT s m)
Methods (>>-) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # join :: StateT s m (StateT s m a) -> StateT s m a #
(Functor m, Monad m) => Bind (ExceptT e m)
Methods (>>-) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b # join :: ExceptT e m (ExceptT e m a) -> ExceptT e m a #
(Bind f, Bind g) => Bind (Product * f g)
Methods (>>-) :: Product * f g a -> (a -> Product * f g b) -> Product * f g b # join :: Product * f g (Product * f g a) -> Product * f g a #
Bind m => Bind (ReaderT * e m)
Methods (>>-) :: ReaderT * e m a -> (a -> ReaderT * e m b) -> ReaderT * e m b # join :: ReaderT * e m (ReaderT * e m a) -> ReaderT * e m a #
Bind (ContT * r m)
Methods (>>-) :: ContT * r m a -> (a -> ContT * r m b) -> ContT * r m b # join :: ContT * r m (ContT * r m a) -> ContT * r m a #
(Bind m, Semigroup w) => Bind (RWST r w s m)
Methods (>>-) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b # join :: RWST r w s m (RWST r w s m a) -> RWST r w s m a #
(Bind m, Semigroup w) => Bind (RWST r w s m)
Methods (>>-) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b # join :: RWST r w s m (RWST r w s m a) -> RWST r w s m a #

(-<<) :: Bind m => (a -> m b) -> m a -> m b infixr 1 #

(-<-) :: Bind m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 #

(->-) :: Bind m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 #

apDefault :: Bind f => f (a -> b) -> f a -> f b #

returning :: Functor f => f a -> (a -> b) -> f b #

class MonadTrans t => BindTrans t where #

A subset of monad transformers can transform any Bind as well.

Minimal complete definition

liftB

Methods

liftB :: Bind b => b a -> t b a #

Instances

BindTrans (IdentityT *)
Methods liftB :: Bind b => b a -> IdentityT * b a #
Monoid w => BindTrans (WriterT w)
Methods liftB :: Bind b => b a -> WriterT w b a #
Monoid w => BindTrans (WriterT w)
Methods liftB :: Bind b => b a -> WriterT w b a #
BindTrans (StateT s)
Methods liftB :: Bind b => b a -> StateT s b a #
BindTrans (StateT s)
Methods liftB :: Bind b => b a -> StateT s b a #
BindTrans (ReaderT * e)
Methods liftB :: Bind b => b a -> ReaderT * e b a #
BindTrans (ContT * r)
Methods liftB :: Bind b => b a -> ContT * r b a #
Monoid w => BindTrans (RWST r w s)
Methods liftB :: Bind b => b a -> RWST r w s b a #
Monoid w => BindTrans (RWST r w s)
Methods liftB :: Bind b => b a -> RWST r w s b a #

class Functor w => Extend w where #

Minimal complete definition

duplicated | extended

Methods

duplicated :: w a -> w (w a) #

duplicated = extended id
fmap (fmap f) . duplicated = duplicated . fmap f

extended :: (w a -> b) -> w a -> w b #

extended f  = fmap f . duplicated

Instances

Extend []
Methods duplicated :: [a] -> [[a]] # extended :: ([a] -> b) -> [a] -> [b] #
Extend Maybe
Methods duplicated :: Maybe a -> Maybe (Maybe a) # extended :: (Maybe a -> b) -> Maybe a -> Maybe b #
Extend Identity
Methods duplicated :: Identity a -> Identity (Identity a) # extended :: (Identity a -> b) -> Identity a -> Identity b #
Extend NonEmpty
Methods duplicated :: NonEmpty a -> NonEmpty (NonEmpty a) # extended :: (NonEmpty a -> b) -> NonEmpty a -> NonEmpty b #
Extend Tree
Methods duplicated :: Tree a -> Tree (Tree a) # extended :: (Tree a -> b) -> Tree a -> Tree b #
Extend Seq
Methods duplicated :: Seq a -> Seq (Seq a) # extended :: (Seq a -> b) -> Seq a -> Seq b #
Semigroup m => Extend ((->) m)
Methods duplicated :: (m -> a) -> m -> m -> a # extended :: ((m -> a) -> b) -> (m -> a) -> m -> b #
Extend (Either a)
Methods duplicated :: Either a a -> Either a (Either a a) # extended :: (Either a a -> b) -> Either a a -> Either a b #
Extend ((,) e)
Methods duplicated :: (e, a) -> (e, (e, a)) # extended :: ((e, a) -> b) -> (e, a) -> (e, b) #
Extend (Proxy *)
Methods duplicated :: Proxy * a -> Proxy * (Proxy * a) # extended :: (Proxy * a -> b) -> Proxy * a -> Proxy * b #
Extend f => Extend (MaybeApply f)
Methods duplicated :: MaybeApply f a -> MaybeApply f (MaybeApply f a) # extended :: (MaybeApply f a -> b) -> MaybeApply f a -> MaybeApply f b #
(Extend w, Semigroup m) => Extend (TracedT m w)
Methods duplicated :: TracedT m w a -> TracedT m w (TracedT m w a) # extended :: (TracedT m w a -> b) -> TracedT m w a -> TracedT m w b #
Extend w => Extend (StoreT s w)
Methods duplicated :: StoreT s w a -> StoreT s w (StoreT s w a) # extended :: (StoreT s w a -> b) -> StoreT s w a -> StoreT s w b #
Extend w => Extend (EnvT e w)
Methods duplicated :: EnvT e w a -> EnvT e w (EnvT e w a) # extended :: (EnvT e w a -> b) -> EnvT e w a -> EnvT e w b #
Extend w => Extend (IdentityT * w)
Methods duplicated :: IdentityT * w a -> IdentityT * w (IdentityT * w a) # extended :: (IdentityT * w a -> b) -> IdentityT * w a -> IdentityT * w b #
(Extend f, Semigroup a) => Extend (Static f a)
Methods duplicated :: Static f a a -> Static f a (Static f a a) # extended :: (Static f a a -> b) -> Static f a a -> Static f a b #
Extend (Tagged * a)
Methods duplicated :: Tagged * a a -> Tagged * a (Tagged * a a) # extended :: (Tagged * a a -> b) -> Tagged * a a -> Tagged * a b #
(Extend f, Extend g) => Extend (Sum * f g)
Methods duplicated :: Sum * f g a -> Sum * f g (Sum * f g a) # extended :: (Sum * f g a -> b) -> Sum * f g a -> Sum * f g b #

class Alt f => Plus f where #

Laws:

zero <!> m = m
m <!> zero = m

If extended to an Alternative then zero should equal empty.

Minimal complete definition

zero

Methods

zero :: f a #

Instances

Plus []
Methods zero :: [a] #
Plus Maybe
Methods zero :: Maybe a #
Plus IO
Methods zero :: IO a #
Plus U1
Methods zero :: U1 a #
Plus Option
Methods zero :: Option a #
Plus IntMap
Methods zero :: IntMap a #
Plus Seq
Methods zero :: Seq a #
Plus f => Plus (Rec1 f)
Methods zero :: Rec1 f a #
MonadPlus m => Plus (WrappedMonad m)
Methods zero :: WrappedMonad m a #
Plus (Proxy *)
Methods zero :: Proxy * a #
Ord k => Plus (Map k)
Methods zero :: Map k a #
Alternative f => Plus (WrappedApplicative f)
Methods zero :: WrappedApplicative f a #
Plus f => Plus (Lift f)
Methods zero :: Lift f a #
(Bind f, Monad f) => Plus (MaybeT f)
Methods zero :: MaybeT f a #
(Apply f, Applicative f) => Plus (ListT f)
Methods zero :: ListT f a #
(Plus f, Plus g) => Plus ((:*:) f g)
Methods zero :: (f :*: g) a #
ArrowPlus a => Plus (WrappedArrow a b)
Methods zero :: WrappedArrow a b a #
Plus f => Plus (IdentityT * f)
Methods zero :: IdentityT * f a #
(Bind f, Monad f, Error e) => Plus (ErrorT e f)
Methods zero :: ErrorT e f a #
Plus f => Plus (Static f a)
Methods zero :: Static f a a #
Plus f => Plus (Reverse * f)
Methods zero :: Reverse * f a #
Plus f => Plus (Backwards * f)
Methods zero :: Backwards * f a #
Plus f => Plus (WriterT w f)
Methods zero :: WriterT w f a #
Plus f => Plus (WriterT w f)
Methods zero :: WriterT w f a #
Plus f => Plus (StateT e f)
Methods zero :: StateT e f a #
Plus f => Plus (StateT e f)
Methods zero :: StateT e f a #
(Bind f, Monad f, Semigroup e, Monoid e) => Plus (ExceptT e f)
Methods zero :: ExceptT e f a #
Plus f => Plus (M1 i c f)
Methods zero :: M1 i c f a #
(Plus f, Plus g) => Plus (Product * f g)
Methods zero :: Product * f g a #
Plus f => Plus (ReaderT * e f)
Methods zero :: ReaderT * e f a #
(Plus f, Functor g) => Plus (Compose * * f g)
Methods zero :: Compose * * f g a #
Plus f => Plus (RWST r w s f)
Methods zero :: RWST r w s f a #
Plus f => Plus (RWST r w s f)
Methods zero :: RWST r w s f a #

class Semigroupoid k k1 => Groupoid k k1 where #

semigroupoid with inverses. This technically should be a category with inverses, except we need to use Ob to define the valid objects for the category

Minimal complete definition

inv

Methods

inv :: k1 a b -> k1 b a #

Instances

Groupoid k k1 => Groupoid k (Dual k k k1)
Methods inv :: k1 a b -> k1 b a #

class Bifoldable t => Bifoldable1 t where #

Methods

bifold1 :: Semigroup m => t m m -> m #

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> t a b -> m #

Instances

Bifoldable1 Either
Methods bifold1 :: Semigroup m => Either m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Either a b -> m #
Bifoldable1 (,)
Methods bifold1 :: Semigroup m => (m, m) -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (a, b) -> m #
Bifoldable1 Arg
Methods bifold1 :: Semigroup m => Arg m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Arg a b -> m #
Bifoldable1 ((,,) x)
Methods bifold1 :: Semigroup m => (x, m, m) -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (x, a, b) -> m #
Bifoldable1 (Const *)
Methods bifold1 :: Semigroup m => Const * m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Const * a b -> m #
Bifoldable1 (Tagged *)
Methods bifold1 :: Semigroup m => Tagged * m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Tagged * a b -> m #
Bifoldable1 ((,,,) x y)
Methods bifold1 :: Semigroup m => (x, y, m, m) -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (x, y, a, b) -> m #
Bifoldable1 ((,,,,) x y z)
Methods bifold1 :: Semigroup m => (x, y, z, m, m) -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (x, y, z, a, b) -> m #
Bifoldable1 p => Bifoldable1 (WrappedBifunctor * * p)
Methods bifold1 :: Semigroup m => WrappedBifunctor * * p m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> WrappedBifunctor * * p a b -> m #
Foldable1 g => Bifoldable1 (Joker * * g)
Methods bifold1 :: Semigroup m => Joker * * g m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Joker * * g a b -> m #
Bifoldable1 p => Bifoldable1 (Flip * * p)
Methods bifold1 :: Semigroup m => Flip * * p m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Flip * * p a b -> m #
Foldable1 f => Bifoldable1 (Clown * * f)
Methods bifold1 :: Semigroup m => Clown * * f m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Clown * * f a b -> m #
(Bifoldable1 f, Bifoldable1 g) => Bifoldable1 (Product * * f g)
Methods bifold1 :: Semigroup m => Product * * f g m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Product * * f g a b -> m #
(Foldable1 f, Bifoldable1 p) => Bifoldable1 (Tannen * * * f p)
Methods bifold1 :: Semigroup m => Tannen * * * f p m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Tannen * * * f p a b -> m #
(Bifoldable1 p, Foldable1 f, Foldable1 g) => Bifoldable1 (Biff * * * * p f g)
Methods bifold1 :: Semigroup m => Biff * * * * p f g m m -> m # bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Biff * * * * p f g a b -> m #

bitraverse1_ :: (Bifoldable1 t, Apply f) => (a -> f b) -> (c -> f d) -> t a c -> f () #

bifor1_ :: (Bifoldable1 t, Apply f) => t a c -> (a -> f b) -> (c -> f d) -> f () #

bisequenceA1_ :: (Bifoldable1 t, Apply f) => t (f a) (f b) -> f () #

bifoldMapDefault1 :: (Bifoldable1 t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m #

Usable default for foldMap, but only if you define bifoldMap1 yourself

class (Bifoldable1 t, Bitraversable t) => Bitraversable1 t where #

Minimal complete definition

bitraverse1 | bisequence1

Methods

bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> t a c -> f (t b d) #

bisequence1 :: Apply f => t (f a) (f b) -> f (t a b) #

Instances

Bitraversable1 Either
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Either a c -> f (Either b d) # bisequence1 :: Apply f => Either (f a) (f b) -> f (Either a b) #
Bitraversable1 (,)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> (a, c) -> f (b, d) # bisequence1 :: Apply f => (f a, f b) -> f (a, b) #
Bitraversable1 Arg
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Arg a c -> f (Arg b d) # bisequence1 :: Apply f => Arg (f a) (f b) -> f (Arg a b) #
Bitraversable1 ((,,) x)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> (x, a, c) -> f (x, b, d) # bisequence1 :: Apply f => (x, f a, f b) -> f (x, a, b) #
Bitraversable1 (Const *)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Const * a c -> f (Const * b d) # bisequence1 :: Apply f => Const * (f a) (f b) -> f (Const * a b) #
Bitraversable1 (Tagged *)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Tagged * a c -> f (Tagged * b d) # bisequence1 :: Apply f => Tagged * (f a) (f b) -> f (Tagged * a b) #
Bitraversable1 ((,,,) x y)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> (x, y, a, c) -> f (x, y, b, d) # bisequence1 :: Apply f => (x, y, f a, f b) -> f (x, y, a, b) #
Bitraversable1 ((,,,,) x y z)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> (x, y, z, a, c) -> f (x, y, z, b, d) # bisequence1 :: Apply f => (x, y, z, f a, f b) -> f (x, y, z, a, b) #
Bitraversable1 p => Bitraversable1 (WrappedBifunctor * * p)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> WrappedBifunctor * * p a c -> f (WrappedBifunctor * * p b d) # bisequence1 :: Apply f => WrappedBifunctor * * p (f a) (f b) -> f (WrappedBifunctor * * p a b) #
Traversable1 g => Bitraversable1 (Joker * * g)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Joker * * g a c -> f (Joker * * g b d) # bisequence1 :: Apply f => Joker * * g (f a) (f b) -> f (Joker * * g a b) #
Bitraversable1 p => Bitraversable1 (Flip * * p)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Flip * * p a c -> f (Flip * * p b d) # bisequence1 :: Apply f => Flip * * p (f a) (f b) -> f (Flip * * p a b) #
Traversable1 f => Bitraversable1 (Clown * * f)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Clown * * f a c -> f (Clown * * f b d) # bisequence1 :: Apply f => Clown * * f (f a) (f b) -> f (Clown * * f a b) #
(Bitraversable1 f, Bitraversable1 g) => Bitraversable1 (Product * * f g)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Product * * f g a c -> f (Product * * f g b d) # bisequence1 :: Apply f => Product * * f g (f a) (f b) -> f (Product * * f g a b) #
(Traversable1 f, Bitraversable1 p) => Bitraversable1 (Tannen * * * f p)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Tannen * * * f p a c -> f (Tannen * * * f p b d) # bisequence1 :: Apply f => Tannen * * * f p (f a) (f b) -> f (Tannen * * * f p a b) #
(Bitraversable1 p, Traversable1 f, Traversable1 g) => Bitraversable1 (Biff * * * * p f g)
Methods bitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> Biff * * * * p f g a c -> f (Biff * * * * p f g b d) # bisequence1 :: Apply f => Biff * * * * p f g (f a) (f b) -> f (Biff * * * * p f g a b) #

bifoldMap1Default :: (Bitraversable1 t, Semigroup m) => (a -> m) -> (b -> m) -> t a b -> m #

class Foldable t => Foldable1 t where #

Methods

fold1 :: Semigroup m => t m -> m #

foldMap1 :: Semigroup m => (a -> m) -> t a -> m #

Instances

Foldable1 V1
Methods fold1 :: Semigroup m => V1 m -> m # foldMap1 :: Semigroup m => (a -> m) -> V1 a -> m # toNonEmpty :: V1 a -> NonEmpty a #
Foldable1 Par1
Methods fold1 :: Semigroup m => Par1 m -> m # foldMap1 :: Semigroup m => (a -> m) -> Par1 a -> m # toNonEmpty :: Par1 a -> NonEmpty a #
Foldable1 Identity
Methods fold1 :: Semigroup m => Identity m -> m # foldMap1 :: Semigroup m => (a -> m) -> Identity a -> m # toNonEmpty :: Identity a -> NonEmpty a #
Foldable1 NonEmpty
Methods fold1 :: Semigroup m => NonEmpty m -> m # foldMap1 :: Semigroup m => (a -> m) -> NonEmpty a -> m # toNonEmpty :: NonEmpty a -> NonEmpty a #
Foldable1 Complex
Methods fold1 :: Semigroup m => Complex m -> m # foldMap1 :: Semigroup m => (a -> m) -> Complex a -> m # toNonEmpty :: Complex a -> NonEmpty a #
Foldable1 Tree
Methods fold1 :: Semigroup m => Tree m -> m # foldMap1 :: Semigroup m => (a -> m) -> Tree a -> m # toNonEmpty :: Tree a -> NonEmpty a #
Foldable1 f => Foldable1 (Rec1 f)
Methods fold1 :: Semigroup m => Rec1 f m -> m # foldMap1 :: Semigroup m => (a -> m) -> Rec1 f a -> m # toNonEmpty :: Rec1 f a -> NonEmpty a #
Foldable1 ((,) a)
Methods fold1 :: Semigroup m => (a, m) -> m # foldMap1 :: Semigroup m => (a -> m) -> (a, a) -> m # toNonEmpty :: (a, a) -> NonEmpty a #
Foldable1 f => Foldable1 (Lift f)
Methods fold1 :: Semigroup m => Lift f m -> m # foldMap1 :: Semigroup m => (a -> m) -> Lift f a -> m # toNonEmpty :: Lift f a -> NonEmpty a #
(Foldable1 f, Foldable1 g) => Foldable1 ((:+:) f g)
Methods fold1 :: Semigroup m => (f :+: g) m -> m # foldMap1 :: Semigroup m => (a -> m) -> (f :+: g) a -> m # toNonEmpty :: (f :+: g) a -> NonEmpty a #
(Foldable1 f, Foldable1 g) => Foldable1 ((:*:) f g)
Methods fold1 :: Semigroup m => (f :: g) m -> m # foldMap1 :: Semigroup m => (a -> m) -> (f :: g) a -> m # toNonEmpty :: (f :*: g) a -> NonEmpty a #
(Foldable1 f, Foldable1 g) => Foldable1 ((:.:) f g)
Methods fold1 :: Semigroup m => (f :.: g) m -> m # foldMap1 :: Semigroup m => (a -> m) -> (f :.: g) a -> m # toNonEmpty :: (f :.: g) a -> NonEmpty a #
Bifoldable1 p => Foldable1 (Join * p)
Methods fold1 :: Semigroup m => Join * p m -> m # foldMap1 :: Semigroup m => (a -> m) -> Join * p a -> m # toNonEmpty :: Join * p a -> NonEmpty a #
Foldable1 m => Foldable1 (IdentityT * m)
Methods fold1 :: Semigroup m => IdentityT * m m -> m # foldMap1 :: Semigroup m => (a -> m) -> IdentityT * m a -> m # toNonEmpty :: IdentityT * m a -> NonEmpty a #
Foldable1 (Tagged * a)
Methods fold1 :: Semigroup m => Tagged * a m -> m # foldMap1 :: Semigroup m => (a -> m) -> Tagged * a a -> m # toNonEmpty :: Tagged * a a -> NonEmpty a #
Foldable1 f => Foldable1 (Reverse * f)
Methods fold1 :: Semigroup m => Reverse * f m -> m # foldMap1 :: Semigroup m => (a -> m) -> Reverse * f a -> m # toNonEmpty :: Reverse * f a -> NonEmpty a #
Foldable1 f => Foldable1 (Backwards * f)
Methods fold1 :: Semigroup m => Backwards * f m -> m # foldMap1 :: Semigroup m => (a -> m) -> Backwards * f a -> m # toNonEmpty :: Backwards * f a -> NonEmpty a #
Foldable1 f => Foldable1 (M1 i c f)
Methods fold1 :: Semigroup m => M1 i c f m -> m # foldMap1 :: Semigroup m => (a -> m) -> M1 i c f a -> m # toNonEmpty :: M1 i c f a -> NonEmpty a #
(Foldable1 f, Foldable1 g) => Foldable1 (Sum * f g)
Methods fold1 :: Semigroup m => Sum * f g m -> m # foldMap1 :: Semigroup m => (a -> m) -> Sum * f g a -> m # toNonEmpty :: Sum * f g a -> NonEmpty a #
(Foldable1 f, Foldable1 g) => Foldable1 (Product * f g)
Methods fold1 :: Semigroup m => Product * f g m -> m # foldMap1 :: Semigroup m => (a -> m) -> Product * f g a -> m # toNonEmpty :: Product * f g a -> NonEmpty a #
(Foldable1 f, Foldable1 g) => Foldable1 (Compose * * f g)
Methods fold1 :: Semigroup m => Compose * * f g m -> m # foldMap1 :: Semigroup m => (a -> m) -> Compose * * f g a -> m # toNonEmpty :: Compose * * f g a -> NonEmpty a #
Foldable1 g => Foldable1 (Joker * * g a)
Methods fold1 :: Semigroup m => Joker * * g a m -> m # foldMap1 :: Semigroup m => (a -> m) -> Joker * * g a a -> m # toNonEmpty :: Joker * * g a a -> NonEmpty a #

intercalate1 :: (Foldable1 t, Semigroup m) => m -> t m -> m #

Insert an m between each pair of 't m'. Equivalent to intercalateMap1 with id as the second argument.

>>> intercalate1 ", " $ "hello" :| ["how", "are", "you"]
"hello, how, are, you"

>>> intercalate1 ", " $ "hello" :| []
"hello"

>>> intercalate1 mempty $ "I" :| ["Am", "Fine", "You?"]
"IAmFineYou?"

intercalateMap1 :: (Foldable1 t, Semigroup m) => m -> (a -> m) -> t a -> m #

Insert m between each pair of m derived from a.

>>> intercalateMap1 " " show $ True :| [False, True]
"True False True"

>>> intercalateMap1 " " show $ True :| []
"True"

traverse1_ :: (Foldable1 t, Apply f) => (a -> f b) -> t a -> f () #

for1_ :: (Foldable1 t, Apply f) => t a -> (a -> f b) -> f () #

sequenceA1_ :: (Foldable1 t, Apply f) => t (f a) -> f () #

foldMapDefault1 :: (Foldable1 t, Monoid m) => (a -> m) -> t a -> m #

Usable default for foldMap, but only if you define foldMap1 yourself

asum1 :: (Foldable1 t, Alt m) => t (m a) -> m a #

class (Foldable1 t, Traversable t) => Traversable1 t where #

Minimal complete definition

traverse1 | sequence1

Methods

traverse1 :: Apply f => (a -> f b) -> t a -> f (t b) #

sequence1 :: Apply f => t (f b) -> f (t b) #

Instances

Traversable1 V1
Methods traverse1 :: Apply f => (a -> f b) -> V1 a -> f (V1 b) # sequence1 :: Apply f => V1 (f b) -> f (V1 b) #
Traversable1 Par1
Methods traverse1 :: Apply f => (a -> f b) -> Par1 a -> f (Par1 b) # sequence1 :: Apply f => Par1 (f b) -> f (Par1 b) #
Traversable1 Identity
Methods traverse1 :: Apply f => (a -> f b) -> Identity a -> f (Identity b) # sequence1 :: Apply f => Identity (f b) -> f (Identity b) #
Traversable1 NonEmpty
Methods traverse1 :: Apply f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) # sequence1 :: Apply f => NonEmpty (f b) -> f (NonEmpty b) #
Traversable1 Complex
Methods traverse1 :: Apply f => (a -> f b) -> Complex a -> f (Complex b) # sequence1 :: Apply f => Complex (f b) -> f (Complex b) #
Traversable1 Tree
Methods traverse1 :: Apply f => (a -> f b) -> Tree a -> f (Tree b) # sequence1 :: Apply f => Tree (f b) -> f (Tree b) #
Traversable1 f => Traversable1 (Rec1 f)
Methods traverse1 :: Apply f => (a -> f b) -> Rec1 f a -> f (Rec1 f b) # sequence1 :: Apply f => Rec1 f (f b) -> f (Rec1 f b) #
Traversable1 ((,) a)
Methods traverse1 :: Apply f => (a -> f b) -> (a, a) -> f (a, b) # sequence1 :: Apply f => (a, f b) -> f (a, b) #
Traversable1 f => Traversable1 (Lift f)
Methods traverse1 :: Apply f => (a -> f b) -> Lift f a -> f (Lift f b) # sequence1 :: Apply f => Lift f (f b) -> f (Lift f b) #
(Traversable1 f, Traversable1 g) => Traversable1 ((:+:) f g)
Methods traverse1 :: Apply f => (a -> f b) -> (f :+: g) a -> f ((f :+: g) b) # sequence1 :: Apply f => (f :+: g) (f b) -> f ((f :+: g) b) #
(Traversable1 f, Traversable1 g) => Traversable1 ((:*:) f g)
Methods traverse1 :: Apply f => (a -> f b) -> (f :: g) a -> f ((f :: g) b) # sequence1 :: Apply f => (f :: g) (f b) -> f ((f :: g) b) #
(Traversable1 f, Traversable1 g) => Traversable1 ((:.:) f g)
Methods traverse1 :: Apply f => (a -> f b) -> (f :.: g) a -> f ((f :.: g) b) # sequence1 :: Apply f => (f :.: g) (f b) -> f ((f :.: g) b) #
Bitraversable1 p => Traversable1 (Join * p)
Methods traverse1 :: Apply f => (a -> f b) -> Join * p a -> f (Join * p b) # sequence1 :: Apply f => Join * p (f b) -> f (Join * p b) #
Traversable1 f => Traversable1 (IdentityT * f)
Methods traverse1 :: Apply f => (a -> f b) -> IdentityT * f a -> f (IdentityT * f b) # sequence1 :: Apply f => IdentityT * f (f b) -> f (IdentityT * f b) #
Traversable1 (Tagged * a)
Methods traverse1 :: Apply f => (a -> f b) -> Tagged * a a -> f (Tagged * a b) # sequence1 :: Apply f => Tagged * a (f b) -> f (Tagged * a b) #
Traversable1 f => Traversable1 (Reverse * f)
Methods traverse1 :: Apply f => (a -> f b) -> Reverse * f a -> f (Reverse * f b) # sequence1 :: Apply f => Reverse * f (f b) -> f (Reverse * f b) #
Traversable1 f => Traversable1 (Backwards * f)
Methods traverse1 :: Apply f => (a -> f b) -> Backwards * f a -> f (Backwards * f b) # sequence1 :: Apply f => Backwards * f (f b) -> f (Backwards * f b) #
Traversable1 f => Traversable1 (M1 i c f)
Methods traverse1 :: Apply f => (a -> f b) -> M1 i c f a -> f (M1 i c f b) # sequence1 :: Apply f => M1 i c f (f b) -> f (M1 i c f b) #
(Traversable1 f, Traversable1 g) => Traversable1 (Sum * f g)
Methods traverse1 :: Apply f => (a -> f b) -> Sum * f g a -> f (Sum * f g b) # sequence1 :: Apply f => Sum * f g (f b) -> f (Sum * f g b) #
(Traversable1 f, Traversable1 g) => Traversable1 (Product * f g)
Methods traverse1 :: Apply f => (a -> f b) -> Product * f g a -> f (Product * f g b) # sequence1 :: Apply f => Product * f g (f b) -> f (Product * f g b) #
(Traversable1 f, Traversable1 g) => Traversable1 (Compose * * f g)
Methods traverse1 :: Apply f => (a -> f b) -> Compose * * f g a -> f (Compose * * f g b) # sequence1 :: Apply f => Compose * * f g (f b) -> f (Compose * * f g b) #
Traversable1 g => Traversable1 (Joker * * g a)
Methods traverse1 :: Apply f => (a -> f b) -> Joker * * g a a -> f (Joker * * g a b) # sequence1 :: Apply f => Joker * * g a (f b) -> f (Joker * * g a b) #

foldMap1Default :: (Traversable1 f, Semigroup m) => (a -> m) -> f a -> m #

class Semigroupoid k c where #

Category sans id

Minimal complete definition

o

Methods

o :: c j k1 -> c i j -> c i k1 #

Instances

Category k k1 => Semigroupoid k (WrappedCategory k k k1)
Methods o :: c j k1 -> c i j -> c i k1 #
Semigroup m => Semigroupoid k (Semi k k m)
Methods o :: c j k1 -> c i j -> c i k1 #
Semigroupoid * (->)
Methods o :: c j k1 -> c i j -> c i k1 #
Semigroupoid * (,)	http://en.wikipedia.org/wiki/Band_(mathematics)#Rectangular_bands
Methods o :: c j k1 -> c i j -> c i k1 #
Semigroupoid * Op
Methods o :: c j k1 -> c i j -> c i k1 #
Bind m => Semigroupoid * (Kleisli m)
Methods o :: c j k1 -> c i j -> c i k1 #
Semigroupoid * (Const *)
Methods o :: c j k1 -> c i j -> c i k1 #
Extend w => Semigroupoid * (Cokleisli w)
Methods o :: c j k1 -> c i j -> c i k1 #
Apply f => Semigroupoid * (Static f)
Methods o :: c j k1 -> c i j -> c i k1 #
Semigroupoid * (Tagged *)
Methods o :: c j k1 -> c i j -> c i k1 #

data WrappedCategory k k1 k2 a b :: forall k k1. (k1 -> k -> *) -> k1 -> k -> * #

Instances

Category k k1 => Category k (WrappedCategory k k k1)
Methods id :: cat a a # (.) :: cat b c -> cat a b -> cat a c #
Category k k1 => Semigroupoid k (WrappedCategory k k k1)
Methods o :: c j k1 -> c i j -> c i k1 #

data Semi k k1 m a b :: forall k k1. * -> k1 -> k -> * #

Instances

Monoid m => Category k (Semi k k m)
Methods id :: cat a a # (.) :: cat b c -> cat a b -> cat a c #
Semigroup m => Semigroupoid k (Semi k k m)
Methods o :: c j k1 -> c i j -> c i k1 #

class Semigroupoid k k1 => Ob k k1 a where #

Minimal complete definition

semiid

Methods

semiid :: k1 a a #

Instances

Ob * (->) a
Methods semiid :: a a a #
(Bind m, Monad m) => Ob * (Kleisli m) a
Methods semiid :: a a a #
(Extend w, Comonad w) => Ob * (Cokleisli w) a
Methods semiid :: a a a #

data Static f a b :: (* -> *) -> * -> * -> * #

Instances

Applicative f => Arrow (Static f)
Methods arr :: (b -> c) -> Static f b c # first :: Static f b c -> Static f (b, d) (c, d) # second :: Static f b c -> Static f (d, b) (d, c) # (***) :: Static f b c -> Static f b' c' -> Static f (b, b') (c, c') # (&&&) :: Static f b c -> Static f b c' -> Static f b (c, c') #
Alternative f => ArrowZero (Static f)
Methods zeroArrow :: Static f b c #
Alternative f => ArrowPlus (Static f)
Methods (<+>) :: Static f b c -> Static f b c -> Static f b c #
Applicative f => ArrowChoice (Static f)
Methods left :: Static f b c -> Static f (Either b d) (Either c d) # right :: Static f b c -> Static f (Either d b) (Either d c) # (+++) :: Static f b c -> Static f b' c' -> Static f (Either b b') (Either c c') # (\|\|\|) :: Static f b d -> Static f c d -> Static f (Either b c) d #
Applicative f => Category * (Static f)
Methods id :: cat a a # (.) :: cat b c -> cat a b -> cat a c #
Apply f => Semigroupoid * (Static f)
Methods o :: c j k1 -> c i j -> c i k1 #
Functor f => Functor (Static f a)
Methods fmap :: (a -> b) -> Static f a a -> Static f a b # (<$) :: a -> Static f a b -> Static f a a #
Applicative f => Applicative (Static f a)
Methods pure :: a -> Static f a a # (<>) :: Static f a (a -> b) -> Static f a a -> Static f a b # (>) :: Static f a a -> Static f a b -> Static f a b # (<*) :: Static f a a -> Static f a b -> Static f a a #
(Comonad f, Monoid a) => Comonad (Static f a)
Methods extract :: Static f a a -> a # duplicate :: Static f a a -> Static f a (Static f a a) # extend :: (Static f a a -> b) -> Static f a a -> Static f a b #
Plus f => Plus (Static f a)
Methods zero :: Static f a a #
Alt f => Alt (Static f a)
Methods (<!>) :: Static f a a -> Static f a a -> Static f a a # some :: Applicative (Static f a) => Static f a a -> Static f a [a] # many :: Applicative (Static f a) => Static f a a -> Static f a [a] #
Apply f => Apply (Static f a)
Methods (<.>) :: Static f a (a -> b) -> Static f a a -> Static f a b # (.>) :: Static f a a -> Static f a b -> Static f a b # (<.) :: Static f a a -> Static f a b -> Static f a a #
(Extend f, Semigroup a) => Extend (Static f a)
Methods duplicated :: Static f a a -> Static f a (Static f a a) # extended :: (Static f a a -> b) -> Static f a a -> Static f a b #