{-# LANGUAGE EmptyCase, StandaloneDeriving, TupleSections #-}
{-# LANGUAGE UndecidableSuperClasses                      #-}
{-# OPTIONS_GHC -Wno-orphans #-}
module Control.Subcategory.Applicative
  ( CApplicative(..), defaultRightApply, defaultLeftApply, CApp(..)
  ) where
import Control.Subcategory.Alternative.Class
import Control.Subcategory.Applicative.Class
import Control.Subcategory.Functor
import Control.Subcategory.Pointed

import qualified Control.Applicative             as App
import qualified Control.Monad.ST.Lazy           as LST
import qualified Control.Monad.ST.Strict         as SST
import           Data.Coerce                     (coerce)
import           Data.Functor.Const              (Const)
import           Data.Functor.Identity           (Identity)
import qualified Data.Functor.Product            as SOP
import           Data.Hashable                   (Hashable)
import qualified Data.HashMap.Strict             as HM
import qualified Data.HashSet                    as HS
import qualified Data.IntMap                     as IM
import           Data.List.NonEmpty              (NonEmpty)
import qualified Data.Map                        as Map
import qualified Data.Primitive.Array            as A
import qualified Data.Primitive.SmallArray       as SA
import qualified Data.Semigroup                  as Sem
import qualified Data.Sequence                   as Seq
import qualified Data.Set                        as Set
import qualified Data.Tree                       as Tree
import qualified Data.Vector                     as V
import           GHC.Conc                        (STM)
import           Text.ParserCombinators.ReadP    (ReadP)
import           Text.ParserCombinators.ReadPrec (ReadPrec)

defaultLeftApply :: (Dom f (b1, b2), Dom f b1, Dom f b2, CApplicative f)
                 => f b1 -> f b2 -> f b1
defaultLeftApply :: f b1 -> f b2 -> f b1
defaultLeftApply f b1
a f b2
b = (b1 -> b2 -> b1) -> (b1, b2) -> b1
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry b1 -> b2 -> b1
forall a b. a -> b -> a
const ((b1, b2) -> b1) -> f (b1, b2) -> f b1
forall (f :: * -> *) a b.
(CFunctor f, Dom f a, Dom f b) =>
(a -> b) -> f a -> f b
<$:> f b1 -> f b2 -> f (b1, b2)
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b, Dom f (a, b)) =>
f a -> f b -> f (a, b)
pair f b1
a f b2
b
defaultRightApply :: (Dom f (b1, b2), Dom f b2, Dom f b1, CApplicative f)
                  => f b1 -> f b2 -> f b2
defaultRightApply :: f b1 -> f b2 -> f b2
defaultRightApply f b1
a f b2
b = (b1 -> b2 -> b2) -> (b1, b2) -> b2
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((b2 -> b2) -> b1 -> b2 -> b2
forall a b. a -> b -> a
const b2 -> b2
forall a. a -> a
id) ((b1, b2) -> b2) -> f (b1, b2) -> f b2
forall (f :: * -> *) a b.
(CFunctor f, Dom f a, Dom f b) =>
(a -> b) -> f a -> f b
<$:> f b1 -> f b2 -> f (b1, b2)
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b, Dom f (a, b)) =>
f a -> f b -> f (a, b)
pair f b1
a f b2
b

instance Semigroup w => CApplicative (Const w) where
  pair :: Const w a -> Const w b -> Const w (a, b)
pair = (w -> w -> w) -> Const w a -> Const w b -> Const w (a, b)
coerce @(w -> w -> w) w -> w -> w
forall a. Semigroup a => a -> a -> a
(<>)
  <.> :: Const w (a -> b) -> Const w a -> Const w b
(<.>) = (w -> w -> w) -> Const w (a -> b) -> Const w a -> Const w b
coerce @(w -> w -> w) w -> w -> w
forall a. Semigroup a => a -> a -> a
(<>)
  {-# INLINE (<.>) #-}
  (<. ) = (w -> w -> w) -> Const w a -> Const w b -> Const w a
coerce @(w -> w -> w) w -> w -> w
forall a. Semigroup a => a -> a -> a
(<>)
  {-# INLINE (<. ) #-}
  ( .>) = (w -> w -> w) -> Const w a -> Const w b -> Const w b
coerce @(w -> w -> w) w -> w -> w
forall a. Semigroup a => a -> a -> a
(<>)
  {-# INLINE ( .>) #-}

instance CApplicative []
instance CApplicative IO
instance CApplicative STM
instance CApplicative ReadP
instance CApplicative V.Vector
instance CApplicative SA.SmallArray
instance CApplicative A.Array
instance CApplicative ReadPrec
instance CApplicative (SST.ST s)
instance CApplicative (LST.ST s)
instance CApplicative App.ZipList
instance CApplicative Maybe
instance CApplicative Identity
instance CApplicative Tree.Tree
instance CApplicative Seq.Seq
instance CApplicative Sem.Option
instance CApplicative NonEmpty
instance CApplicative ((->) a)
instance CApplicative (Either a)
instance (CApplicative f, CApplicative g)
      => CApplicative (SOP.Product f g) where
  pair :: Product f g a -> Product f g b -> Product f g (a, b)
pair (SOP.Pair f a
a g a
b) (SOP.Pair f b
c g b
d) = f (a, b) -> g (a, b) -> Product f g (a, b)
forall k (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
SOP.Pair (f a -> f b -> f (a, b)
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b, Dom f (a, b)) =>
f a -> f b -> f (a, b)
pair f a
a f b
c) (g a -> g b -> g (a, b)
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b, Dom f (a, b)) =>
f a -> f b -> f (a, b)
pair g a
b g b
d)
  SOP.Pair f (a -> b)
f g (a -> b)
g <.> :: Product f g (a -> b) -> Product f g a -> Product f g b
<.> SOP.Pair f a
a g a
b = f b -> g b -> Product f g b
forall k (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
SOP.Pair (f (a -> b)
f f (a -> b) -> f a -> f b
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b, Dom f (a -> b)) =>
f (a -> b) -> f a -> f b
<.> f a
a) (g (a -> b)
g g (a -> b) -> g a -> g b
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b, Dom f (a -> b)) =>
f (a -> b) -> f a -> f b
<.> g a
b)
  {-# INLINE (<.>) #-}
  SOP.Pair f a
f g a
g <. :: Product f g a -> Product f g b -> Product f g a
<. SOP.Pair f b
a g b
b = f a -> g a -> Product f g a
forall k (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
SOP.Pair (f a
f f a -> f b -> f a
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b) =>
f a -> f b -> f a
<. f b
a) (g a
g g a -> g b -> g a
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b) =>
f a -> f b -> f a
<. g b
b)
  {-# INLINE (<.) #-}
  SOP.Pair f a
f g a
g .> :: Product f g a -> Product f g b -> Product f g b
.> SOP.Pair f b
a g b
b = f b -> g b -> Product f g b
forall k (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
SOP.Pair (f a
f f a -> f b -> f b
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b) =>
f a -> f b -> f b
.> f b
a) (g a
g g a -> g b -> g b
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b) =>
f a -> f b -> f b
.> g b
b)
  {-# INLINE (.>) #-}

class Dom f (g a -> g b) => DomOver f g a b
instance Dom f (g a -> g b) => DomOver f g a b

instance Applicative f => CApplicative (WrapFunctor f)
instance Semigroup w => CApplicative ((,) w) where
  pair :: (w, a) -> (w, b) -> (w, (a, b))
pair (w
w, a
a) (w
u, b
b) = (w
w w -> w -> w
forall a. Semigroup a => a -> a -> a
<> w
u, (a
a, b
b))
  {-# INLINE pair #-}
  (w
w, a -> b
f) <.> :: (w, a -> b) -> (w, a) -> (w, b)
<.> (w
u, a
a) = (w
w w -> w -> w
forall a. Semigroup a => a -> a -> a
<> w
u, a -> b
f a
a)
  {-# INLINE (<.>) #-}
  (w
w, a
a) <. :: (w, a) -> (w, b) -> (w, a)
<.  (w
u, b
_) = (w
w w -> w -> w
forall a. Semigroup a => a -> a -> a
<> w
u, a
a)
  {-# INLINE (<.) #-}
  (w
w, a
_)  .> :: (w, a) -> (w, b) -> (w, b)
.> (w
u, b
b) = (w
w w -> w -> w
forall a. Semigroup a => a -> a -> a
<> w
u, b
b)
  {-# INLINE (.>) #-}
instance CApplicative IM.IntMap where
  pair :: IntMap a -> IntMap b -> IntMap (a, b)
pair = (a -> b -> (a, b)) -> IntMap a -> IntMap b -> IntMap (a, b)
forall a b c. (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
IM.intersectionWith (,)
  {-# INLINE pair #-}
  <.> :: IntMap (a -> b) -> IntMap a -> IntMap b
(<.>) = ((a -> b) -> a -> b) -> IntMap (a -> b) -> IntMap a -> IntMap b
forall a b c. (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
IM.intersectionWith (a -> b) -> a -> b
forall a. a -> a
id
  {-# INLINE (<.>) #-}
  <. :: IntMap a -> IntMap b -> IntMap a
(<.)  = (a -> b -> a) -> IntMap a -> IntMap b -> IntMap a
forall a b c. (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
IM.intersectionWith a -> b -> a
forall a b. a -> b -> a
const
  {-# INLINE (<.) #-}
  .> :: IntMap a -> IntMap b -> IntMap b
(.>)  = (a -> b -> b) -> IntMap a -> IntMap b -> IntMap b
forall a b c. (a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
IM.intersectionWith ((a -> b -> b) -> IntMap a -> IntMap b -> IntMap b)
-> (a -> b -> b) -> IntMap a -> IntMap b -> IntMap b
forall a b. (a -> b) -> a -> b
$ (b -> b) -> a -> b -> b
forall a b. a -> b -> a
const b -> b
forall a. a -> a
id
  {-# INLINE (.>) #-}

instance Ord k => CApplicative (Map.Map k) where
  pair :: Map k a -> Map k b -> Map k (a, b)
pair = (a -> b -> (a, b)) -> Map k a -> Map k b -> Map k (a, b)
forall k a b c.
Ord k =>
(a -> b -> c) -> Map k a -> Map k b -> Map k c
Map.intersectionWith (,)
  {-# INLINE pair #-}
  <.> :: Map k (a -> b) -> Map k a -> Map k b
(<.>) = ((a -> b) -> a -> b) -> Map k (a -> b) -> Map k a -> Map k b
forall k a b c.
Ord k =>
(a -> b -> c) -> Map k a -> Map k b -> Map k c
Map.intersectionWith (a -> b) -> a -> b
forall a. a -> a
id
  {-# INLINE (<.>) #-}
  <. :: Map k a -> Map k b -> Map k a
(<.)  = (a -> b -> a) -> Map k a -> Map k b -> Map k a
forall k a b c.
Ord k =>
(a -> b -> c) -> Map k a -> Map k b -> Map k c
Map.intersectionWith a -> b -> a
forall a b. a -> b -> a
const
  {-# INLINE (<.) #-}
  .> :: Map k a -> Map k b -> Map k b
(.>)  = (a -> b -> b) -> Map k a -> Map k b -> Map k b
forall k a b c.
Ord k =>
(a -> b -> c) -> Map k a -> Map k b -> Map k c
Map.intersectionWith ((a -> b -> b) -> Map k a -> Map k b -> Map k b)
-> (a -> b -> b) -> Map k a -> Map k b -> Map k b
forall a b. (a -> b) -> a -> b
$ (b -> b) -> a -> b -> b
forall a b. a -> b -> a
const b -> b
forall a. a -> a
id
  {-# INLINE (.>) #-}

instance (Eq k, Hashable k) => CApplicative (HM.HashMap k) where
  pair :: HashMap k a -> HashMap k b -> HashMap k (a, b)
pair = (a -> b -> (a, b))
-> HashMap k a -> HashMap k b -> HashMap k (a, b)
forall k v1 v2 v3.
(Eq k, Hashable k) =>
(v1 -> v2 -> v3) -> HashMap k v1 -> HashMap k v2 -> HashMap k v3
HM.intersectionWith (,)
  {-# INLINE pair #-}
  <.> :: HashMap k (a -> b) -> HashMap k a -> HashMap k b
(<.>) = ((a -> b) -> a -> b)
-> HashMap k (a -> b) -> HashMap k a -> HashMap k b
forall k v1 v2 v3.
(Eq k, Hashable k) =>
(v1 -> v2 -> v3) -> HashMap k v1 -> HashMap k v2 -> HashMap k v3
HM.intersectionWith (a -> b) -> a -> b
forall a. a -> a
id
  {-# INLINE (<.>) #-}
  <. :: HashMap k a -> HashMap k b -> HashMap k a
(<.)  = (a -> b -> a) -> HashMap k a -> HashMap k b -> HashMap k a
forall k v1 v2 v3.
(Eq k, Hashable k) =>
(v1 -> v2 -> v3) -> HashMap k v1 -> HashMap k v2 -> HashMap k v3
HM.intersectionWith a -> b -> a
forall a b. a -> b -> a
const
  {-# INLINE (<.) #-}
  .> :: HashMap k a -> HashMap k b -> HashMap k b
(.>)  = (a -> b -> b) -> HashMap k a -> HashMap k b -> HashMap k b
forall k v1 v2 v3.
(Eq k, Hashable k) =>
(v1 -> v2 -> v3) -> HashMap k v1 -> HashMap k v2 -> HashMap k v3
HM.intersectionWith ((a -> b -> b) -> HashMap k a -> HashMap k b -> HashMap k b)
-> (a -> b -> b) -> HashMap k a -> HashMap k b -> HashMap k b
forall a b. (a -> b) -> a -> b
$ (b -> b) -> a -> b -> b
forall a b. a -> b -> a
const b -> b
forall a. a -> a
id
  {-# INLINE (.>) #-}

instance CApplicative Set.Set where
  pair :: Set a -> Set b -> Set (a, b)
pair Set a
as Set b
bs = (b -> Set (a, b)) -> Set b -> Set (a, b)
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (\b
b -> (a -> (a, b)) -> Set a -> Set (a, b)
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map (,b
b) Set a
as) Set b
bs
  {-# INLINE pair #-}
  Set (a -> b)
fs <.> :: Set (a -> b) -> Set a -> Set b
<.> Set a
as = ((a -> b) -> Set b) -> Set (a -> b) -> Set b
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (\a -> b
f -> (a -> b) -> Set a -> Set b
forall b a. Ord b => (a -> b) -> Set a -> Set b
Set.map a -> b
f Set a
as) Set (a -> b)
fs
  {-# INLINE (<.>) #-}
  Set a
a <. :: Set a -> Set b -> Set a
<. Set b
b | Set b -> Bool
forall a. Set a -> Bool
Set.null Set b
b = Set a
forall a. Set a
Set.empty
         | Bool
otherwise  = Set a
a
  {-# INLINE (<.) #-}
  Set a
a .> :: Set a -> Set b -> Set b
.> Set b
b | Set a -> Bool
forall a. Set a -> Bool
Set.null Set a
a = Set b
forall a. Set a
Set.empty
         | Bool
otherwise  = Set b
b
  {-# INLINE (.>) #-}

instance CApplicative HS.HashSet where
  pair :: HashSet a -> HashSet b -> HashSet (a, b)
pair HashSet a
as HashSet b
bs = (b -> HashSet (a, b)) -> HashSet b -> HashSet (a, b)
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (\b
b -> (a -> (a, b)) -> HashSet a -> HashSet (a, b)
forall b a.
(Hashable b, Eq b) =>
(a -> b) -> HashSet a -> HashSet b
HS.map (,b
b) HashSet a
as) HashSet b
bs
  {-# INLINE pair #-}
  HashSet (a -> b)
fs <.> :: HashSet (a -> b) -> HashSet a -> HashSet b
<.> HashSet a
as = ((a -> b) -> HashSet b) -> HashSet (a -> b) -> HashSet b
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (\a -> b
f -> (a -> b) -> HashSet a -> HashSet b
forall b a.
(Hashable b, Eq b) =>
(a -> b) -> HashSet a -> HashSet b
HS.map a -> b
f HashSet a
as) HashSet (a -> b)
fs
  {-# INLINE (<.>) #-}
  HashSet a
a <. :: HashSet a -> HashSet b -> HashSet a
<. HashSet b
b | HashSet b -> Bool
forall a. HashSet a -> Bool
HS.null HashSet b
b = HashSet a
forall a. HashSet a
HS.empty
         | Bool
otherwise  = HashSet a
a
  {-# INLINE (<.) #-}
  HashSet a
a .> :: HashSet a -> HashSet b -> HashSet b
.> HashSet b
b | HashSet a -> Bool
forall a. HashSet a -> Bool
HS.null HashSet a
a = HashSet b
forall a. HashSet a
HS.empty
         | Bool
otherwise  = HashSet b
b
  {-# INLINE (.>) #-}

instance Constrained f => Constrained (CApp f) where
  type Dom (CApp f) a = Dom f a

newtype CApp f a = CApp { CApp f a -> f a
runCApp :: f a }
  deriving (ReadPrec [CApp f a]
ReadPrec (CApp f a)
Int -> ReadS (CApp f a)
ReadS [CApp f a]
(Int -> ReadS (CApp f a))
-> ReadS [CApp f a]
-> ReadPrec (CApp f a)
-> ReadPrec [CApp f a]
-> Read (CApp f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k (f :: k -> *) (a :: k). Read (f a) => ReadPrec [CApp f a]
forall k (f :: k -> *) (a :: k). Read (f a) => ReadPrec (CApp f a)
forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (CApp f a)
forall k (f :: k -> *) (a :: k). Read (f a) => ReadS [CApp f a]
readListPrec :: ReadPrec [CApp f a]
$creadListPrec :: forall k (f :: k -> *) (a :: k). Read (f a) => ReadPrec [CApp f a]
readPrec :: ReadPrec (CApp f a)
$creadPrec :: forall k (f :: k -> *) (a :: k). Read (f a) => ReadPrec (CApp f a)
readList :: ReadS [CApp f a]
$creadList :: forall k (f :: k -> *) (a :: k). Read (f a) => ReadS [CApp f a]
readsPrec :: Int -> ReadS (CApp f a)
$creadsPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (CApp f a)
Read, Int -> CApp f a -> ShowS
[CApp f a] -> ShowS
CApp f a -> String
(Int -> CApp f a -> ShowS)
-> (CApp f a -> String) -> ([CApp f a] -> ShowS) -> Show (CApp f a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> CApp f a -> ShowS
forall k (f :: k -> *) (a :: k). Show (f a) => [CApp f a] -> ShowS
forall k (f :: k -> *) (a :: k). Show (f a) => CApp f a -> String
showList :: [CApp f a] -> ShowS
$cshowList :: forall k (f :: k -> *) (a :: k). Show (f a) => [CApp f a] -> ShowS
show :: CApp f a -> String
$cshow :: forall k (f :: k -> *) (a :: k). Show (f a) => CApp f a -> String
showsPrec :: Int -> CApp f a -> ShowS
$cshowsPrec :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> CApp f a -> ShowS
Show, CApp f a -> CApp f a -> Bool
(CApp f a -> CApp f a -> Bool)
-> (CApp f a -> CApp f a -> Bool) -> Eq (CApp f a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (f :: k -> *) (a :: k).
Eq (f a) =>
CApp f a -> CApp f a -> Bool
/= :: CApp f a -> CApp f a -> Bool
$c/= :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
CApp f a -> CApp f a -> Bool
== :: CApp f a -> CApp f a -> Bool
$c== :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
CApp f a -> CApp f a -> Bool
Eq, Eq (CApp f a)
Eq (CApp f a)
-> (CApp f a -> CApp f a -> Ordering)
-> (CApp f a -> CApp f a -> Bool)
-> (CApp f a -> CApp f a -> Bool)
-> (CApp f a -> CApp f a -> Bool)
-> (CApp f a -> CApp f a -> Bool)
-> (CApp f a -> CApp f a -> CApp f a)
-> (CApp f a -> CApp f a -> CApp f a)
-> Ord (CApp f a)
CApp f a -> CApp f a -> Bool
CApp f a -> CApp f a -> Ordering
CApp f a -> CApp f a -> CApp f 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 k (f :: k -> *) (a :: k). Ord (f a) => Eq (CApp f a)
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
CApp f a -> CApp f a -> Bool
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
CApp f a -> CApp f a -> Ordering
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
CApp f a -> CApp f a -> CApp f a
min :: CApp f a -> CApp f a -> CApp f a
$cmin :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
CApp f a -> CApp f a -> CApp f a
max :: CApp f a -> CApp f a -> CApp f a
$cmax :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
CApp f a -> CApp f a -> CApp f a
>= :: CApp f a -> CApp f a -> Bool
$c>= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
CApp f a -> CApp f a -> Bool
> :: CApp f a -> CApp f a -> Bool
$c> :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
CApp f a -> CApp f a -> Bool
<= :: CApp f a -> CApp f a -> Bool
$c<= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
CApp f a -> CApp f a -> Bool
< :: CApp f a -> CApp f a -> Bool
$c< :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
CApp f a -> CApp f a -> Bool
compare :: CApp f a -> CApp f a -> Ordering
$ccompare :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
CApp f a -> CApp f a -> Ordering
$cp1Ord :: forall k (f :: k -> *) (a :: k). Ord (f a) => Eq (CApp f a)
Ord)
  deriving newtype (a -> CApp f b -> CApp f a
(a -> b) -> CApp f a -> CApp f b
(forall a b. (a -> b) -> CApp f a -> CApp f b)
-> (forall a b. a -> CApp f b -> CApp f a) -> Functor (CApp f)
forall a b. a -> CApp f b -> CApp f a
forall a b. (a -> b) -> CApp f a -> CApp f b
forall (f :: * -> *) a b. Functor f => a -> CApp f b -> CApp f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> CApp f a -> CApp f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> CApp f b -> CApp f a
$c<$ :: forall (f :: * -> *) a b. Functor f => a -> CApp f b -> CApp f a
fmap :: (a -> b) -> CApp f a -> CApp f b
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> CApp f a -> CApp f b
Functor, Functor (CApp f)
a -> CApp f a
Functor (CApp f)
-> (forall a. a -> CApp f a)
-> (forall a b. CApp f (a -> b) -> CApp f a -> CApp f b)
-> (forall a b c.
    (a -> b -> c) -> CApp f a -> CApp f b -> CApp f c)
-> (forall a b. CApp f a -> CApp f b -> CApp f b)
-> (forall a b. CApp f a -> CApp f b -> CApp f a)
-> Applicative (CApp f)
CApp f a -> CApp f b -> CApp f b
CApp f a -> CApp f b -> CApp f a
CApp f (a -> b) -> CApp f a -> CApp f b
(a -> b -> c) -> CApp f a -> CApp f b -> CApp f c
forall a. a -> CApp f a
forall a b. CApp f a -> CApp f b -> CApp f a
forall a b. CApp f a -> CApp f b -> CApp f b
forall a b. CApp f (a -> b) -> CApp f a -> CApp f b
forall a b c. (a -> b -> c) -> CApp f a -> CApp f b -> CApp f c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (f :: * -> *). Applicative f => Functor (CApp f)
forall (f :: * -> *) a. Applicative f => a -> CApp f a
forall (f :: * -> *) a b.
Applicative f =>
CApp f a -> CApp f b -> CApp f a
forall (f :: * -> *) a b.
Applicative f =>
CApp f a -> CApp f b -> CApp f b
forall (f :: * -> *) a b.
Applicative f =>
CApp f (a -> b) -> CApp f a -> CApp f b
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> CApp f a -> CApp f b -> CApp f c
<* :: CApp f a -> CApp f b -> CApp f a
$c<* :: forall (f :: * -> *) a b.
Applicative f =>
CApp f a -> CApp f b -> CApp f a
*> :: CApp f a -> CApp f b -> CApp f b
$c*> :: forall (f :: * -> *) a b.
Applicative f =>
CApp f a -> CApp f b -> CApp f b
liftA2 :: (a -> b -> c) -> CApp f a -> CApp f b -> CApp f c
$cliftA2 :: forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> CApp f a -> CApp f b -> CApp f c
<*> :: CApp f (a -> b) -> CApp f a -> CApp f b
$c<*> :: forall (f :: * -> *) a b.
Applicative f =>
CApp f (a -> b) -> CApp f a -> CApp f b
pure :: a -> CApp f a
$cpure :: forall (f :: * -> *) a. Applicative f => a -> CApp f a
$cp1Applicative :: forall (f :: * -> *). Applicative f => Functor (CApp f)
Applicative, Applicative (CApp f)
CApp f a
Applicative (CApp f)
-> (forall a. CApp f a)
-> (forall a. CApp f a -> CApp f a -> CApp f a)
-> (forall a. CApp f a -> CApp f [a])
-> (forall a. CApp f a -> CApp f [a])
-> Alternative (CApp f)
CApp f a -> CApp f a -> CApp f a
CApp f a -> CApp f [a]
CApp f a -> CApp f [a]
forall a. CApp f a
forall a. CApp f a -> CApp f [a]
forall a. CApp f a -> CApp f a -> CApp f a
forall (f :: * -> *).
Applicative f
-> (forall a. f a)
-> (forall a. f a -> f a -> f a)
-> (forall a. f a -> f [a])
-> (forall a. f a -> f [a])
-> Alternative f
forall (f :: * -> *). Alternative f => Applicative (CApp f)
forall (f :: * -> *) a. Alternative f => CApp f a
forall (f :: * -> *) a. Alternative f => CApp f a -> CApp f [a]
forall (f :: * -> *) a.
Alternative f =>
CApp f a -> CApp f a -> CApp f a
many :: CApp f a -> CApp f [a]
$cmany :: forall (f :: * -> *) a. Alternative f => CApp f a -> CApp f [a]
some :: CApp f a -> CApp f [a]
$csome :: forall (f :: * -> *) a. Alternative f => CApp f a -> CApp f [a]
<|> :: CApp f a -> CApp f a -> CApp f a
$c<|> :: forall (f :: * -> *) a.
Alternative f =>
CApp f a -> CApp f a -> CApp f a
empty :: CApp f a
$cempty :: forall (f :: * -> *) a. Alternative f => CApp f a
$cp1Alternative :: forall (f :: * -> *). Alternative f => Applicative (CApp f)
App.Alternative)

deriving newtype instance (CFunctor f) => CFunctor (CApp f)
deriving newtype instance (CChoice f) => CChoice (CApp f)
deriving newtype instance (CAlternative f) => CAlternative (CApp f)
deriving newtype instance (CApplicative f) => CApplicative (CApp f)
deriving newtype instance (CPointed f) => CPointed (CApp f)

instance (Dom f a, CApplicative f, Semigroup a, Dom f (a, a))
       => Semigroup (CApp f a) where
  CApp f a
a <> :: CApp f a -> CApp f a -> CApp f a
<> CApp f a
b = f a -> CApp f a
forall k (f :: k -> *) (a :: k). f a -> CApp f a
CApp (f a -> CApp f a) -> f a -> CApp f a
forall a b. (a -> b) -> a -> b
$ (a -> a -> a) -> (a, a) -> a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> a -> a
forall a. Semigroup a => a -> a -> a
(<>) ((a, a) -> a) -> f (a, a) -> f a
forall (f :: * -> *) a b.
(CFunctor f, Dom f a, Dom f b) =>
(a -> b) -> f a -> f b
<$:> f a -> f a -> f (a, a)
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b, Dom f (a, b)) =>
f a -> f b -> f (a, b)
pair f a
a f a
b

instance (Dom f a, CPointed f, CApplicative f, Monoid a, Dom f (a, a))
       => Monoid (CApp f a) where
  CApp f a
a mappend :: CApp f a -> CApp f a -> CApp f a
`mappend` CApp f a
b = f a -> CApp f a
forall k (f :: k -> *) (a :: k). f a -> CApp f a
CApp (f a -> CApp f a) -> f a -> CApp f a
forall a b. (a -> b) -> a -> b
$ (a -> a -> a) -> (a, a) -> a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> a -> a
forall a. Monoid a => a -> a -> a
mappend ((a, a) -> a) -> f (a, a) -> f a
forall (f :: * -> *) a b.
(CFunctor f, Dom f a, Dom f b) =>
(a -> b) -> f a -> f b
<$:> f a -> f a -> f (a, a)
forall (f :: * -> *) a b.
(CApplicative f, Dom f a, Dom f b, Dom f (a, b)) =>
f a -> f b -> f (a, b)
pair f a
a f a
b
  mempty :: CApp f a
mempty = f a -> CApp f a
forall k (f :: k -> *) (a :: k). f a -> CApp f a
CApp (f a -> CApp f a) -> f a -> CApp f a
forall a b. (a -> b) -> a -> b
$ a -> f a
forall (f :: * -> *) a. (CPointed f, Dom f a) => a -> f a
cpure a
forall a. Monoid a => a
mempty