papa-semigroupoids-export-0.3.1: export useful functions from semigroupoids.

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

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

 Methodsbimap :: (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 # Methodsbimap :: (a -> b) -> (c -> d) -> (a, c) -> (b, d) #first :: (a -> b) -> (a, c) -> (b, c) #second :: (b -> c) -> (a, b) -> (a, c) # Methodsbimap :: (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) Methodsbimap :: (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) Methodsbimap :: (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) # Methodsbimap :: (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) Methodsbimap :: (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) Methodsbimap :: (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) Methodsbimap :: (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) Methodsbimap :: (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

 Methods(<<.>>) :: (a -> b, c -> d) -> (a, c) -> (b, d) #(.>>) :: (a, b) -> (c, d) -> (c, d) #(<<.) :: (a, b) -> (c, d) -> (a, b) # 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) # 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 # 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) # 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]] # Methods() :: Maybe a -> Maybe a -> Maybe a #some :: Applicative Maybe => Maybe a -> Maybe [a] #many :: Applicative Maybe => Maybe a -> Maybe [a] # 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] # Methods() :: V1 a -> V1 a -> V1 a #some :: Applicative V1 => V1 a -> V1 [a] #many :: Applicative V1 => V1 a -> V1 [a] # Methods() :: U1 a -> U1 a -> U1 a #some :: Applicative U1 => U1 a -> U1 [a] #many :: Applicative U1 => U1 a -> U1 [a] # Methods() :: Option a -> Option a -> Option a #some :: Applicative Option => Option a -> Option [a] #many :: Applicative Option => Option a -> Option [a] # Methods() :: NonEmpty a -> NonEmpty a -> NonEmpty a #some :: Applicative NonEmpty => NonEmpty a -> NonEmpty [a] #many :: Applicative NonEmpty => NonEmpty a -> NonEmpty [a] # Methods() :: IntMap a -> IntMap a -> IntMap a #some :: Applicative IntMap => IntMap a -> IntMap [a] #many :: Applicative IntMap => IntMap a -> IntMap [a] # 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] # 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] # 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] # Methods(<.>) :: Maybe (a -> b) -> Maybe a -> Maybe b #(.>) :: Maybe a -> Maybe b -> Maybe b #(<.) :: Maybe a -> Maybe b -> Maybe a # Methods(<.>) :: IO (a -> b) -> IO a -> IO b #(.>) :: IO a -> IO b -> IO b #(<.) :: IO a -> IO b -> IO a # Methods(<.>) :: Identity (a -> b) -> Identity a -> Identity b #(.>) :: Identity a -> Identity b -> Identity b #(<.) :: Identity a -> Identity b -> Identity a # Methods(<.>) :: Option (a -> b) -> Option a -> Option b #(.>) :: Option a -> Option b -> Option b #(<.) :: Option a -> Option b -> Option a # Methods(<.>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b #(.>) :: NonEmpty a -> NonEmpty b -> NonEmpty b #(<.) :: NonEmpty a -> NonEmpty b -> NonEmpty a # Methods(<.>) :: Complex (a -> b) -> Complex a -> Complex b #(.>) :: Complex a -> Complex b -> Complex b #(<.) :: Complex a -> Complex b -> Complex a # Methods(<.>) :: ZipList (a -> b) -> ZipList a -> ZipList b #(.>) :: ZipList a -> ZipList b -> ZipList b #(<.) :: ZipList a -> ZipList b -> ZipList a # 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 # Methods(<.>) :: Tree (a -> b) -> Tree a -> Tree b #(.>) :: Tree a -> Tree b -> Tree b #(<.) :: Tree a -> Tree b -> Tree a # 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 # 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 # 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

 Methodsfmap :: (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b #(<$) :: a -> WrappedApplicative f b -> WrappedApplicative f a # Methodspure :: 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 # Methods(<|>) :: WrappedApplicative f a -> WrappedApplicative f a -> WrappedApplicative f a #some :: WrappedApplicative f a -> WrappedApplicative f [a] #many :: WrappedApplicative f a -> WrappedApplicative f [a] # Methods 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] # 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) Methodsfmap :: (a -> b) -> MaybeApply f a -> MaybeApply f b #(<$) :: a -> MaybeApply f b -> MaybeApply f a # Apply f => Applicative (MaybeApply f) Methodspure :: 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) Methodsextract :: 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) Methodsduplicated :: 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 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] # Methods(>>-) :: Maybe a -> (a -> Maybe b) -> Maybe b #join :: Maybe (Maybe a) -> Maybe a # Methods(>>-) :: IO a -> (a -> IO b) -> IO b #join :: IO (IO a) -> IO a # Methods(>>-) :: Identity a -> (a -> Identity b) -> Identity b #join :: Identity (Identity a) -> Identity a # Methods(>>-) :: Option a -> (a -> Option b) -> Option b #join :: Option (Option a) -> Option a # Methods(>>-) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b #join :: NonEmpty (NonEmpty a) -> NonEmpty a # Methods(>>-) :: Complex a -> (a -> Complex b) -> Complex b #join :: Complex (Complex a) -> Complex a # 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 # Methods(>>-) :: Tree a -> (a -> Tree b) -> Tree b #join :: Tree (Tree a) -> Tree a # 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 # 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  MethodsliftB :: Bind b => b a -> IdentityT * b a # Monoid w => BindTrans (WriterT w) MethodsliftB :: Bind b => b a -> WriterT w b a # Monoid w => BindTrans (WriterT w) MethodsliftB :: Bind b => b a -> WriterT w b a # MethodsliftB :: Bind b => b a -> StateT s b a # MethodsliftB :: Bind b => b a -> StateT s b a # MethodsliftB :: Bind b => b a -> ReaderT * e b a # MethodsliftB :: Bind b => b a -> ContT * r b a # Monoid w => BindTrans (RWST r w s) MethodsliftB :: Bind b => b a -> RWST r w s b a # Monoid w => BindTrans (RWST r w s) MethodsliftB :: Bind b => b a -> RWST r w s b a # class Functor w => Extend w where # Minimal complete definition 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 [] Methodsduplicated :: [a] -> [[a]] #extended :: ([a] -> b) -> [a] -> [b] # Methodsduplicated :: Maybe a -> Maybe (Maybe a) #extended :: (Maybe a -> b) -> Maybe a -> Maybe b # Methodsduplicated :: Identity a -> Identity (Identity a) #extended :: (Identity a -> b) -> Identity a -> Identity b # Methodsduplicated :: NonEmpty a -> NonEmpty (NonEmpty a) #extended :: (NonEmpty a -> b) -> NonEmpty a -> NonEmpty b # Methodsduplicated :: Tree a -> Tree (Tree a) #extended :: (Tree a -> b) -> Tree a -> Tree b # Methodsduplicated :: Seq a -> Seq (Seq a) #extended :: (Seq a -> b) -> Seq a -> Seq b # Semigroup m => Extend ((->) m) Methodsduplicated :: (m -> a) -> m -> m -> a #extended :: ((m -> a) -> b) -> (m -> a) -> m -> b # Extend (Either a) Methodsduplicated :: Either a a -> Either a (Either a a) #extended :: (Either a a -> b) -> Either a a -> Either a b # Extend ((,) e) Methodsduplicated :: (e, a) -> (e, (e, a)) #extended :: ((e, a) -> b) -> (e, a) -> (e, b) # Methodsduplicated :: Proxy * a -> Proxy * (Proxy * a) #extended :: (Proxy * a -> b) -> Proxy * a -> Proxy * b # Extend f => Extend (MaybeApply f) Methodsduplicated :: 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) Methodsduplicated :: 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) Methodsduplicated :: 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) Methodsduplicated :: 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) Methodsduplicated :: 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) Methodsduplicated :: 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 # Methodsduplicated :: 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) Methodsduplicated :: 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 [] Methodszero :: [a] # Methodszero :: Maybe a # Methodszero :: IO a # Methodszero :: U1 a # Methodszero :: Option a # Methodszero :: IntMap a # Methodszero :: Seq a # Plus f => Plus (Rec1 f) Methodszero :: Rec1 f a # MonadPlus m => Plus (WrappedMonad m) Methodszero :: WrappedMonad m a # Methodszero :: Proxy * a # Ord k => Plus (Map k) Methodszero :: Map k a # Methods Plus f => Plus (Lift f) Methodszero :: Lift f a # (Bind f, Monad f) => Plus (MaybeT f) Methodszero :: MaybeT f a # (Apply f, Applicative f) => Plus (ListT f) Methodszero :: ListT f a # (Plus f, Plus g) => Plus ((:*:) f g) Methodszero :: (f :*: g) a # ArrowPlus a => Plus (WrappedArrow a b) Methodszero :: WrappedArrow a b a # Plus f => Plus (IdentityT * f) Methodszero :: IdentityT * f a # (Bind f, Monad f, Error e) => Plus (ErrorT e f) Methodszero :: ErrorT e f a # Plus f => Plus (Static f a) Methodszero :: Static f a a # Plus f => Plus (Reverse * f) Methodszero :: Reverse * f a # Plus f => Plus (Backwards * f) Methodszero :: Backwards * f a # Plus f => Plus (WriterT w f) Methodszero :: WriterT w f a # Plus f => Plus (WriterT w f) Methodszero :: WriterT w f a # Plus f => Plus (StateT e f) Methodszero :: StateT e f a # Plus f => Plus (StateT e f) Methodszero :: StateT e f a # (Bind f, Monad f, Semigroup e, Monoid e) => Plus (ExceptT e f) Methodszero :: ExceptT e f a # Plus f => Plus (M1 i c f) Methodszero :: M1 i c f a # (Plus f, Plus g) => Plus (Product * f g) Methodszero :: Product * f g a # Plus f => Plus (ReaderT * e f) Methodszero :: ReaderT * e f a # (Plus f, Functor g) => Plus (Compose * * f g) Methodszero :: Compose * * f g a # Plus f => Plus (RWST r w s f) Methodszero :: RWST r w s f a # Plus f => Plus (RWST r w s f) Methodszero :: 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) Methodsinv :: 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  Methodsbifold1 :: Semigroup m => Either m m -> m #bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Either a b -> m # Methodsbifold1 :: Semigroup m => (m, m) -> m #bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (a, b) -> m # Methodsbifold1 :: Semigroup m => Arg m m -> m #bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Arg a b -> m # Methodsbifold1 :: Semigroup m => (x, m, m) -> m #bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (x, a, b) -> m # Methodsbifold1 :: Semigroup m => Const * m m -> m #bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Const * a b -> m # Methodsbifold1 :: Semigroup m => Tagged * m m -> m #bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Tagged * a b -> m # Bifoldable1 ((,,,) x y) Methodsbifold1 :: Semigroup m => (x, y, m, m) -> m #bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (x, y, a, b) -> m # Bifoldable1 ((,,,,) x y z) Methodsbifold1 :: Semigroup m => (x, y, z, m, m) -> m #bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> (x, y, z, a, b) -> m # Methodsbifold1 :: Semigroup m => WrappedBifunctor * * p m m -> m #bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> WrappedBifunctor * * p a b -> m # Foldable1 g => Bifoldable1 (Joker * * g) Methodsbifold1 :: Semigroup m => Joker * * g m m -> m #bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Joker * * g a b -> m # Bifoldable1 p => Bifoldable1 (Flip * * p) Methodsbifold1 :: Semigroup m => Flip * * p m m -> m #bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Flip * * p a b -> m # Foldable1 f => Bifoldable1 (Clown * * f) Methodsbifold1 :: 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) Methodsbifold1 :: 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) Methodsbifold1 :: 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) Methodsbifold1 :: 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 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  Methodsbitraverse1 :: 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) # Methodsbitraverse1 :: Apply f => (a -> f b) -> (c -> f d) -> (a, c) -> f (b, d) #bisequence1 :: Apply f => (f a, f b) -> f (a, b) # Methodsbitraverse1 :: 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) # Methodsbitraverse1 :: 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) # Methodsbitraverse1 :: 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) # Methodsbitraverse1 :: 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) Methodsbitraverse1 :: 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) Methodsbitraverse1 :: 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) # Methodsbitraverse1 :: 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) # Methodsbitraverse1 :: 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) # Methodsbitraverse1 :: 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) # Methodsbitraverse1 :: 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) Methodsbitraverse1 :: 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) Methodsbitraverse1 :: 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) Methodsbitraverse1 :: 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  Methodsfold1 :: Semigroup m => V1 m -> m #foldMap1 :: Semigroup m => (a -> m) -> V1 a -> m #toNonEmpty :: V1 a -> NonEmpty a # Methodsfold1 :: Semigroup m => Par1 m -> m #foldMap1 :: Semigroup m => (a -> m) -> Par1 a -> m #toNonEmpty :: Par1 a -> NonEmpty a # Methodsfold1 :: Semigroup m => Identity m -> m #foldMap1 :: Semigroup m => (a -> m) -> Identity a -> m #toNonEmpty :: Identity a -> NonEmpty a # Methodsfold1 :: Semigroup m => NonEmpty m -> m #foldMap1 :: Semigroup m => (a -> m) -> NonEmpty a -> m #toNonEmpty :: NonEmpty a -> NonEmpty a # Methodsfold1 :: Semigroup m => Complex m -> m #foldMap1 :: Semigroup m => (a -> m) -> Complex a -> m #toNonEmpty :: Complex a -> NonEmpty a # Methodsfold1 :: Semigroup m => Tree m -> m #foldMap1 :: Semigroup m => (a -> m) -> Tree a -> m #toNonEmpty :: Tree a -> NonEmpty a # Foldable1 f => Foldable1 (Rec1 f) Methodsfold1 :: Semigroup m => Rec1 f m -> m #foldMap1 :: Semigroup m => (a -> m) -> Rec1 f a -> m #toNonEmpty :: Rec1 f a -> NonEmpty a # Foldable1 ((,) a) Methodsfold1 :: Semigroup m => (a, m) -> m #foldMap1 :: Semigroup m => (a -> m) -> (a, a) -> m #toNonEmpty :: (a, a) -> NonEmpty a # Foldable1 f => Foldable1 (Lift f) Methodsfold1 :: 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) Methodsfold1 :: 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) Methodsfold1 :: 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) Methodsfold1 :: 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) Methodsfold1 :: 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) Methodsfold1 :: Semigroup m => IdentityT * m m -> m #foldMap1 :: Semigroup m => (a -> m) -> IdentityT * m a -> m #toNonEmpty :: IdentityT * m a -> NonEmpty a # Methodsfold1 :: 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) Methodsfold1 :: 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) Methodsfold1 :: 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) Methodsfold1 :: 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) Methodsfold1 :: 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) Methodsfold1 :: 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) Methodsfold1 :: 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) Methodsfold1 :: 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

Methods

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

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

Instances

 Methodstraverse1 :: Apply f => (a -> f b) -> V1 a -> f (V1 b) #sequence1 :: Apply f => V1 (f b) -> f (V1 b) # Methodstraverse1 :: Apply f => (a -> f b) -> Par1 a -> f (Par1 b) #sequence1 :: Apply f => Par1 (f b) -> f (Par1 b) # Methodstraverse1 :: Apply f => (a -> f b) -> Identity a -> f (Identity b) #sequence1 :: Apply f => Identity (f b) -> f (Identity b) # Methodstraverse1 :: Apply f => (a -> f b) -> NonEmpty a -> f (NonEmpty b) #sequence1 :: Apply f => NonEmpty (f b) -> f (NonEmpty b) # Methodstraverse1 :: Apply f => (a -> f b) -> Complex a -> f (Complex b) #sequence1 :: Apply f => Complex (f b) -> f (Complex b) # Methodstraverse1 :: Apply f => (a -> f b) -> Tree a -> f (Tree b) #sequence1 :: Apply f => Tree (f b) -> f (Tree b) # Traversable1 f => Traversable1 (Rec1 f) Methodstraverse1 :: Apply f => (a -> f b) -> Rec1 f a -> f (Rec1 f b) #sequence1 :: Apply f => Rec1 f (f b) -> f (Rec1 f b) # Methodstraverse1 :: Apply f => (a -> f b) -> (a, a) -> f (a, b) #sequence1 :: Apply f => (a, f b) -> f (a, b) # Traversable1 f => Traversable1 (Lift f) Methodstraverse1 :: 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) Methodstraverse1 :: 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) Methodstraverse1 :: 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) Methodstraverse1 :: Apply f => (a -> f b) -> (f :.: g) a -> f ((f :.: g) b) #sequence1 :: Apply f => (f :.: g) (f b) -> f ((f :.: g) b) # Methodstraverse1 :: Apply f => (a -> f b) -> Join * p a -> f (Join * p b) #sequence1 :: Apply f => Join * p (f b) -> f (Join * p b) # Methodstraverse1 :: Apply f => (a -> f b) -> IdentityT * f a -> f (IdentityT * f b) #sequence1 :: Apply f => IdentityT * f (f b) -> f (IdentityT * f b) # Methodstraverse1 :: Apply f => (a -> f b) -> Tagged * a a -> f (Tagged * a b) #sequence1 :: Apply f => Tagged * a (f b) -> f (Tagged * a b) # Methodstraverse1 :: Apply f => (a -> f b) -> Reverse * f a -> f (Reverse * f b) #sequence1 :: Apply f => Reverse * f (f b) -> f (Reverse * f b) # Methodstraverse1 :: 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) Methodstraverse1 :: 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) Methodstraverse1 :: 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) Methodstraverse1 :: 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) Methodstraverse1 :: 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) Methodstraverse1 :: 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) Methodso :: c j k1 -> c i j -> c i k1 # Semigroup m => Semigroupoid k (Semi k k m) Methodso :: c j k1 -> c i j -> c i k1 # Semigroupoid * (->) Methodso :: c j k1 -> c i j -> c i k1 # http://en.wikipedia.org/wiki/Band_(mathematics)#Rectangular_bands Methodso :: c j k1 -> c i j -> c i k1 # Methodso :: c j k1 -> c i j -> c i k1 # Bind m => Semigroupoid * (Kleisli m) Methodso :: c j k1 -> c i j -> c i k1 # Methodso :: c j k1 -> c i j -> c i k1 # Extend w => Semigroupoid * (Cokleisli w) Methodso :: c j k1 -> c i j -> c i k1 # Apply f => Semigroupoid * (Static f) Methodso :: c j k1 -> c i j -> c i k1 # Methodso :: 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) Methodsid :: cat a a #(.) :: cat b c -> cat a b -> cat a c # Category k k1 => Semigroupoid k (WrappedCategory k k k1) Methodso :: 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) Methodsid :: cat a a #(.) :: cat b c -> cat a b -> cat a c # Semigroup m => Semigroupoid k (Semi k k m) Methodso :: 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 Methodssemiid :: a a a # (Bind m, Monad m) => Ob * (Kleisli m) a Methodssemiid :: a a a # (Extend w, Comonad w) => Ob * (Cokleisli w) a Methodssemiid :: a a a #

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

Instances

 Applicative f => Arrow (Static f) Methodsarr :: (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) MethodszeroArrow :: 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) Methodsleft :: 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) Methodsid :: cat a a #(.) :: cat b c -> cat a b -> cat a c # Apply f => Semigroupoid * (Static f) Methodso :: c j k1 -> c i j -> c i k1 # Functor f => Functor (Static f a) Methodsfmap :: (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) Methodspure :: 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) Methodsextract :: 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) Methodszero :: 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) Methodsduplicated :: 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 #