{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE DeriveTraversable #-}
-----------------------------------------------------------------------------
-- |
-- Module      :  Data.Functor.KeepLeft
-- Copyright   :  (C) 2024 Koji Miyazato
-- License     :  BSD-style (see the file LICENSE)
--
-- Maintainer  :  Koji Miyazato <viercc@gmail.com>
-- Stability   :  experimental
module Data.Functor.KeepLeft where

import Data.Functor.Const (Const(..))
import Data.Semigroup (First(..))
import Data.Bitraversable (Bitraversable (..))
import Data.Bifoldable (Bifoldable)
import Data.Bifunctor (Bifunctor)

import Data.Functor.Classes ( Eq1, Ord1, Eq2, Ord2 )
import Data.Functor.Bind.Class ( Apply(..), Bind(..) )
import Control.Monad.Isolated ( Isolated(..) )
import Control.Monad.Ideal ( MonadIdeal(..), impureBindDefault )

import Data.Semigroup.Bifoldable (Bifoldable1)
import Data.Semigroup.Bitraversable (Bitraversable1)
import Data.Semigroup.Traversable.Class (Bitraversable1(..))

-- | Another choices of instances for 'Const'. @'KeepLeft' c@ have 'Apply' instance isomorphic to
--   @Const ('First' c)@, which can also (exceptionally) have 'Bind' instance.
--
-- The most used constant functor 'Const' lacks the instance of 'Bind', due to incompatibility
-- between 'Bind' and 'Apply'.
-- 
-- @
-- instance (Semigroup c) => 'Apply' ('Const' c)
-- @
-- 
-- While any @Semigroup c@ instance yields a lawful @Apply (Const c)@ instance, large number of
-- them do not have @Bind (Const c)@ instance compatible to @Apply@. One of few exceptional @Semigroup@
-- instance is the one defined as below, which is isomorphic to @'First' c@ semigroup.
--
-- @
-- (<>) :: c -> c -> c
-- x <> _ = x
-- @
newtype KeepLeft c a = KeepLeft { forall c a. KeepLeft c a -> c
getKeepLeft :: c }
  deriving stock (Int -> KeepLeft c a -> ShowS
[KeepLeft c a] -> ShowS
KeepLeft c a -> String
(Int -> KeepLeft c a -> ShowS)
-> (KeepLeft c a -> String)
-> ([KeepLeft c a] -> ShowS)
-> Show (KeepLeft c a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall c a. Show c => Int -> KeepLeft c a -> ShowS
forall c a. Show c => [KeepLeft c a] -> ShowS
forall c a. Show c => KeepLeft c a -> String
$cshowsPrec :: forall c a. Show c => Int -> KeepLeft c a -> ShowS
showsPrec :: Int -> KeepLeft c a -> ShowS
$cshow :: forall c a. Show c => KeepLeft c a -> String
show :: KeepLeft c a -> String
$cshowList :: forall c a. Show c => [KeepLeft c a] -> ShowS
showList :: [KeepLeft c a] -> ShowS
Show, ReadPrec [KeepLeft c a]
ReadPrec (KeepLeft c a)
Int -> ReadS (KeepLeft c a)
ReadS [KeepLeft c a]
(Int -> ReadS (KeepLeft c a))
-> ReadS [KeepLeft c a]
-> ReadPrec (KeepLeft c a)
-> ReadPrec [KeepLeft c a]
-> Read (KeepLeft c a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall c a. Read c => ReadPrec [KeepLeft c a]
forall c a. Read c => ReadPrec (KeepLeft c a)
forall c a. Read c => Int -> ReadS (KeepLeft c a)
forall c a. Read c => ReadS [KeepLeft c a]
$creadsPrec :: forall c a. Read c => Int -> ReadS (KeepLeft c a)
readsPrec :: Int -> ReadS (KeepLeft c a)
$creadList :: forall c a. Read c => ReadS [KeepLeft c a]
readList :: ReadS [KeepLeft c a]
$creadPrec :: forall c a. Read c => ReadPrec (KeepLeft c a)
readPrec :: ReadPrec (KeepLeft c a)
$creadListPrec :: forall c a. Read c => ReadPrec [KeepLeft c a]
readListPrec :: ReadPrec [KeepLeft c a]
Read, KeepLeft c a -> KeepLeft c a -> Bool
(KeepLeft c a -> KeepLeft c a -> Bool)
-> (KeepLeft c a -> KeepLeft c a -> Bool) -> Eq (KeepLeft c a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall c a. Eq c => KeepLeft c a -> KeepLeft c a -> Bool
$c== :: forall c a. Eq c => KeepLeft c a -> KeepLeft c a -> Bool
== :: KeepLeft c a -> KeepLeft c a -> Bool
$c/= :: forall c a. Eq c => KeepLeft c a -> KeepLeft c a -> Bool
/= :: KeepLeft c a -> KeepLeft c a -> Bool
Eq, Eq (KeepLeft c a)
Eq (KeepLeft c a) =>
(KeepLeft c a -> KeepLeft c a -> Ordering)
-> (KeepLeft c a -> KeepLeft c a -> Bool)
-> (KeepLeft c a -> KeepLeft c a -> Bool)
-> (KeepLeft c a -> KeepLeft c a -> Bool)
-> (KeepLeft c a -> KeepLeft c a -> Bool)
-> (KeepLeft c a -> KeepLeft c a -> KeepLeft c a)
-> (KeepLeft c a -> KeepLeft c a -> KeepLeft c a)
-> Ord (KeepLeft c a)
KeepLeft c a -> KeepLeft c a -> Bool
KeepLeft c a -> KeepLeft c a -> Ordering
KeepLeft c a -> KeepLeft c a -> KeepLeft c a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall c a. Ord c => Eq (KeepLeft c a)
forall c a. Ord c => KeepLeft c a -> KeepLeft c a -> Bool
forall c a. Ord c => KeepLeft c a -> KeepLeft c a -> Ordering
forall c a. Ord c => KeepLeft c a -> KeepLeft c a -> KeepLeft c a
$ccompare :: forall c a. Ord c => KeepLeft c a -> KeepLeft c a -> Ordering
compare :: KeepLeft c a -> KeepLeft c a -> Ordering
$c< :: forall c a. Ord c => KeepLeft c a -> KeepLeft c a -> Bool
< :: KeepLeft c a -> KeepLeft c a -> Bool
$c<= :: forall c a. Ord c => KeepLeft c a -> KeepLeft c a -> Bool
<= :: KeepLeft c a -> KeepLeft c a -> Bool
$c> :: forall c a. Ord c => KeepLeft c a -> KeepLeft c a -> Bool
> :: KeepLeft c a -> KeepLeft c a -> Bool
$c>= :: forall c a. Ord c => KeepLeft c a -> KeepLeft c a -> Bool
>= :: KeepLeft c a -> KeepLeft c a -> Bool
$cmax :: forall c a. Ord c => KeepLeft c a -> KeepLeft c a -> KeepLeft c a
max :: KeepLeft c a -> KeepLeft c a -> KeepLeft c a
$cmin :: forall c a. Ord c => KeepLeft c a -> KeepLeft c a -> KeepLeft c a
min :: KeepLeft c a -> KeepLeft c a -> KeepLeft c a
Ord, (forall a b. (a -> b) -> KeepLeft c a -> KeepLeft c b)
-> (forall a b. a -> KeepLeft c b -> KeepLeft c a)
-> Functor (KeepLeft c)
forall a b. a -> KeepLeft c b -> KeepLeft c a
forall a b. (a -> b) -> KeepLeft c a -> KeepLeft c b
forall c a b. a -> KeepLeft c b -> KeepLeft c a
forall c a b. (a -> b) -> KeepLeft c a -> KeepLeft c b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall c a b. (a -> b) -> KeepLeft c a -> KeepLeft c b
fmap :: forall a b. (a -> b) -> KeepLeft c a -> KeepLeft c b
$c<$ :: forall c a b. a -> KeepLeft c b -> KeepLeft c a
<$ :: forall a b. a -> KeepLeft c b -> KeepLeft c a
Functor, (forall m. Monoid m => KeepLeft c m -> m)
-> (forall m a. Monoid m => (a -> m) -> KeepLeft c a -> m)
-> (forall m a. Monoid m => (a -> m) -> KeepLeft c a -> m)
-> (forall a b. (a -> b -> b) -> b -> KeepLeft c a -> b)
-> (forall a b. (a -> b -> b) -> b -> KeepLeft c a -> b)
-> (forall b a. (b -> a -> b) -> b -> KeepLeft c a -> b)
-> (forall b a. (b -> a -> b) -> b -> KeepLeft c a -> b)
-> (forall a. (a -> a -> a) -> KeepLeft c a -> a)
-> (forall a. (a -> a -> a) -> KeepLeft c a -> a)
-> (forall a. KeepLeft c a -> [a])
-> (forall a. KeepLeft c a -> Bool)
-> (forall a. KeepLeft c a -> Int)
-> (forall a. Eq a => a -> KeepLeft c a -> Bool)
-> (forall a. Ord a => KeepLeft c a -> a)
-> (forall a. Ord a => KeepLeft c a -> a)
-> (forall a. Num a => KeepLeft c a -> a)
-> (forall a. Num a => KeepLeft c a -> a)
-> Foldable (KeepLeft c)
forall a. Eq a => a -> KeepLeft c a -> Bool
forall a. Num a => KeepLeft c a -> a
forall a. Ord a => KeepLeft c a -> a
forall m. Monoid m => KeepLeft c m -> m
forall a. KeepLeft c a -> Bool
forall a. KeepLeft c a -> Int
forall a. KeepLeft c a -> [a]
forall a. (a -> a -> a) -> KeepLeft c a -> a
forall c a. Eq a => a -> KeepLeft c a -> Bool
forall c a. Num a => KeepLeft c a -> a
forall c a. Ord a => KeepLeft c a -> a
forall m a. Monoid m => (a -> m) -> KeepLeft c a -> m
forall c m. Monoid m => KeepLeft c m -> m
forall c a. KeepLeft c a -> Bool
forall c a. KeepLeft c a -> Int
forall c a. KeepLeft c a -> [a]
forall b a. (b -> a -> b) -> b -> KeepLeft c a -> b
forall a b. (a -> b -> b) -> b -> KeepLeft c a -> b
forall c a. (a -> a -> a) -> KeepLeft c a -> a
forall c m a. Monoid m => (a -> m) -> KeepLeft c a -> m
forall c b a. (b -> a -> b) -> b -> KeepLeft c a -> b
forall c a b. (a -> b -> b) -> b -> KeepLeft c a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall c m. Monoid m => KeepLeft c m -> m
fold :: forall m. Monoid m => KeepLeft c m -> m
$cfoldMap :: forall c m a. Monoid m => (a -> m) -> KeepLeft c a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> KeepLeft c a -> m
$cfoldMap' :: forall c m a. Monoid m => (a -> m) -> KeepLeft c a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> KeepLeft c a -> m
$cfoldr :: forall c a b. (a -> b -> b) -> b -> KeepLeft c a -> b
foldr :: forall a b. (a -> b -> b) -> b -> KeepLeft c a -> b
$cfoldr' :: forall c a b. (a -> b -> b) -> b -> KeepLeft c a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> KeepLeft c a -> b
$cfoldl :: forall c b a. (b -> a -> b) -> b -> KeepLeft c a -> b
foldl :: forall b a. (b -> a -> b) -> b -> KeepLeft c a -> b
$cfoldl' :: forall c b a. (b -> a -> b) -> b -> KeepLeft c a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> KeepLeft c a -> b
$cfoldr1 :: forall c a. (a -> a -> a) -> KeepLeft c a -> a
foldr1 :: forall a. (a -> a -> a) -> KeepLeft c a -> a
$cfoldl1 :: forall c a. (a -> a -> a) -> KeepLeft c a -> a
foldl1 :: forall a. (a -> a -> a) -> KeepLeft c a -> a
$ctoList :: forall c a. KeepLeft c a -> [a]
toList :: forall a. KeepLeft c a -> [a]
$cnull :: forall c a. KeepLeft c a -> Bool
null :: forall a. KeepLeft c a -> Bool
$clength :: forall c a. KeepLeft c a -> Int
length :: forall a. KeepLeft c a -> Int
$celem :: forall c a. Eq a => a -> KeepLeft c a -> Bool
elem :: forall a. Eq a => a -> KeepLeft c a -> Bool
$cmaximum :: forall c a. Ord a => KeepLeft c a -> a
maximum :: forall a. Ord a => KeepLeft c a -> a
$cminimum :: forall c a. Ord a => KeepLeft c a -> a
minimum :: forall a. Ord a => KeepLeft c a -> a
$csum :: forall c a. Num a => KeepLeft c a -> a
sum :: forall a. Num a => KeepLeft c a -> a
$cproduct :: forall c a. Num a => KeepLeft c a -> a
product :: forall a. Num a => KeepLeft c a -> a
Foldable, Functor (KeepLeft c)
Foldable (KeepLeft c)
(Functor (KeepLeft c), Foldable (KeepLeft c)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> KeepLeft c a -> f (KeepLeft c b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    KeepLeft c (f a) -> f (KeepLeft c a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> KeepLeft c a -> m (KeepLeft c b))
-> (forall (m :: * -> *) a.
    Monad m =>
    KeepLeft c (m a) -> m (KeepLeft c a))
-> Traversable (KeepLeft c)
forall c. Functor (KeepLeft c)
forall c. Foldable (KeepLeft c)
forall c (m :: * -> *) a.
Monad m =>
KeepLeft c (m a) -> m (KeepLeft c a)
forall c (f :: * -> *) a.
Applicative f =>
KeepLeft c (f a) -> f (KeepLeft c a)
forall c (m :: * -> *) a b.
Monad m =>
(a -> m b) -> KeepLeft c a -> m (KeepLeft c b)
forall c (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> KeepLeft c a -> f (KeepLeft c b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
KeepLeft c (m a) -> m (KeepLeft c a)
forall (f :: * -> *) a.
Applicative f =>
KeepLeft c (f a) -> f (KeepLeft c a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> KeepLeft c a -> m (KeepLeft c b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> KeepLeft c a -> f (KeepLeft c b)
$ctraverse :: forall c (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> KeepLeft c a -> f (KeepLeft c b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> KeepLeft c a -> f (KeepLeft c b)
$csequenceA :: forall c (f :: * -> *) a.
Applicative f =>
KeepLeft c (f a) -> f (KeepLeft c a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
KeepLeft c (f a) -> f (KeepLeft c a)
$cmapM :: forall c (m :: * -> *) a b.
Monad m =>
(a -> m b) -> KeepLeft c a -> m (KeepLeft c b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> KeepLeft c a -> m (KeepLeft c b)
$csequence :: forall c (m :: * -> *) a.
Monad m =>
KeepLeft c (m a) -> m (KeepLeft c a)
sequence :: forall (m :: * -> *) a.
Monad m =>
KeepLeft c (m a) -> m (KeepLeft c a)
Traversable)
  deriving (NonEmpty (KeepLeft c a) -> KeepLeft c a
KeepLeft c a -> KeepLeft c a -> KeepLeft c a
(KeepLeft c a -> KeepLeft c a -> KeepLeft c a)
-> (NonEmpty (KeepLeft c a) -> KeepLeft c a)
-> (forall b. Integral b => b -> KeepLeft c a -> KeepLeft c a)
-> Semigroup (KeepLeft c a)
forall b. Integral b => b -> KeepLeft c a -> KeepLeft c a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a c. NonEmpty (KeepLeft c a) -> KeepLeft c a
forall a c. KeepLeft c a -> KeepLeft c a -> KeepLeft c a
forall a c b. Integral b => b -> KeepLeft c a -> KeepLeft c a
$c<> :: forall a c. KeepLeft c a -> KeepLeft c a -> KeepLeft c a
<> :: KeepLeft c a -> KeepLeft c a -> KeepLeft c a
$csconcat :: forall a c. NonEmpty (KeepLeft c a) -> KeepLeft c a
sconcat :: NonEmpty (KeepLeft c a) -> KeepLeft c a
$cstimes :: forall a c b. Integral b => b -> KeepLeft c a -> KeepLeft c a
stimes :: forall b. Integral b => b -> KeepLeft c a -> KeepLeft c a
Semigroup) via (First c)
  deriving ((forall a. Eq a => Eq (KeepLeft c a)) =>
(forall a b.
 (a -> b -> Bool) -> KeepLeft c a -> KeepLeft c b -> Bool)
-> Eq1 (KeepLeft c)
forall a. Eq a => Eq (KeepLeft c a)
forall c a. (Eq c, Eq a) => Eq (KeepLeft c a)
forall c a b.
Eq c =>
(a -> b -> Bool) -> KeepLeft c a -> KeepLeft c b -> Bool
forall a b.
(a -> b -> Bool) -> KeepLeft c a -> KeepLeft c b -> Bool
forall (f :: * -> *).
(forall a. Eq a => Eq (f a)) =>
(forall a b. (a -> b -> Bool) -> f a -> f b -> Bool) -> Eq1 f
$cliftEq :: forall c a b.
Eq c =>
(a -> b -> Bool) -> KeepLeft c a -> KeepLeft c b -> Bool
liftEq :: forall a b.
(a -> b -> Bool) -> KeepLeft c a -> KeepLeft c b -> Bool
Eq1, Eq1 (KeepLeft c)
(Eq1 (KeepLeft c), forall a. Ord a => Ord (KeepLeft c a)) =>
(forall a b.
 (a -> b -> Ordering) -> KeepLeft c a -> KeepLeft c b -> Ordering)
-> Ord1 (KeepLeft c)
forall a. Ord a => Ord (KeepLeft c a)
forall c. Ord c => Eq1 (KeepLeft c)
forall c a. (Ord c, Ord a) => Ord (KeepLeft c a)
forall c a b.
Ord c =>
(a -> b -> Ordering) -> KeepLeft c a -> KeepLeft c b -> Ordering
forall a b.
(a -> b -> Ordering) -> KeepLeft c a -> KeepLeft c b -> Ordering
forall (f :: * -> *).
(Eq1 f, forall a. Ord a => Ord (f a)) =>
(forall a b. (a -> b -> Ordering) -> f a -> f b -> Ordering)
-> Ord1 f
$cliftCompare :: forall c a b.
Ord c =>
(a -> b -> Ordering) -> KeepLeft c a -> KeepLeft c b -> Ordering
liftCompare :: forall a b.
(a -> b -> Ordering) -> KeepLeft c a -> KeepLeft c b -> Ordering
Ord1, Functor (KeepLeft c)
Functor (KeepLeft c) =>
(forall a b. KeepLeft c (a -> b) -> KeepLeft c a -> KeepLeft c b)
-> (forall a b. KeepLeft c a -> KeepLeft c b -> KeepLeft c b)
-> (forall a b. KeepLeft c a -> KeepLeft c b -> KeepLeft c a)
-> (forall a b c.
    (a -> b -> c) -> KeepLeft c a -> KeepLeft c b -> KeepLeft c c)
-> Apply (KeepLeft c)
forall c. Functor (KeepLeft c)
forall a b. KeepLeft c a -> KeepLeft c b -> KeepLeft c a
forall a b. KeepLeft c a -> KeepLeft c b -> KeepLeft c b
forall a b. KeepLeft c (a -> b) -> KeepLeft c a -> KeepLeft c b
forall c a b. KeepLeft c a -> KeepLeft c b -> KeepLeft c a
forall c a b. KeepLeft c a -> KeepLeft c b -> KeepLeft c b
forall c a b. KeepLeft c (a -> b) -> KeepLeft c a -> KeepLeft c b
forall a b c.
(a -> b -> c) -> KeepLeft c a -> KeepLeft c b -> KeepLeft c c
forall c a b c.
(a -> b -> c) -> KeepLeft c a -> KeepLeft c b -> KeepLeft c c
forall (f :: * -> *).
Functor f =>
(forall a b. f (a -> b) -> f a -> f b)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> Apply f
$c<.> :: forall c a b. KeepLeft c (a -> b) -> KeepLeft c a -> KeepLeft c b
<.> :: forall a b. KeepLeft c (a -> b) -> KeepLeft c a -> KeepLeft c b
$c.> :: forall c a b. KeepLeft c a -> KeepLeft c b -> KeepLeft c b
.> :: forall a b. KeepLeft c a -> KeepLeft c b -> KeepLeft c b
$c<. :: forall c a b. KeepLeft c a -> KeepLeft c b -> KeepLeft c a
<. :: forall a b. KeepLeft c a -> KeepLeft c b -> KeepLeft c a
$cliftF2 :: forall c a b c.
(a -> b -> c) -> KeepLeft c a -> KeepLeft c b -> KeepLeft c c
liftF2 :: forall a b c.
(a -> b -> c) -> KeepLeft c a -> KeepLeft c b -> KeepLeft c c
Apply) via (Const (First c))
  deriving ((forall c. Eq c => Eq1 (KeepLeft c)) =>
(forall a b c d.
 (a -> b -> Bool)
 -> (c -> d -> Bool) -> KeepLeft a c -> KeepLeft b d -> Bool)
-> Eq2 KeepLeft
forall c. Eq c => Eq1 (KeepLeft c)
forall a b c d.
(a -> b -> Bool)
-> (c -> d -> Bool) -> KeepLeft a c -> KeepLeft b d -> Bool
forall (f :: * -> * -> *).
(forall a. Eq a => Eq1 (f a)) =>
(forall a b c d.
 (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool)
-> Eq2 f
$cliftEq2 :: forall a b c d.
(a -> b -> Bool)
-> (c -> d -> Bool) -> KeepLeft a c -> KeepLeft b d -> Bool
liftEq2 :: forall a b c d.
(a -> b -> Bool)
-> (c -> d -> Bool) -> KeepLeft a c -> KeepLeft b d -> Bool
Eq2, Eq2 KeepLeft
(Eq2 KeepLeft, forall c. Ord c => Ord1 (KeepLeft c)) =>
(forall a b c d.
 (a -> b -> Ordering)
 -> (c -> d -> Ordering)
 -> KeepLeft a c
 -> KeepLeft b d
 -> Ordering)
-> Ord2 KeepLeft
forall c. Ord c => Ord1 (KeepLeft c)
forall a b c d.
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> KeepLeft a c -> KeepLeft b d -> Ordering
forall (f :: * -> * -> *).
(Eq2 f, forall a. Ord a => Ord1 (f a)) =>
(forall a b c d.
 (a -> b -> Ordering)
 -> (c -> d -> Ordering) -> f a c -> f b d -> Ordering)
-> Ord2 f
$cliftCompare2 :: forall a b c d.
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> KeepLeft a c -> KeepLeft b d -> Ordering
liftCompare2 :: forall a b c d.
(a -> b -> Ordering)
-> (c -> d -> Ordering) -> KeepLeft a c -> KeepLeft b d -> Ordering
Ord2, (forall c. Functor (KeepLeft c)) =>
(forall a b c d.
 (a -> b) -> (c -> d) -> KeepLeft a c -> KeepLeft b d)
-> (forall a b c. (a -> b) -> KeepLeft a c -> KeepLeft b c)
-> (forall b c a. (b -> c) -> KeepLeft a b -> KeepLeft a c)
-> Bifunctor KeepLeft
forall c. Functor (KeepLeft c)
forall a b c. (a -> b) -> KeepLeft a c -> KeepLeft b c
forall b c a. (b -> c) -> KeepLeft a b -> KeepLeft a c
forall a b c d.
(a -> b) -> (c -> d) -> KeepLeft a c -> KeepLeft b d
forall (p :: * -> * -> *).
(forall a. Functor (p a)) =>
(forall a b c d. (a -> b) -> (c -> d) -> p a c -> p b d)
-> (forall a b c. (a -> b) -> p a c -> p b c)
-> (forall b c a. (b -> c) -> p a b -> p a c)
-> Bifunctor p
$cbimap :: forall a b c d.
(a -> b) -> (c -> d) -> KeepLeft a c -> KeepLeft b d
bimap :: forall a b c d.
(a -> b) -> (c -> d) -> KeepLeft a c -> KeepLeft b d
$cfirst :: forall a b c. (a -> b) -> KeepLeft a c -> KeepLeft b c
first :: forall a b c. (a -> b) -> KeepLeft a c -> KeepLeft b c
$csecond :: forall b c a. (b -> c) -> KeepLeft a b -> KeepLeft a c
second :: forall b c a. (b -> c) -> KeepLeft a b -> KeepLeft a c
Bifunctor, (forall m. Monoid m => KeepLeft m m -> m)
-> (forall m a b.
    Monoid m =>
    (a -> m) -> (b -> m) -> KeepLeft a b -> m)
-> (forall a c b.
    (a -> c -> c) -> (b -> c -> c) -> c -> KeepLeft a b -> c)
-> (forall c a b.
    (c -> a -> c) -> (c -> b -> c) -> c -> KeepLeft a b -> c)
-> Bifoldable KeepLeft
forall m. Monoid m => KeepLeft m m -> m
forall m a b. Monoid m => (a -> m) -> (b -> m) -> KeepLeft a b -> m
forall c a b.
(c -> a -> c) -> (c -> b -> c) -> c -> KeepLeft a b -> c
forall a c b.
(a -> c -> c) -> (b -> c -> c) -> c -> KeepLeft a b -> c
forall (p :: * -> * -> *).
(forall m. Monoid m => p m m -> m)
-> (forall m a b. Monoid m => (a -> m) -> (b -> m) -> p a b -> m)
-> (forall a c b.
    (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c)
-> (forall c a b.
    (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c)
-> Bifoldable p
$cbifold :: forall m. Monoid m => KeepLeft m m -> m
bifold :: forall m. Monoid m => KeepLeft m m -> m
$cbifoldMap :: forall m a b. Monoid m => (a -> m) -> (b -> m) -> KeepLeft a b -> m
bifoldMap :: forall m a b. Monoid m => (a -> m) -> (b -> m) -> KeepLeft a b -> m
$cbifoldr :: forall a c b.
(a -> c -> c) -> (b -> c -> c) -> c -> KeepLeft a b -> c
bifoldr :: forall a c b.
(a -> c -> c) -> (b -> c -> c) -> c -> KeepLeft a b -> c
$cbifoldl :: forall c a b.
(c -> a -> c) -> (c -> b -> c) -> c -> KeepLeft a b -> c
bifoldl :: forall c a b.
(c -> a -> c) -> (c -> b -> c) -> c -> KeepLeft a b -> c
Bifoldable, Bifoldable KeepLeft
Bifoldable KeepLeft =>
(forall m. Semigroup m => KeepLeft m m -> m)
-> (forall m a b.
    Semigroup m =>
    (a -> m) -> (b -> m) -> KeepLeft a b -> m)
-> Bifoldable1 KeepLeft
forall m. Semigroup m => KeepLeft m m -> m
forall m a b.
Semigroup m =>
(a -> m) -> (b -> m) -> KeepLeft a b -> m
forall (t :: * -> * -> *).
Bifoldable t =>
(forall m. Semigroup m => t m m -> m)
-> (forall m a b.
    Semigroup m =>
    (a -> m) -> (b -> m) -> t a b -> m)
-> Bifoldable1 t
$cbifold1 :: forall m. Semigroup m => KeepLeft m m -> m
bifold1 :: forall m. Semigroup m => KeepLeft m m -> m
$cbifoldMap1 :: forall m a b.
Semigroup m =>
(a -> m) -> (b -> m) -> KeepLeft a b -> m
bifoldMap1 :: forall m a b.
Semigroup m =>
(a -> m) -> (b -> m) -> KeepLeft a b -> m
Bifoldable1) via Const

instance Bitraversable KeepLeft where
  bitraverse :: forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c) -> (b -> f d) -> KeepLeft a b -> f (KeepLeft c d)
bitraverse a -> f c
f b -> f d
_ (KeepLeft a
c) = c -> KeepLeft c d
forall c a. c -> KeepLeft c a
KeepLeft (c -> KeepLeft c d) -> f c -> f (KeepLeft c d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f c
f a
c

instance Bitraversable1 KeepLeft where
  bitraverse1 :: forall (f :: * -> *) a b c d.
Apply f =>
(a -> f b) -> (c -> f d) -> KeepLeft a c -> f (KeepLeft b d)
bitraverse1 a -> f b
f c -> f d
_ (KeepLeft a
c) = b -> KeepLeft b d
forall c a. c -> KeepLeft c a
KeepLeft (b -> KeepLeft b d) -> f b -> f (KeepLeft b d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
c

instance Bind (KeepLeft c) where
  KeepLeft c
c >>- :: forall a b. KeepLeft c a -> (a -> KeepLeft c b) -> KeepLeft c b
>>- a -> KeepLeft c b
_ = c -> KeepLeft c b
forall c a. c -> KeepLeft c a
KeepLeft c
c

instance Isolated (KeepLeft c) where
  impureBind :: forall a b.
KeepLeft c a -> (a -> Unite (KeepLeft c) b) -> Unite (KeepLeft c) b
impureBind = KeepLeft c a -> (a -> Unite (KeepLeft c) b) -> Unite (KeepLeft c) b
forall (m0 :: * -> *) a b.
MonadIdeal m0 =>
m0 a -> (a -> Unite m0 b) -> Unite m0 b
impureBindDefault

-- | @Ideal (KeepLeft c) a ~ Either c a@
instance MonadIdeal (KeepLeft c) where
  idealBind :: forall a b.
KeepLeft c a -> (a -> Ideal (KeepLeft c) b) -> KeepLeft c b
idealBind (KeepLeft c
c) a -> Ideal (KeepLeft c) b
_ = c -> KeepLeft c b
forall c a. c -> KeepLeft c a
KeepLeft c
c