Copyright	(C) 2011-2018 Edward Kmett
License	BSD-style (see the file LICENSE)
Maintainer	Edward Kmett <ekmett@gmail.com>
Stability	provisional
Portability	portable
Safe Haskell	Trustworthy
Language	Haskell2010

Data.Functor.Bind.Class

Contents

Applyable functors
Wrappers
Bindable functors
Biappliable bifunctors

Description

This module is used to resolve the cyclic we get from defining these classes here rather than in a package upstream. Otherwise we'd get orphaned heads for many instances on the types in transformers and bifunctors.

Synopsis

class Functor f => Apply f where
- (<.>) :: f (a -> b) -> f a -> f b
- (.>) :: f a -> f b -> f b
- (<.) :: f a -> f b -> f a
- liftF2 :: (a -> b -> c) -> f a -> f b -> f c
newtype WrappedApplicative f a = WrapApplicative {
- unwrapApplicative :: f a
}
newtype MaybeApply f a = MaybeApply {
- runMaybeApply :: Either (f a) a
}
(<.*>) :: Apply f => f (a -> b) -> MaybeApply f a -> f b
(<*.>) :: Apply f => MaybeApply f (a -> b) -> f a -> f b
traverse1Maybe :: (Traversable t, Apply f) => (a -> f b) -> t a -> MaybeApply f (t b)
class Apply m => Bind m where
- (>>-) :: m a -> (a -> m b) -> m b
- join :: m (m a) -> m a
apDefault :: Bind f => f (a -> b) -> f a -> f b
returning :: Functor f => f a -> (a -> b) -> f b
class Bifunctor p => Biapply p where
- (<<.>>) :: p (a -> b) (c -> d) -> p a c -> p b d
- (.>>) :: p a b -> p c d -> p c d
- (<<.) :: p a b -> p c d -> p a b

Applyable functors

class Functor f => Apply f where Source #

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

(<.>) | liftF2

Methods

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

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

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

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

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

liftF2 :: (a -> b -> c) -> f a -> f b -> f c Source #

Lift a binary function into a comonad with zipping

Instances

Instances details

Apply ZipList Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: ZipList (a -> b) -> ZipList a -> ZipList b Source # (.>) :: ZipList a -> ZipList b -> ZipList b Source # (<.) :: ZipList a -> ZipList b -> ZipList a Source # liftF2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c Source #
Apply Complex Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Complex (a -> b) -> Complex a -> Complex b Source # (.>) :: Complex a -> Complex b -> Complex b Source # (<.) :: Complex a -> Complex b -> Complex a Source # liftF2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c Source #
Apply Identity Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Identity (a -> b) -> Identity a -> Identity b Source # (.>) :: Identity a -> Identity b -> Identity b Source # (<.) :: Identity a -> Identity b -> Identity a Source # liftF2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c Source #
Apply First Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: First (a -> b) -> First a -> First b Source # (.>) :: First a -> First b -> First b Source # (<.) :: First a -> First b -> First a Source # liftF2 :: (a -> b -> c) -> First a -> First b -> First c Source #
Apply Last Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Last (a -> b) -> Last a -> Last b Source # (.>) :: Last a -> Last b -> Last b Source # (<.) :: Last a -> Last b -> Last a Source # liftF2 :: (a -> b -> c) -> Last a -> Last b -> Last c Source #
Apply Down Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Down (a -> b) -> Down a -> Down b Source # (.>) :: Down a -> Down b -> Down b Source # (<.) :: Down a -> Down b -> Down a Source # liftF2 :: (a -> b -> c) -> Down a -> Down b -> Down c Source #
Apply First Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: First (a -> b) -> First a -> First b Source # (.>) :: First a -> First b -> First b Source # (<.) :: First a -> First b -> First a Source # liftF2 :: (a -> b -> c) -> First a -> First b -> First c Source #
Apply Last Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Last (a -> b) -> Last a -> Last b Source # (.>) :: Last a -> Last b -> Last b Source # (<.) :: Last a -> Last b -> Last a Source # liftF2 :: (a -> b -> c) -> Last a -> Last b -> Last c Source #
Apply Max Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Max (a -> b) -> Max a -> Max b Source # (.>) :: Max a -> Max b -> Max b Source # (<.) :: Max a -> Max b -> Max a Source # liftF2 :: (a -> b -> c) -> Max a -> Max b -> Max c Source #
Apply Min Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Min (a -> b) -> Min a -> Min b Source # (.>) :: Min a -> Min b -> Min b Source # (<.) :: Min a -> Min b -> Min a Source # liftF2 :: (a -> b -> c) -> Min a -> Min b -> Min c Source #
Apply Dual Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Dual (a -> b) -> Dual a -> Dual b Source # (.>) :: Dual a -> Dual b -> Dual b Source # (<.) :: Dual a -> Dual b -> Dual a Source # liftF2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c Source #
Apply Product Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Product (a -> b) -> Product a -> Product b Source # (.>) :: Product a -> Product b -> Product b Source # (<.) :: Product a -> Product b -> Product a Source # liftF2 :: (a -> b -> c) -> Product a -> Product b -> Product c Source #
Apply Sum Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Sum (a -> b) -> Sum a -> Sum b Source # (.>) :: Sum a -> Sum b -> Sum b Source # (<.) :: Sum a -> Sum b -> Sum a Source # liftF2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c Source #
Apply Par1 Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Par1 (a -> b) -> Par1 a -> Par1 b Source # (.>) :: Par1 a -> Par1 b -> Par1 b Source # (<.) :: Par1 a -> Par1 b -> Par1 a Source # liftF2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c Source #
Apply IntMap Source #	An `IntMap` is not `Applicative`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: IntMap (a -> b) -> IntMap a -> IntMap b Source # (.>) :: IntMap a -> IntMap b -> IntMap b Source # (<.) :: IntMap a -> IntMap b -> IntMap a Source # liftF2 :: (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c Source #
Apply Seq Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Seq (a -> b) -> Seq a -> Seq b Source # (.>) :: Seq a -> Seq b -> Seq b Source # (<.) :: Seq a -> Seq b -> Seq a Source # liftF2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c Source #
Apply Tree Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Tree (a -> b) -> Tree a -> Tree b Source # (.>) :: Tree a -> Tree b -> Tree b Source # (<.) :: Tree a -> Tree b -> Tree a Source # liftF2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c Source #
Apply IO Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: IO (a -> b) -> IO a -> IO b Source # (.>) :: IO a -> IO b -> IO b Source # (<.) :: IO a -> IO b -> IO a Source # liftF2 :: (a -> b -> c) -> IO a -> IO b -> IO c Source #
Apply Q Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Q (a -> b) -> Q a -> Q b Source # (.>) :: Q a -> Q b -> Q b Source # (<.) :: Q a -> Q b -> Q a Source # liftF2 :: (a -> b -> c) -> Q a -> Q b -> Q c Source #
Apply NonEmpty Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b Source # (.>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source # (<.) :: NonEmpty a -> NonEmpty b -> NonEmpty a Source # liftF2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c Source #
Apply Maybe Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Maybe (a -> b) -> Maybe a -> Maybe b Source # (.>) :: Maybe a -> Maybe b -> Maybe b Source # (<.) :: Maybe a -> Maybe b -> Maybe a Source # liftF2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c Source #
Apply [] Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: [a -> b] -> [a] -> [b] Source # (.>) :: [a] -> [b] -> [b] Source # (<.) :: [a] -> [b] -> [a] Source # liftF2 :: (a -> b -> c) -> [a] -> [b] -> [c] Source #
Monad m => Apply (WrappedMonad m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source # (.>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source # (<.) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a Source # liftF2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c Source #
Apply (Either a) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Either a (a0 -> b) -> Either a a0 -> Either a b Source # (.>) :: Either a a0 -> Either a b -> Either a b Source # (<.) :: Either a a0 -> Either a b -> Either a a0 Source # liftF2 :: (a0 -> b -> c) -> Either a a0 -> Either a b -> Either a c Source #
Apply (Proxy :: Type -> Type) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Proxy (a -> b) -> Proxy a -> Proxy b Source # (.>) :: Proxy a -> Proxy b -> Proxy b Source # (<.) :: Proxy a -> Proxy b -> Proxy a Source # liftF2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c Source #
Apply (U1 :: Type -> Type) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: U1 (a -> b) -> U1 a -> U1 b Source # (.>) :: U1 a -> U1 b -> U1 b Source # (<.) :: U1 a -> U1 b -> U1 a Source # liftF2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c Source #
Apply (V1 :: Type -> Type) Source #	A `V1` is not `Applicative`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: V1 (a -> b) -> V1 a -> V1 b Source # (.>) :: V1 a -> V1 b -> V1 b Source # (<.) :: V1 a -> V1 b -> V1 a Source # liftF2 :: (a -> b -> c) -> V1 a -> V1 b -> V1 c Source #
Ord k => Apply (Map k) Source #	A 'Map k' is not `Applicative`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Map k (a -> b) -> Map k a -> Map k b Source # (.>) :: Map k a -> Map k b -> Map k b Source # (<.) :: Map k a -> Map k b -> Map k a Source # liftF2 :: (a -> b -> c) -> Map k a -> Map k b -> Map k c Source #
Apply f => Apply (MaybeApply f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b Source # (.>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b Source # (<.) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a Source # liftF2 :: (a -> b -> c) -> MaybeApply f a -> MaybeApply f b -> MaybeApply f c Source #
Applicative f => Apply (WrappedApplicative f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WrappedApplicative f (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b Source # (.>) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f b Source # (<.) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f a Source # liftF2 :: (a -> b -> c) -> WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f c Source #
Apply f => Apply (Lift f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Lift f (a -> b) -> Lift f a -> Lift f b Source # (.>) :: Lift f a -> Lift f b -> Lift f b Source # (<.) :: Lift f a -> Lift f b -> Lift f a Source # liftF2 :: (a -> b -> c) -> Lift f a -> Lift f b -> Lift f c Source #
Apply m => Apply (ListT m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: ListT m (a -> b) -> ListT m a -> ListT m b Source # (.>) :: ListT m a -> ListT m b -> ListT m b Source # (<.) :: ListT m a -> ListT m b -> ListT m a Source # liftF2 :: (a -> b -> c) -> ListT m a -> ListT m b -> ListT m c Source #
(Functor m, Monad m) => Apply (MaybeT m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b Source # (.>) :: MaybeT m a -> MaybeT m b -> MaybeT m b Source # (<.) :: MaybeT m a -> MaybeT m b -> MaybeT m a Source # liftF2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c Source #
(Hashable k, Eq k) => Apply (HashMap k) Source #	A 'HashMap k' is not `Applicative`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: HashMap k (a -> b) -> HashMap k a -> HashMap k b Source # (.>) :: HashMap k a -> HashMap k b -> HashMap k b Source # (<.) :: HashMap k a -> HashMap k b -> HashMap k a Source # liftF2 :: (a -> b -> c) -> HashMap k a -> HashMap k b -> HashMap k c Source #
Semigroup m => Apply ((,) m) Source #	A `(,) m` is not `Applicative` unless its `m` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: (m, a -> b) -> (m, a) -> (m, b) Source # (.>) :: (m, a) -> (m, b) -> (m, b) Source # (<.) :: (m, a) -> (m, b) -> (m, a) Source # liftF2 :: (a -> b -> c) -> (m, a) -> (m, b) -> (m, c) Source #
Arrow a => Apply (WrappedArrow a b) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 Source # (.>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 Source # (<.) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 Source # liftF2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c Source #
Semigroup m => Apply (Const m :: Type -> Type) Source #	A `Const m` is not `Applicative` unless its `m` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Const m (a -> b) -> Const m a -> Const m b Source # (.>) :: Const m a -> Const m b -> Const m b Source # (<.) :: Const m a -> Const m b -> Const m a Source # liftF2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c Source #
Apply f => Apply (Alt f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Alt f (a -> b) -> Alt f a -> Alt f b Source # (.>) :: Alt f a -> Alt f b -> Alt f b Source # (<.) :: Alt f a -> Alt f b -> Alt f a Source # liftF2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c Source #
Apply f => Apply (Rec1 f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b Source # (.>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Source # (<.) :: Rec1 f a -> Rec1 f b -> Rec1 f a Source # liftF2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c Source #
Biapply p => Apply (Join p) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Join p (a -> b) -> Join p a -> Join p b Source # (.>) :: Join p a -> Join p b -> Join p b Source # (<.) :: Join p a -> Join p b -> Join p a Source # liftF2 :: (a -> b -> c) -> Join p a -> Join p b -> Join p c Source #
(Semigroup e, Apply w) => Apply (EnvT e w) Source #	An `EnvT e w` is not `Applicative` unless its `e` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: EnvT e w (a -> b) -> EnvT e w a -> EnvT e w b Source # (.>) :: EnvT e w a -> EnvT e w b -> EnvT e w b Source # (<.) :: EnvT e w a -> EnvT e w b -> EnvT e w a Source # liftF2 :: (a -> b -> c) -> EnvT e w a -> EnvT e w b -> EnvT e w c Source #
(Apply w, Semigroup s) => Apply (StoreT s w) Source #	A `StoreT s w` is not `Applicative` unless its `s` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: StoreT s w (a -> b) -> StoreT s w a -> StoreT s w b Source # (.>) :: StoreT s w a -> StoreT s w b -> StoreT s w b Source # (<.) :: StoreT s w a -> StoreT s w b -> StoreT s w a Source # liftF2 :: (a -> b -> c) -> StoreT s w a -> StoreT s w b -> StoreT s w c Source #
Apply w => Apply (TracedT m w) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: TracedT m w (a -> b) -> TracedT m w a -> TracedT m w b Source # (.>) :: TracedT m w a -> TracedT m w b -> TracedT m w b Source # (<.) :: TracedT m w a -> TracedT m w b -> TracedT m w a Source # liftF2 :: (a -> b -> c) -> TracedT m w a -> TracedT m w b -> TracedT m w c Source #
Apply f => Apply (Static f a) Source #
Instance details Defined in Data.Semigroupoid.Static Methods (<.>) :: Static f a (a0 -> b) -> Static f a a0 -> Static f a b Source # (.>) :: Static f a a0 -> Static f a b -> Static f a b Source # (<.) :: Static f a a0 -> Static f a b -> Static f a a0 Source # liftF2 :: (a0 -> b -> c) -> Static f a a0 -> Static f a b -> Static f a c Source #
Apply (Tagged a) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Tagged a (a0 -> b) -> Tagged a a0 -> Tagged a b Source # (.>) :: Tagged a a0 -> Tagged a b -> Tagged a b Source # (<.) :: Tagged a a0 -> Tagged a b -> Tagged a a0 Source # liftF2 :: (a0 -> b -> c) -> Tagged a a0 -> Tagged a b -> Tagged a c Source #
Apply f => Apply (Backwards f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Backwards f (a -> b) -> Backwards f a -> Backwards f b Source # (.>) :: Backwards f a -> Backwards f b -> Backwards f b Source # (<.) :: Backwards f a -> Backwards f b -> Backwards f a Source # liftF2 :: (a -> b -> c) -> Backwards f a -> Backwards f b -> Backwards f c Source #
(Functor m, Monad m) => Apply (ErrorT e m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b Source # (.>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b Source # (<.) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a Source # liftF2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c Source #
(Functor m, Monad m) => Apply (ExceptT e m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b Source # (.>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b Source # (<.) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a Source # liftF2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c Source #
Apply w => Apply (IdentityT w) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: IdentityT w (a -> b) -> IdentityT w a -> IdentityT w b Source # (.>) :: IdentityT w a -> IdentityT w b -> IdentityT w b Source # (<.) :: IdentityT w a -> IdentityT w b -> IdentityT w a Source # liftF2 :: (a -> b -> c) -> IdentityT w a -> IdentityT w b -> IdentityT w c Source #
Apply m => Apply (ReaderT e m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: ReaderT e m (a -> b) -> ReaderT e m a -> ReaderT e m b Source # (.>) :: ReaderT e m a -> ReaderT e m b -> ReaderT e m b Source # (<.) :: ReaderT e m a -> ReaderT e m b -> ReaderT e m a Source # liftF2 :: (a -> b -> c) -> ReaderT e m a -> ReaderT e m b -> ReaderT e m c Source #
Bind m => Apply (StateT s m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b Source # (.>) :: StateT s m a -> StateT s m b -> StateT s m b Source # (<.) :: StateT s m a -> StateT s m b -> StateT s m a Source # liftF2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c Source #
Bind m => Apply (StateT s m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b Source # (.>) :: StateT s m a -> StateT s m b -> StateT s m b Source # (<.) :: StateT s m a -> StateT s m b -> StateT s m a Source # liftF2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c Source #
Bind m => Apply (WriterT w m) Source #	Since: 5.3.6
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b Source # (.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b Source # (<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a Source # liftF2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c Source #
(Apply m, Semigroup w) => Apply (WriterT w m) Source #	A `WriterT w m` is not `Applicative` unless its `w` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b Source # (.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b Source # (<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a Source # liftF2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c Source #
(Apply m, Semigroup w) => Apply (WriterT w m) Source #	A `WriterT w m` is not `Applicative` unless its `w` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b Source # (.>) :: WriterT w m a -> WriterT w m b -> WriterT w m b Source # (<.) :: WriterT w m a -> WriterT w m b -> WriterT w m a Source # liftF2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c Source #
Semigroup f => Apply (Constant f :: Type -> Type) Source #	A `Constant f` is not `Applicative` unless its `f` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Constant f (a -> b) -> Constant f a -> Constant f b Source # (.>) :: Constant f a -> Constant f b -> Constant f b Source # (<.) :: Constant f a -> Constant f b -> Constant f a Source # liftF2 :: (a -> b -> c) -> Constant f a -> Constant f b -> Constant f c Source #
Apply f => Apply (Reverse f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Reverse f (a -> b) -> Reverse f a -> Reverse f b Source # (.>) :: Reverse f a -> Reverse f b -> Reverse f b Source # (<.) :: Reverse f a -> Reverse f b -> Reverse f a Source # liftF2 :: (a -> b -> c) -> Reverse f a -> Reverse f b -> Reverse f c Source #
(Apply f, Apply g) => Apply (Product f g) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Product f g (a -> b) -> Product f g a -> Product f g b Source # (.>) :: Product f g a -> Product f g b -> Product f g b Source # (<.) :: Product f g a -> Product f g b -> Product f g a Source # liftF2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c Source #
(Apply f, Apply g) => Apply (f :*: g) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: (f :: g) (a -> b) -> (f :: g) a -> (f :: g) b Source # (.>) :: (f :: g) a -> (f :: g) b -> (f :: g) b Source # (<.) :: (f :: g) a -> (f :: g) b -> (f :: g) a Source # liftF2 :: (a -> b -> c) -> (f :: g) a -> (f :: g) b -> (f :: g) c Source #
Semigroup c => Apply (K1 i c :: Type -> Type) Source #	A `K1 i c` is not `Applicative` unless its `c` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b Source # (.>) :: K1 i c a -> K1 i c b -> K1 i c b Source # (<.) :: K1 i c a -> K1 i c b -> K1 i c a Source # liftF2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0 Source #
Apply (Cokleisli w a) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Cokleisli w a (a0 -> b) -> Cokleisli w a a0 -> Cokleisli w a b Source # (.>) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a b Source # (<.) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a a0 Source # liftF2 :: (a0 -> b -> c) -> Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a c Source #
Apply (ContT r m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: ContT r m (a -> b) -> ContT r m a -> ContT r m b Source # (.>) :: ContT r m a -> ContT r m b -> ContT r m b Source # (<.) :: ContT r m a -> ContT r m b -> ContT r m a Source # liftF2 :: (a -> b -> c) -> ContT r m a -> ContT r m b -> ContT r m c Source #
Apply ((->) m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: (m -> (a -> b)) -> (m -> a) -> m -> b Source # (.>) :: (m -> a) -> (m -> b) -> m -> b Source # (<.) :: (m -> a) -> (m -> b) -> m -> a Source # liftF2 :: (a -> b -> c) -> (m -> a) -> (m -> b) -> m -> c Source #
(Apply f, Apply g) => Apply (Compose f g) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b Source # (.>) :: Compose f g a -> Compose f g b -> Compose f g b Source # (<.) :: Compose f g a -> Compose f g b -> Compose f g a Source # liftF2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c Source #
(Apply f, Apply g) => Apply (f :.: g) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b Source # (.>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b Source # (<.) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a Source # liftF2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c Source #
Apply f => Apply (M1 i t f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: M1 i t f (a -> b) -> M1 i t f a -> M1 i t f b Source # (.>) :: M1 i t f a -> M1 i t f b -> M1 i t f b Source # (<.) :: M1 i t f a -> M1 i t f b -> M1 i t f a Source # liftF2 :: (a -> b -> c) -> M1 i t f a -> M1 i t f b -> M1 i t f c Source #
Bind m => Apply (RWST r w s m) Source #	Since: 5.3.6
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b Source # (.>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b Source # (<.) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a Source # liftF2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c Source #
(Bind m, Semigroup w) => Apply (RWST r w s m) Source #	An `RWST r w s m` is not `Applicative` unless its `w` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b Source # (.>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b Source # (<.) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a Source # liftF2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c Source #
(Bind m, Semigroup w) => Apply (RWST r w s m) Source #	An `RWST r w s m` is not `Applicative` unless its `w` is a `Monoid`, but it is an instance of `Apply`
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b Source # (.>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b Source # (<.) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a Source # liftF2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c Source #

Wrappers

newtype WrappedApplicative f a Source #

Wrap an Applicative to be used as a member of Apply

Constructors

WrapApplicative
Fields unwrapApplicative :: f a

Instances

Instances details

Alternative f => Alternative (WrappedApplicative f) Source #
Instance details Defined in Data.Functor.Bind.Class 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] #
Applicative f => Applicative (WrappedApplicative f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods pure :: a -> WrappedApplicative f a # (<>) :: WrappedApplicative f (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b # liftA2 :: (a -> b -> c) -> WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f c # (>) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f b # (<*) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f a #
Functor f => Functor (WrappedApplicative f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods fmap :: (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b # (<$) :: a -> WrappedApplicative f b -> WrappedApplicative f a #
Alternative f => Alt (WrappedApplicative f) Source #
Instance details Defined in Data.Functor.Alt Methods (<!>) :: WrappedApplicative f a -> WrappedApplicative f a -> WrappedApplicative f a Source # some :: Applicative (WrappedApplicative f) => WrappedApplicative f a -> WrappedApplicative f [a] Source # many :: Applicative (WrappedApplicative f) => WrappedApplicative f a -> WrappedApplicative f [a] Source #
Applicative f => Apply (WrappedApplicative f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: WrappedApplicative f (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b Source # (.>) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f b Source # (<.) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f a Source # liftF2 :: (a -> b -> c) -> WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f c Source #
Alternative f => Plus (WrappedApplicative f) Source #
Instance details Defined in Data.Functor.Plus Methods zero :: WrappedApplicative f a Source #

newtype MaybeApply f a Source #

Transform an Apply into an Applicative by adding a unit.

Constructors

MaybeApply
Fields runMaybeApply :: Either (f a) a

Instances

Instances details

Apply f => Applicative (MaybeApply f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods pure :: a -> MaybeApply f a # (<>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b # liftA2 :: (a -> b -> c) -> MaybeApply f a -> MaybeApply f b -> MaybeApply f c # (>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b # (<*) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a #
Functor f => Functor (MaybeApply f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods fmap :: (a -> b) -> MaybeApply f a -> MaybeApply f b # (<$) :: a -> MaybeApply f b -> MaybeApply f a #
Comonad f => Comonad (MaybeApply f) Source #
Instance details Defined in Data.Functor.Bind.Class 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) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<.>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b Source # (.>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b Source # (<.) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a Source # liftF2 :: (a -> b -> c) -> MaybeApply f a -> MaybeApply f b -> MaybeApply f c Source #
Extend f => Extend (MaybeApply f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods duplicated :: MaybeApply f a -> MaybeApply f (MaybeApply f a) Source # extended :: (MaybeApply f a -> b) -> MaybeApply f a -> MaybeApply f b Source #

(<.*>) :: Apply f => f (a -> b) -> MaybeApply f a -> f b infixl 4 Source #

Apply a non-empty container of functions to a possibly-empty-with-unit container of values.

(<*.>) :: Apply f => MaybeApply f (a -> b) -> f a -> f b infixl 4 Source #

Apply a possibly-empty-with-unit container of functions to a non-empty container of values.

traverse1Maybe :: (Traversable t, Apply f) => (a -> f b) -> t a -> MaybeApply f (t b) Source #

Traverse a Traversable using Apply, getting the results back in a MaybeApply.

Bindable functors

class Apply m => Bind m where Source #

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 Source #

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

Instances

Instances details

Bind Complex Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Complex a -> (a -> Complex b) -> Complex b Source # join :: Complex (Complex a) -> Complex a Source #
Bind Identity Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Identity a -> (a -> Identity b) -> Identity b Source # join :: Identity (Identity a) -> Identity a Source #
Bind First Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: First a -> (a -> First b) -> First b Source # join :: First (First a) -> First a Source #
Bind Last Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Last a -> (a -> Last b) -> Last b Source # join :: Last (Last a) -> Last a Source #
Bind Down Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Down a -> (a -> Down b) -> Down b Source # join :: Down (Down a) -> Down a Source #
Bind First Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: First a -> (a -> First b) -> First b Source # join :: First (First a) -> First a Source #
Bind Last Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Last a -> (a -> Last b) -> Last b Source # join :: Last (Last a) -> Last a Source #
Bind Max Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Max a -> (a -> Max b) -> Max b Source # join :: Max (Max a) -> Max a Source #
Bind Min Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Min a -> (a -> Min b) -> Min b Source # join :: Min (Min a) -> Min a Source #
Bind Dual Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Dual a -> (a -> Dual b) -> Dual b Source # join :: Dual (Dual a) -> Dual a Source #
Bind Product Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Product a -> (a -> Product b) -> Product b Source # join :: Product (Product a) -> Product a Source #
Bind Sum Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Sum a -> (a -> Sum b) -> Sum b Source # join :: Sum (Sum a) -> Sum a Source #
Bind IntMap Source #	An `IntMap` is not a `Monad`, but it is an instance of `Bind`
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: IntMap a -> (a -> IntMap b) -> IntMap b Source # join :: IntMap (IntMap a) -> IntMap a Source #
Bind Seq Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Seq a -> (a -> Seq b) -> Seq b Source # join :: Seq (Seq a) -> Seq a Source #
Bind Tree Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Tree a -> (a -> Tree b) -> Tree b Source # join :: Tree (Tree a) -> Tree a Source #
Bind IO Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: IO a -> (a -> IO b) -> IO b Source # join :: IO (IO a) -> IO a Source #
Bind Q Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Q a -> (a -> Q b) -> Q b Source # join :: Q (Q a) -> Q a Source #
Bind NonEmpty Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b Source # join :: NonEmpty (NonEmpty a) -> NonEmpty a Source #
Bind Maybe Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Maybe a -> (a -> Maybe b) -> Maybe b Source # join :: Maybe (Maybe a) -> Maybe a Source #
Bind [] Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: [a] -> (a -> [b]) -> [b] Source # join :: [[a]] -> [a] Source #
Monad m => Bind (WrappedMonad m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b Source # join :: WrappedMonad m (WrappedMonad m a) -> WrappedMonad m a Source #
Bind (Either a) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Either a a0 -> (a0 -> Either a b) -> Either a b Source # join :: Either a (Either a a0) -> Either a a0 Source #
Bind (Proxy :: Type -> Type) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Proxy a -> (a -> Proxy b) -> Proxy b Source # join :: Proxy (Proxy a) -> Proxy a Source #
Bind (V1 :: Type -> Type) Source #	A `V1` is not a `Monad`, but it is an instance of `Bind`
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: V1 a -> (a -> V1 b) -> V1 b Source # join :: V1 (V1 a) -> V1 a Source #
Ord k => Bind (Map k) Source #	A 'Map k' is not a `Monad`, but it is an instance of `Bind`
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Map k a -> (a -> Map k b) -> Map k b Source # join :: Map k (Map k a) -> Map k a Source #
(Apply m, Monad m) => Bind (ListT m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: ListT m a -> (a -> ListT m b) -> ListT m b Source # join :: ListT m (ListT m a) -> ListT m a Source #
(Functor m, Monad m) => Bind (MaybeT m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b Source # join :: MaybeT m (MaybeT m a) -> MaybeT m a Source #
(Hashable k, Eq k) => Bind (HashMap k) Source #	A 'HashMap k' is not a `Monad`, but it is an instance of `Bind`
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: HashMap k a -> (a -> HashMap k b) -> HashMap k b Source # join :: HashMap k (HashMap k a) -> HashMap k a Source #
Semigroup m => Bind ((,) m) Source #	A `(,) m` is not a `Monad` unless its `m` is a `Monoid`, but it is an instance of `Bind`
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: (m, a) -> (a -> (m, b)) -> (m, b) Source # join :: (m, (m, a)) -> (m, a) Source #
Bind f => Bind (Alt f) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Alt f a -> (a -> Alt f b) -> Alt f b Source # join :: Alt f (Alt f a) -> Alt f a Source #
Bind (Tagged a) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Tagged a a0 -> (a0 -> Tagged a b) -> Tagged a b Source # join :: Tagged a (Tagged a a0) -> Tagged a a0 Source #
(Functor m, Monad m) => Bind (ErrorT e m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: ErrorT e m a -> (a -> ErrorT e m b) -> ErrorT e m b Source # join :: ErrorT e m (ErrorT e m a) -> ErrorT e m a Source #
(Functor m, Monad m) => Bind (ExceptT e m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b Source # join :: ExceptT e m (ExceptT e m a) -> ExceptT e m a Source #
Bind m => Bind (IdentityT m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: IdentityT m a -> (a -> IdentityT m b) -> IdentityT m b Source # join :: IdentityT m (IdentityT m a) -> IdentityT m a Source #
Bind m => Bind (ReaderT e m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: ReaderT e m a -> (a -> ReaderT e m b) -> ReaderT e m b Source # join :: ReaderT e m (ReaderT e m a) -> ReaderT e m a Source #
Bind m => Bind (StateT s m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b Source # join :: StateT s m (StateT s m a) -> StateT s m a Source #
Bind m => Bind (StateT s m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b Source # join :: StateT s m (StateT s m a) -> StateT s m a Source #
Bind m => Bind (WriterT w m) Source #	Since: 5.3.6
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b Source # join :: WriterT w m (WriterT w m a) -> WriterT w m a Source #
(Bind m, Semigroup w) => Bind (WriterT w m) Source #	A `WriterT w m` is not a `Monad` unless its `w` is a `Monoid`, but it is an instance of `Bind`
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b Source # join :: WriterT w m (WriterT w m a) -> WriterT w m a Source #
(Bind m, Semigroup w) => Bind (WriterT w m) Source #	A `WriterT w m` is not a `Monad` unless its `w` is a `Monoid`, but it is an instance of `Bind`
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b Source # join :: WriterT w m (WriterT w m a) -> WriterT w m a Source #
(Bind f, Bind g) => Bind (Product f g) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: Product f g a -> (a -> Product f g b) -> Product f g b Source # join :: Product f g (Product f g a) -> Product f g a Source #
Bind (ContT r m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: ContT r m a -> (a -> ContT r m b) -> ContT r m b Source # join :: ContT r m (ContT r m a) -> ContT r m a Source #
Bind ((->) m) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: (m -> a) -> (a -> m -> b) -> m -> b Source # join :: (m -> (m -> a)) -> m -> a Source #
Bind m => Bind (RWST r w s m) Source #	Since: 5.3.6
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b Source # join :: RWST r w s m (RWST r w s m a) -> RWST r w s m a Source #
(Bind m, Semigroup w) => Bind (RWST r w s m) Source #	An `RWST r w s m` is not a `Monad` unless its `w` is a `Monoid`, but it is an instance of `Bind`
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b Source # join :: RWST r w s m (RWST r w s m a) -> RWST r w s m a Source #
(Bind m, Semigroup w) => Bind (RWST r w s m) Source #	An `RWST r w s m` is not a `Monad` unless its `w` is a `Monoid`, but it is an instance of `Bind`
Instance details Defined in Data.Functor.Bind.Class Methods (>>-) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b Source # join :: RWST r w s m (RWST r w s m a) -> RWST r w s m a Source #

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

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

Biappliable bifunctors

class Bifunctor p => Biapply p where Source #

Minimal complete definition

(<<.>>)

Methods

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

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

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

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

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

Instances

Instances details

Biapply Arg Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: Arg (a -> b) (c -> d) -> Arg a c -> Arg b d Source # (.>>) :: Arg a b -> Arg c d -> Arg c d Source # (<<.) :: Arg a b -> Arg c d -> Arg a b Source #
Biapply (,) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: (a -> b, c -> d) -> (a, c) -> (b, d) Source # (.>>) :: (a, b) -> (c, d) -> (c, d) Source # (<<.) :: (a, b) -> (c, d) -> (a, b) Source #
Biapply (Const :: Type -> Type -> Type) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: Const (a -> b) (c -> d) -> Const a c -> Const b d Source # (.>>) :: Const a b -> Const c d -> Const c d Source # (<<.) :: Const a b -> Const c d -> Const a b Source #
Biapply (Tagged :: Type -> Type -> Type) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: Tagged (a -> b) (c -> d) -> Tagged a c -> Tagged b d Source # (.>>) :: Tagged a b -> Tagged c d -> Tagged c d Source # (<<.) :: Tagged a b -> Tagged c d -> Tagged a b Source #
Semigroup x => Biapply ((,,) x) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: (x, a -> b, c -> d) -> (x, a, c) -> (x, b, d) Source # (.>>) :: (x, a, b) -> (x, c, d) -> (x, c, d) Source # (<<.) :: (x, a, b) -> (x, c, d) -> (x, a, b) Source #
(Semigroup x, Semigroup y) => Biapply ((,,,) x y) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: (x, y, a -> b, c -> d) -> (x, y, a, c) -> (x, y, b, d) Source # (.>>) :: (x, y, a, b) -> (x, y, c, d) -> (x, y, c, d) Source # (<<.) :: (x, y, a, b) -> (x, y, c, d) -> (x, y, a, b) Source #
Apply f => Biapply (Clown f :: Type -> Type -> Type) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: Clown f (a -> b) (c -> d) -> Clown f a c -> Clown f b d Source # (.>>) :: Clown f a b -> Clown f c d -> Clown f c d Source # (<<.) :: Clown f a b -> Clown f c d -> Clown f a b Source #
Biapply p => Biapply (Flip p) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: Flip p (a -> b) (c -> d) -> Flip p a c -> Flip p b d Source # (.>>) :: Flip p a b -> Flip p c d -> Flip p c d Source # (<<.) :: Flip p a b -> Flip p c d -> Flip p a b Source #
Apply g => Biapply (Joker g :: Type -> Type -> Type) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: Joker g (a -> b) (c -> d) -> Joker g a c -> Joker g b d Source # (.>>) :: Joker g a b -> Joker g c d -> Joker g c d Source # (<<.) :: Joker g a b -> Joker g c d -> Joker g a b Source #
Biapply p => Biapply (WrappedBifunctor p) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: WrappedBifunctor p (a -> b) (c -> d) -> WrappedBifunctor p a c -> WrappedBifunctor p b d Source # (.>>) :: WrappedBifunctor p a b -> WrappedBifunctor p c d -> WrappedBifunctor p c d Source # (<<.) :: WrappedBifunctor p a b -> WrappedBifunctor p c d -> WrappedBifunctor p a b Source #
(Semigroup x, Semigroup y, Semigroup z) => Biapply ((,,,,) x y z) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: (x, y, z, a -> b, c -> d) -> (x, y, z, a, c) -> (x, y, z, b, d) Source # (.>>) :: (x, y, z, a, b) -> (x, y, z, c, d) -> (x, y, z, c, d) Source # (<<.) :: (x, y, z, a, b) -> (x, y, z, c, d) -> (x, y, z, a, b) Source #
(Biapply p, Biapply q) => Biapply (Product p q) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: Product p q (a -> b) (c -> d) -> Product p q a c -> Product p q b d Source # (.>>) :: Product p q a b -> Product p q c d -> Product p q c d Source # (<<.) :: Product p q a b -> Product p q c d -> Product p q a b Source #
(Apply f, Biapply p) => Biapply (Tannen f p) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: Tannen f p (a -> b) (c -> d) -> Tannen f p a c -> Tannen f p b d Source # (.>>) :: Tannen f p a b -> Tannen f p c d -> Tannen f p c d Source # (<<.) :: Tannen f p a b -> Tannen f p c d -> Tannen f p a b Source #
(Biapply p, Apply f, Apply g) => Biapply (Biff p f g) Source #
Instance details Defined in Data.Functor.Bind.Class Methods (<<.>>) :: Biff p f g (a -> b) (c -> d) -> Biff p f g a c -> Biff p f g b d Source # (.>>) :: Biff p f g a b -> Biff p f g c d -> Biff p f g c d Source # (<<.) :: Biff p f g a b -> Biff p f g c d -> Biff p f g a b Source #