{-# LANGUAGE CPP, GADTs, InstanceSigs, KindSignatures, PatternSynonyms #-}
{-# LANGUAGE RankNTypes, RoleAnnotations, ScopedTypeVariables          #-}
{-# LANGUAGE StandaloneDeriving, TemplateHaskell, TypeApplications     #-}
{-# LANGUAGE TypeFamilies, TypeOperators, UndecidableSuperClasses      #-}
module Control.Subcategory.Wrapper.Internal where
import Control.Applicative
import Control.Monad.Fix    (MonadFix)
import Control.Monad.Zip    (MonadZip)
import Data.Coerce
import Data.Kind            (Type)
import Data.MonoTraversable
import Data.Pointed
import Data.Semialign       (Align, Unalign)
import Data.Zip             (Semialign, Unzip, Zip)
import GHC.Base             (MonadPlus)

newtype WrapFunctor f (a :: Type) = WrapFunctor {forall (f :: * -> *) a. WrapFunctor f a -> f a
runFunctor :: f a}
  deriving newtype (forall a b. a -> WrapFunctor f b -> WrapFunctor f a
forall a b. (a -> b) -> WrapFunctor f a -> WrapFunctor f b
forall (f :: * -> *) a b.
Functor f =>
a -> WrapFunctor f b -> WrapFunctor f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> WrapFunctor f a -> WrapFunctor f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> WrapFunctor f b -> WrapFunctor f a
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> WrapFunctor f b -> WrapFunctor f a
fmap :: forall a b. (a -> b) -> WrapFunctor f a -> WrapFunctor f b
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> WrapFunctor f a -> WrapFunctor f b
Functor, forall a. a -> WrapFunctor f a
forall a b. WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f a
forall a b. WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f b
forall a b.
WrapFunctor f (a -> b) -> WrapFunctor f a -> WrapFunctor f b
forall a b c.
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor 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 (WrapFunctor f)
forall (f :: * -> *) a. Applicative f => a -> WrapFunctor f a
forall (f :: * -> *) a b.
Applicative f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f a
forall (f :: * -> *) a b.
Applicative f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f b
forall (f :: * -> *) a b.
Applicative f =>
WrapFunctor f (a -> b) -> WrapFunctor f a -> WrapFunctor f b
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
<* :: forall a b. WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f a
$c<* :: forall (f :: * -> *) a b.
Applicative f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f a
*> :: forall a b. WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f b
$c*> :: forall (f :: * -> *) a b.
Applicative f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f b
liftA2 :: forall a b c.
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
$cliftA2 :: forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
<*> :: forall a b.
WrapFunctor f (a -> b) -> WrapFunctor f a -> WrapFunctor f b
$c<*> :: forall (f :: * -> *) a b.
Applicative f =>
WrapFunctor f (a -> b) -> WrapFunctor f a -> WrapFunctor f b
pure :: forall a. a -> WrapFunctor f a
$cpure :: forall (f :: * -> *) a. Applicative f => a -> WrapFunctor f a
Applicative, forall a. WrapFunctor f a
forall a. WrapFunctor f a -> WrapFunctor f [a]
forall a. WrapFunctor f a -> WrapFunctor f a -> WrapFunctor 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 (WrapFunctor f)
forall (f :: * -> *) a. Alternative f => WrapFunctor f a
forall (f :: * -> *) a.
Alternative f =>
WrapFunctor f a -> WrapFunctor f [a]
forall (f :: * -> *) a.
Alternative f =>
WrapFunctor f a -> WrapFunctor f a -> WrapFunctor f a
many :: forall a. WrapFunctor f a -> WrapFunctor f [a]
$cmany :: forall (f :: * -> *) a.
Alternative f =>
WrapFunctor f a -> WrapFunctor f [a]
some :: forall a. WrapFunctor f a -> WrapFunctor f [a]
$csome :: forall (f :: * -> *) a.
Alternative f =>
WrapFunctor f a -> WrapFunctor f [a]
<|> :: forall a. WrapFunctor f a -> WrapFunctor f a -> WrapFunctor f a
$c<|> :: forall (f :: * -> *) a.
Alternative f =>
WrapFunctor f a -> WrapFunctor f a -> WrapFunctor f a
empty :: forall a. WrapFunctor f a
$cempty :: forall (f :: * -> *) a. Alternative f => WrapFunctor f a
Alternative, forall a. a -> WrapFunctor f a
forall a b. WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f b
forall a b.
WrapFunctor f a -> (a -> WrapFunctor f b) -> WrapFunctor f b
forall {f :: * -> *}. Monad f => Applicative (WrapFunctor f)
forall (f :: * -> *) a. Monad f => a -> WrapFunctor f a
forall (f :: * -> *) a b.
Monad f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f b
forall (f :: * -> *) a b.
Monad f =>
WrapFunctor f a -> (a -> WrapFunctor f b) -> WrapFunctor f b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: forall a. a -> WrapFunctor f a
$creturn :: forall (f :: * -> *) a. Monad f => a -> WrapFunctor f a
>> :: forall a b. WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f b
$c>> :: forall (f :: * -> *) a b.
Monad f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f b
>>= :: forall a b.
WrapFunctor f a -> (a -> WrapFunctor f b) -> WrapFunctor f b
$c>>= :: forall (f :: * -> *) a b.
Monad f =>
WrapFunctor f a -> (a -> WrapFunctor f b) -> WrapFunctor f b
Monad, forall a. Eq a => a -> WrapFunctor f a -> Bool
forall a. Num a => WrapFunctor f a -> a
forall a. Ord a => WrapFunctor f a -> a
forall m. Monoid m => WrapFunctor f m -> m
forall a. WrapFunctor f a -> Bool
forall a. WrapFunctor f a -> Int
forall a. WrapFunctor f a -> [a]
forall a. (a -> a -> a) -> WrapFunctor f a -> a
forall m a. Monoid m => (a -> m) -> WrapFunctor f a -> m
forall b a. (b -> a -> b) -> b -> WrapFunctor f a -> b
forall a b. (a -> b -> b) -> b -> WrapFunctor f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> WrapFunctor f a -> Bool
forall (f :: * -> *) a. (Foldable f, Num a) => WrapFunctor f a -> a
forall (f :: * -> *) a. (Foldable f, Ord a) => WrapFunctor f a -> a
forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
WrapFunctor f m -> m
forall (f :: * -> *) a. Foldable f => WrapFunctor f a -> Bool
forall (f :: * -> *) a. Foldable f => WrapFunctor f a -> Int
forall (f :: * -> *) a. Foldable f => WrapFunctor f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> WrapFunctor f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> WrapFunctor f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> WrapFunctor f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> WrapFunctor f 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
product :: forall a. Num a => WrapFunctor f a -> a
$cproduct :: forall (f :: * -> *) a. (Foldable f, Num a) => WrapFunctor f a -> a
sum :: forall a. Num a => WrapFunctor f a -> a
$csum :: forall (f :: * -> *) a. (Foldable f, Num a) => WrapFunctor f a -> a
minimum :: forall a. Ord a => WrapFunctor f a -> a
$cminimum :: forall (f :: * -> *) a. (Foldable f, Ord a) => WrapFunctor f a -> a
maximum :: forall a. Ord a => WrapFunctor f a -> a
$cmaximum :: forall (f :: * -> *) a. (Foldable f, Ord a) => WrapFunctor f a -> a
elem :: forall a. Eq a => a -> WrapFunctor f a -> Bool
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> WrapFunctor f a -> Bool
length :: forall a. WrapFunctor f a -> Int
$clength :: forall (f :: * -> *) a. Foldable f => WrapFunctor f a -> Int
null :: forall a. WrapFunctor f a -> Bool
$cnull :: forall (f :: * -> *) a. Foldable f => WrapFunctor f a -> Bool
toList :: forall a. WrapFunctor f a -> [a]
$ctoList :: forall (f :: * -> *) a. Foldable f => WrapFunctor f a -> [a]
foldl1 :: forall a. (a -> a -> a) -> WrapFunctor f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> WrapFunctor f a -> a
foldr1 :: forall a. (a -> a -> a) -> WrapFunctor f a -> a
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> WrapFunctor f a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> WrapFunctor f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> WrapFunctor f a -> b
foldl :: forall b a. (b -> a -> b) -> b -> WrapFunctor f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> WrapFunctor f a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> WrapFunctor f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> WrapFunctor f a -> b
foldr :: forall a b. (a -> b -> b) -> b -> WrapFunctor f a -> b
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> WrapFunctor f a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> WrapFunctor f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> WrapFunctor f a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> WrapFunctor f a -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> WrapFunctor f a -> m
fold :: forall m. Monoid m => WrapFunctor f m -> m
$cfold :: forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
WrapFunctor f m -> m
Foldable)
  deriving newtype (forall a. WrapFunctor f a
forall a. WrapFunctor f a -> WrapFunctor f a -> WrapFunctor f a
forall {f :: * -> *}. MonadPlus f => Monad (WrapFunctor f)
forall {f :: * -> *}. MonadPlus f => Alternative (WrapFunctor f)
forall (f :: * -> *) a. MonadPlus f => WrapFunctor f a
forall (f :: * -> *) a.
MonadPlus f =>
WrapFunctor f a -> WrapFunctor f a -> WrapFunctor f a
forall (m :: * -> *).
Alternative m
-> Monad m
-> (forall a. m a)
-> (forall a. m a -> m a -> m a)
-> MonadPlus m
mplus :: forall a. WrapFunctor f a -> WrapFunctor f a -> WrapFunctor f a
$cmplus :: forall (f :: * -> *) a.
MonadPlus f =>
WrapFunctor f a -> WrapFunctor f a -> WrapFunctor f a
mzero :: forall a. WrapFunctor f a
$cmzero :: forall (f :: * -> *) a. MonadPlus f => WrapFunctor f a
MonadPlus, forall a. (a -> WrapFunctor f a) -> WrapFunctor f a
forall (m :: * -> *).
Monad m -> (forall a. (a -> m a) -> m a) -> MonadFix m
forall {f :: * -> *}. MonadFix f => Monad (WrapFunctor f)
forall (f :: * -> *) a.
MonadFix f =>
(a -> WrapFunctor f a) -> WrapFunctor f a
mfix :: forall a. (a -> WrapFunctor f a) -> WrapFunctor f a
$cmfix :: forall (f :: * -> *) a.
MonadFix f =>
(a -> WrapFunctor f a) -> WrapFunctor f a
MonadFix, forall a. String -> WrapFunctor f a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall {f :: * -> *}. MonadFail f => Monad (WrapFunctor f)
forall (f :: * -> *) a. MonadFail f => String -> WrapFunctor f a
fail :: forall a. String -> WrapFunctor f a
$cfail :: forall (f :: * -> *) a. MonadFail f => String -> WrapFunctor f a
MonadFail)
  deriving newtype (forall a. a -> WrapFunctor f a
forall (f :: * -> *) a. Pointed f => a -> WrapFunctor f a
forall (p :: * -> *). (forall a. a -> p a) -> Pointed p
point :: forall a. a -> WrapFunctor f a
$cpoint :: forall (f :: * -> *) a. Pointed f => a -> WrapFunctor f a
Pointed, forall a b.
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (a, b)
forall a b.
WrapFunctor f (a, b) -> (WrapFunctor f a, WrapFunctor f b)
forall a b c.
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
forall (m :: * -> *).
Monad m
-> (forall a b. m a -> m b -> m (a, b))
-> (forall a b c. (a -> b -> c) -> m a -> m b -> m c)
-> (forall a b. m (a, b) -> (m a, m b))
-> MonadZip m
forall {f :: * -> *}. MonadZip f => Monad (WrapFunctor f)
forall (f :: * -> *) a b.
MonadZip f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (a, b)
forall (f :: * -> *) a b.
MonadZip f =>
WrapFunctor f (a, b) -> (WrapFunctor f a, WrapFunctor f b)
forall (f :: * -> *) a b c.
MonadZip f =>
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
munzip :: forall a b.
WrapFunctor f (a, b) -> (WrapFunctor f a, WrapFunctor f b)
$cmunzip :: forall (f :: * -> *) a b.
MonadZip f =>
WrapFunctor f (a, b) -> (WrapFunctor f a, WrapFunctor f b)
mzipWith :: forall a b c.
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
$cmzipWith :: forall (f :: * -> *) a b c.
MonadZip f =>
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
mzip :: forall a b.
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (a, b)
$cmzip :: forall (f :: * -> *) a b.
MonadZip f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (a, b)
MonadZip, forall a b.
WrapFunctor f (These a b) -> (WrapFunctor f a, WrapFunctor f b)
forall c a b.
(c -> These a b)
-> WrapFunctor f c -> (WrapFunctor f a, WrapFunctor f b)
forall (f :: * -> *).
Semialign f
-> (forall a b. f (These a b) -> (f a, f b))
-> (forall c a b. (c -> These a b) -> f c -> (f a, f b))
-> Unalign f
forall {f :: * -> *}. Unalign f => Semialign (WrapFunctor f)
forall (f :: * -> *) a b.
Unalign f =>
WrapFunctor f (These a b) -> (WrapFunctor f a, WrapFunctor f b)
forall (f :: * -> *) c a b.
Unalign f =>
(c -> These a b)
-> WrapFunctor f c -> (WrapFunctor f a, WrapFunctor f b)
unalignWith :: forall c a b.
(c -> These a b)
-> WrapFunctor f c -> (WrapFunctor f a, WrapFunctor f b)
$cunalignWith :: forall (f :: * -> *) c a b.
Unalign f =>
(c -> These a b)
-> WrapFunctor f c -> (WrapFunctor f a, WrapFunctor f b)
unalign :: forall a b.
WrapFunctor f (These a b) -> (WrapFunctor f a, WrapFunctor f b)
$cunalign :: forall (f :: * -> *) a b.
Unalign f =>
WrapFunctor f (These a b) -> (WrapFunctor f a, WrapFunctor f b)
Unalign, forall a. WrapFunctor f a
forall (f :: * -> *). Semialign f -> (forall a. f a) -> Align f
forall {f :: * -> *}. Align f => Semialign (WrapFunctor f)
forall (f :: * -> *) a. Align f => WrapFunctor f a
nil :: forall a. WrapFunctor f a
$cnil :: forall (f :: * -> *) a. Align f => WrapFunctor f a
Align, forall a b.
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (These a b)
forall a b c.
(These a b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
forall (f :: * -> *).
Functor f
-> (forall a b. f a -> f b -> f (These a b))
-> (forall a b c. (These a b -> c) -> f a -> f b -> f c)
-> Semialign f
forall {f :: * -> *}. Semialign f => Functor (WrapFunctor f)
forall (f :: * -> *) a b.
Semialign f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (These a b)
forall (f :: * -> *) a b c.
Semialign f =>
(These a b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
alignWith :: forall a b c.
(These a b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
$calignWith :: forall (f :: * -> *) a b c.
Semialign f =>
(These a b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
align :: forall a b.
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (These a b)
$calign :: forall (f :: * -> *) a b.
Semialign f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (These a b)
Semialign, forall a b.
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (a, b)
forall a b c.
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
forall (f :: * -> *).
Semialign f
-> (forall a b. f a -> f b -> f (a, b))
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> Zip f
forall {f :: * -> *}. Zip f => Semialign (WrapFunctor f)
forall (f :: * -> *) a b.
Zip f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (a, b)
forall (f :: * -> *) a b c.
Zip f =>
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
zipWith :: forall a b c.
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
$czipWith :: forall (f :: * -> *) a b c.
Zip f =>
(a -> b -> c)
-> WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f c
zip :: forall a b.
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (a, b)
$czip :: forall (f :: * -> *) a b.
Zip f =>
WrapFunctor f a -> WrapFunctor f b -> WrapFunctor f (a, b)
Zip,  forall a b.
WrapFunctor f (a, b) -> (WrapFunctor f a, WrapFunctor f b)
forall c a b.
(c -> (a, b))
-> WrapFunctor f c -> (WrapFunctor f a, WrapFunctor f b)
forall (f :: * -> *).
Zip f
-> (forall c a b. (c -> (a, b)) -> f c -> (f a, f b))
-> (forall a b. f (a, b) -> (f a, f b))
-> Unzip f
forall {f :: * -> *}. Unzip f => Zip (WrapFunctor f)
forall (f :: * -> *) a b.
Unzip f =>
WrapFunctor f (a, b) -> (WrapFunctor f a, WrapFunctor f b)
forall (f :: * -> *) c a b.
Unzip f =>
(c -> (a, b))
-> WrapFunctor f c -> (WrapFunctor f a, WrapFunctor f b)
unzip :: forall a b.
WrapFunctor f (a, b) -> (WrapFunctor f a, WrapFunctor f b)
$cunzip :: forall (f :: * -> *) a b.
Unzip f =>
WrapFunctor f (a, b) -> (WrapFunctor f a, WrapFunctor f b)
unzipWith :: forall c a b.
(c -> (a, b))
-> WrapFunctor f c -> (WrapFunctor f a, WrapFunctor f b)
$cunzipWith :: forall (f :: * -> *) c a b.
Unzip f =>
(c -> (a, b))
-> WrapFunctor f c -> (WrapFunctor f a, WrapFunctor f b)
Unzip)

instance Traversable f => Traversable (WrapFunctor f) where
  traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> WrapFunctor f a -> f (WrapFunctor f b)
traverse a -> f b
f = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall (f :: * -> *) a. f a -> WrapFunctor f a
WrapFunctor forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse a -> f b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a. WrapFunctor f a -> f a
runFunctor


type role WrapMono representational nominal
-- | Similar to 'WrappedMono' from @mono-traversable,
--   but uses @newtype@ instaed of GADTs, which is efficient.
--   To restrict the construction, we hide genuine constructor
--   and expose the constrained pattern synonym 'WrapMono' and
--   specifies type roles tightly (note: the role for @mono@
--   should NOT be representational honestly; indeed, @WrapMono mono a@
--   could be coerced to @WrapMono mono' a@ iff @mono@ and @mono' are
--   representationally equivalent __AND__ @Element a ~ Element a@.)
newtype WrapMono mono b = WrapMono' mono
  deriving newtype (Eq (Element (WrapMono mono b)) =>
Element (WrapMono mono b) -> WrapMono mono b -> Bool
WrapMono mono b -> Bool
WrapMono mono b -> Int
WrapMono mono b -> Int64
WrapMono mono b -> [Element (WrapMono mono b)]
WrapMono mono b -> Element (WrapMono mono b)
(Element (WrapMono mono b) -> Bool) -> WrapMono mono b -> Bool
(Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Ordering)
-> WrapMono mono b -> Element (WrapMono mono b)
(Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Element (WrapMono mono b))
-> WrapMono mono b -> Element (WrapMono mono b)
forall i. Integral i => WrapMono mono b -> i -> Ordering
forall m.
Semigroup m =>
(Element (WrapMono mono b) -> m) -> WrapMono mono b -> m
forall m.
Monoid m =>
(Element (WrapMono mono b) -> m) -> WrapMono mono b -> m
forall a.
(a -> Element (WrapMono mono b) -> a) -> a -> WrapMono mono b -> a
forall b.
(Element (WrapMono mono b) -> b -> b) -> b -> WrapMono mono b -> b
forall mono.
(forall m. Monoid m => (Element mono -> m) -> mono -> m)
-> (forall b. (Element mono -> b -> b) -> b -> mono -> b)
-> (forall a. (a -> Element mono -> a) -> a -> mono -> a)
-> (mono -> [Element mono])
-> ((Element mono -> Bool) -> mono -> Bool)
-> ((Element mono -> Bool) -> mono -> Bool)
-> (mono -> Bool)
-> (mono -> Int)
-> (mono -> Int64)
-> (forall i. Integral i => mono -> i -> Ordering)
-> (forall (f :: * -> *) b.
    Applicative f =>
    (Element mono -> f b) -> mono -> f ())
-> (forall (f :: * -> *) b.
    Applicative f =>
    mono -> (Element mono -> f b) -> f ())
-> (forall (m :: * -> *).
    Applicative m =>
    (Element mono -> m ()) -> mono -> m ())
-> (forall (m :: * -> *).
    Applicative m =>
    mono -> (Element mono -> m ()) -> m ())
-> (forall (m :: * -> *) a.
    Monad m =>
    (a -> Element mono -> m a) -> a -> mono -> m a)
-> (forall m. Semigroup m => (Element mono -> m) -> mono -> m)
-> ((Element mono -> Element mono -> Element mono)
    -> mono -> Element mono)
-> ((Element mono -> Element mono -> Element mono)
    -> mono -> Element mono)
-> (mono -> Element mono)
-> (mono -> Element mono)
-> (mono -> Element mono)
-> (mono -> Element mono)
-> ((Element mono -> Element mono -> Ordering)
    -> mono -> Element mono)
-> ((Element mono -> Element mono -> Ordering)
    -> mono -> Element mono)
-> (Eq (Element mono) => Element mono -> mono -> Bool)
-> (Eq (Element mono) => Element mono -> mono -> Bool)
-> MonoFoldable mono
forall mono k (b :: k).
(MonoFoldable mono, Eq (Element (WrapMono mono b))) =>
Element (WrapMono mono b) -> WrapMono mono b -> Bool
forall mono k (b :: k).
MonoFoldable mono =>
WrapMono mono b -> Bool
forall mono k (b :: k). MonoFoldable mono => WrapMono mono b -> Int
forall mono k (b :: k).
MonoFoldable mono =>
WrapMono mono b -> Int64
forall mono k (b :: k).
MonoFoldable mono =>
WrapMono mono b -> [Element (WrapMono mono b)]
forall mono k (b :: k).
MonoFoldable mono =>
WrapMono mono b -> Element (WrapMono mono b)
forall mono k (b :: k).
MonoFoldable mono =>
(Element (WrapMono mono b) -> Bool) -> WrapMono mono b -> Bool
forall mono k (b :: k).
MonoFoldable mono =>
(Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Ordering)
-> WrapMono mono b -> Element (WrapMono mono b)
forall mono k (b :: k).
MonoFoldable mono =>
(Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Element (WrapMono mono b))
-> WrapMono mono b -> Element (WrapMono mono b)
forall mono k (b :: k) i.
(MonoFoldable mono, Integral i) =>
WrapMono mono b -> i -> Ordering
forall mono k (b :: k) m.
(MonoFoldable mono, Semigroup m) =>
(Element (WrapMono mono b) -> m) -> WrapMono mono b -> m
forall mono k (b :: k) m.
(MonoFoldable mono, Monoid m) =>
(Element (WrapMono mono b) -> m) -> WrapMono mono b -> m
forall mono k (b :: k) a.
MonoFoldable mono =>
(a -> Element (WrapMono mono b) -> a) -> a -> WrapMono mono b -> a
forall mono k (b :: k) b.
MonoFoldable mono =>
(Element (WrapMono mono b) -> b -> b) -> b -> WrapMono mono b -> b
forall mono k (b :: k) (m :: * -> *).
(MonoFoldable mono, Applicative m) =>
WrapMono mono b -> (Element (WrapMono mono b) -> m ()) -> m ()
forall mono k (b :: k) (m :: * -> *).
(MonoFoldable mono, Applicative m) =>
(Element (WrapMono mono b) -> m ()) -> WrapMono mono b -> m ()
forall mono k (b :: k) (m :: * -> *) a.
(MonoFoldable mono, Monad m) =>
(a -> Element (WrapMono mono b) -> m a)
-> a -> WrapMono mono b -> m a
forall mono k (b :: k) (f :: * -> *) b.
(MonoFoldable mono, Applicative f) =>
WrapMono mono b -> (Element (WrapMono mono b) -> f b) -> f ()
forall mono k (b :: k) (f :: * -> *) b.
(MonoFoldable mono, Applicative f) =>
(Element (WrapMono mono b) -> f b) -> WrapMono mono b -> f ()
forall (m :: * -> *).
Applicative m =>
WrapMono mono b -> (Element (WrapMono mono b) -> m ()) -> m ()
forall (m :: * -> *).
Applicative m =>
(Element (WrapMono mono b) -> m ()) -> WrapMono mono b -> m ()
forall (m :: * -> *) a.
Monad m =>
(a -> Element (WrapMono mono b) -> m a)
-> a -> WrapMono mono b -> m a
forall (f :: * -> *) b.
Applicative f =>
WrapMono mono b -> (Element (WrapMono mono b) -> f b) -> f ()
forall (f :: * -> *) b.
Applicative f =>
(Element (WrapMono mono b) -> f b) -> WrapMono mono b -> f ()
onotElem :: Eq (Element (WrapMono mono b)) =>
Element (WrapMono mono b) -> WrapMono mono b -> Bool
$conotElem :: forall mono k (b :: k).
(MonoFoldable mono, Eq (Element (WrapMono mono b))) =>
Element (WrapMono mono b) -> WrapMono mono b -> Bool
oelem :: Eq (Element (WrapMono mono b)) =>
Element (WrapMono mono b) -> WrapMono mono b -> Bool
$coelem :: forall mono k (b :: k).
(MonoFoldable mono, Eq (Element (WrapMono mono b))) =>
Element (WrapMono mono b) -> WrapMono mono b -> Bool
minimumByEx :: (Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Ordering)
-> WrapMono mono b -> Element (WrapMono mono b)
$cminimumByEx :: forall mono k (b :: k).
MonoFoldable mono =>
(Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Ordering)
-> WrapMono mono b -> Element (WrapMono mono b)
maximumByEx :: (Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Ordering)
-> WrapMono mono b -> Element (WrapMono mono b)
$cmaximumByEx :: forall mono k (b :: k).
MonoFoldable mono =>
(Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Ordering)
-> WrapMono mono b -> Element (WrapMono mono b)
unsafeLast :: WrapMono mono b -> Element (WrapMono mono b)
$cunsafeLast :: forall mono k (b :: k).
MonoFoldable mono =>
WrapMono mono b -> Element (WrapMono mono b)
unsafeHead :: WrapMono mono b -> Element (WrapMono mono b)
$cunsafeHead :: forall mono k (b :: k).
MonoFoldable mono =>
WrapMono mono b -> Element (WrapMono mono b)
lastEx :: WrapMono mono b -> Element (WrapMono mono b)
$clastEx :: forall mono k (b :: k).
MonoFoldable mono =>
WrapMono mono b -> Element (WrapMono mono b)
headEx :: WrapMono mono b -> Element (WrapMono mono b)
$cheadEx :: forall mono k (b :: k).
MonoFoldable mono =>
WrapMono mono b -> Element (WrapMono mono b)
ofoldl1Ex' :: (Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Element (WrapMono mono b))
-> WrapMono mono b -> Element (WrapMono mono b)
$cofoldl1Ex' :: forall mono k (b :: k).
MonoFoldable mono =>
(Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Element (WrapMono mono b))
-> WrapMono mono b -> Element (WrapMono mono b)
ofoldr1Ex :: (Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Element (WrapMono mono b))
-> WrapMono mono b -> Element (WrapMono mono b)
$cofoldr1Ex :: forall mono k (b :: k).
MonoFoldable mono =>
(Element (WrapMono mono b)
 -> Element (WrapMono mono b) -> Element (WrapMono mono b))
-> WrapMono mono b -> Element (WrapMono mono b)
ofoldMap1Ex :: forall m.
Semigroup m =>
(Element (WrapMono mono b) -> m) -> WrapMono mono b -> m
$cofoldMap1Ex :: forall mono k (b :: k) m.
(MonoFoldable mono, Semigroup m) =>
(Element (WrapMono mono b) -> m) -> WrapMono mono b -> m
ofoldlM :: forall (m :: * -> *) a.
Monad m =>
(a -> Element (WrapMono mono b) -> m a)
-> a -> WrapMono mono b -> m a
$cofoldlM :: forall mono k (b :: k) (m :: * -> *) a.
(MonoFoldable mono, Monad m) =>
(a -> Element (WrapMono mono b) -> m a)
-> a -> WrapMono mono b -> m a
oforM_ :: forall (m :: * -> *).
Applicative m =>
WrapMono mono b -> (Element (WrapMono mono b) -> m ()) -> m ()
$coforM_ :: forall mono k (b :: k) (m :: * -> *).
(MonoFoldable mono, Applicative m) =>
WrapMono mono b -> (Element (WrapMono mono b) -> m ()) -> m ()
omapM_ :: forall (m :: * -> *).
Applicative m =>
(Element (WrapMono mono b) -> m ()) -> WrapMono mono b -> m ()
$comapM_ :: forall mono k (b :: k) (m :: * -> *).
(MonoFoldable mono, Applicative m) =>
(Element (WrapMono mono b) -> m ()) -> WrapMono mono b -> m ()
ofor_ :: forall (f :: * -> *) b.
Applicative f =>
WrapMono mono b -> (Element (WrapMono mono b) -> f b) -> f ()
$cofor_ :: forall mono k (b :: k) (f :: * -> *) b.
(MonoFoldable mono, Applicative f) =>
WrapMono mono b -> (Element (WrapMono mono b) -> f b) -> f ()
otraverse_ :: forall (f :: * -> *) b.
Applicative f =>
(Element (WrapMono mono b) -> f b) -> WrapMono mono b -> f ()
$cotraverse_ :: forall mono k (b :: k) (f :: * -> *) b.
(MonoFoldable mono, Applicative f) =>
(Element (WrapMono mono b) -> f b) -> WrapMono mono b -> f ()
ocompareLength :: forall i. Integral i => WrapMono mono b -> i -> Ordering
$cocompareLength :: forall mono k (b :: k) i.
(MonoFoldable mono, Integral i) =>
WrapMono mono b -> i -> Ordering
olength64 :: WrapMono mono b -> Int64
$colength64 :: forall mono k (b :: k).
MonoFoldable mono =>
WrapMono mono b -> Int64
olength :: WrapMono mono b -> Int
$colength :: forall mono k (b :: k). MonoFoldable mono => WrapMono mono b -> Int
onull :: WrapMono mono b -> Bool
$conull :: forall mono k (b :: k).
MonoFoldable mono =>
WrapMono mono b -> Bool
oany :: (Element (WrapMono mono b) -> Bool) -> WrapMono mono b -> Bool
$coany :: forall mono k (b :: k).
MonoFoldable mono =>
(Element (WrapMono mono b) -> Bool) -> WrapMono mono b -> Bool
oall :: (Element (WrapMono mono b) -> Bool) -> WrapMono mono b -> Bool
$coall :: forall mono k (b :: k).
MonoFoldable mono =>
(Element (WrapMono mono b) -> Bool) -> WrapMono mono b -> Bool
otoList :: WrapMono mono b -> [Element (WrapMono mono b)]
$cotoList :: forall mono k (b :: k).
MonoFoldable mono =>
WrapMono mono b -> [Element (WrapMono mono b)]
ofoldl' :: forall a.
(a -> Element (WrapMono mono b) -> a) -> a -> WrapMono mono b -> a
$cofoldl' :: forall mono k (b :: k) a.
MonoFoldable mono =>
(a -> Element (WrapMono mono b) -> a) -> a -> WrapMono mono b -> a
ofoldr :: forall b.
(Element (WrapMono mono b) -> b -> b) -> b -> WrapMono mono b -> b
$cofoldr :: forall mono k (b :: k) b.
MonoFoldable mono =>
(Element (WrapMono mono b) -> b -> b) -> b -> WrapMono mono b -> b
ofoldMap :: forall m.
Monoid m =>
(Element (WrapMono mono b) -> m) -> WrapMono mono b -> m
$cofoldMap :: forall mono k (b :: k) m.
(MonoFoldable mono, Monoid m) =>
(Element (WrapMono mono b) -> m) -> WrapMono mono b -> m
MonoFoldable, (Element (WrapMono mono b) -> Element (WrapMono mono b))
-> WrapMono mono b -> WrapMono mono b
forall mono.
((Element mono -> Element mono) -> mono -> mono)
-> MonoFunctor mono
forall mono k (b :: k).
MonoFunctor mono =>
(Element (WrapMono mono b) -> Element (WrapMono mono b))
-> WrapMono mono b -> WrapMono mono b
omap :: (Element (WrapMono mono b) -> Element (WrapMono mono b))
-> WrapMono mono b -> WrapMono mono b
$comap :: forall mono k (b :: k).
MonoFunctor mono =>
(Element (WrapMono mono b) -> Element (WrapMono mono b))
-> WrapMono mono b -> WrapMono mono b
MonoFunctor, WrapMono mono b
[WrapMono mono b] -> WrapMono mono b
WrapMono mono b -> WrapMono mono b -> WrapMono mono b
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall {mono} {k} {b :: k}.
Monoid mono =>
Semigroup (WrapMono mono b)
forall mono k (b :: k). Monoid mono => WrapMono mono b
forall mono k (b :: k).
Monoid mono =>
[WrapMono mono b] -> WrapMono mono b
forall mono k (b :: k).
Monoid mono =>
WrapMono mono b -> WrapMono mono b -> WrapMono mono b
mconcat :: [WrapMono mono b] -> WrapMono mono b
$cmconcat :: forall mono k (b :: k).
Monoid mono =>
[WrapMono mono b] -> WrapMono mono b
mappend :: WrapMono mono b -> WrapMono mono b -> WrapMono mono b
$cmappend :: forall mono k (b :: k).
Monoid mono =>
WrapMono mono b -> WrapMono mono b -> WrapMono mono b
mempty :: WrapMono mono b
$cmempty :: forall mono k (b :: k). Monoid mono => WrapMono mono b
Monoid, NonEmpty (WrapMono mono b) -> WrapMono mono b
WrapMono mono b -> WrapMono mono b -> WrapMono mono b
forall b. Integral b => b -> WrapMono mono b -> WrapMono mono b
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall mono k (b :: k).
Semigroup mono =>
NonEmpty (WrapMono mono b) -> WrapMono mono b
forall mono k (b :: k).
Semigroup mono =>
WrapMono mono b -> WrapMono mono b -> WrapMono mono b
forall mono k (b :: k) b.
(Semigroup mono, Integral b) =>
b -> WrapMono mono b -> WrapMono mono b
stimes :: forall b. Integral b => b -> WrapMono mono b -> WrapMono mono b
$cstimes :: forall mono k (b :: k) b.
(Semigroup mono, Integral b) =>
b -> WrapMono mono b -> WrapMono mono b
sconcat :: NonEmpty (WrapMono mono b) -> WrapMono mono b
$csconcat :: forall mono k (b :: k).
Semigroup mono =>
NonEmpty (WrapMono mono b) -> WrapMono mono b
<> :: WrapMono mono b -> WrapMono mono b -> WrapMono mono b
$c<> :: forall mono k (b :: k).
Semigroup mono =>
WrapMono mono b -> WrapMono mono b -> WrapMono mono b
Semigroup, Element (WrapMono mono b) -> WrapMono mono b
forall mono. (Element mono -> mono) -> MonoPointed mono
forall mono k (b :: k).
MonoPointed mono =>
Element (WrapMono mono b) -> WrapMono mono b
opoint :: Element (WrapMono mono b) -> WrapMono mono b
$copoint :: forall mono k (b :: k).
MonoPointed mono =>
Element (WrapMono mono b) -> WrapMono mono b
MonoPointed)
  deriving newtype (forall mono. MonoFoldable mono -> GrowingAppend mono
forall mono k (b :: k).
MonoFoldable mono =>
MonoFoldable (WrapMono mono b)
GrowingAppend)

type instance Element (WrapMono mono b) = Element mono

pattern WrapMono :: b ~ Element mono => b ~ Element mono => mono -> WrapMono mono b
pattern $bWrapMono :: forall b mono.
(b ~ Element mono, b ~ Element mono) =>
mono -> WrapMono mono b
$mWrapMono :: forall {r} {b} {mono}.
(b ~ Element mono) =>
WrapMono mono b
-> ((b ~ Element mono) => mono -> r) -> ((# #) -> r) -> r
WrapMono {forall b mono. (b ~ Element mono) => WrapMono mono b -> mono
unwrapMono} = WrapMono' unwrapMono

coerceToMono :: WrapMono mono (Element mono) -> mono
{-# INLINE coerceToMono #-}
coerceToMono :: forall mono. WrapMono mono (Element mono) -> mono
coerceToMono = coerce :: forall a b. Coercible a b => a -> b
coerce

withMonoCoercible
  :: (Coercible (WrapMono mono (Element mono)) mono => r)
  -> r
{-# INLINE withMonoCoercible #-}
#if defined(DEEP_SUBSUMPTION)
withMonoCoercible :: forall mono r.
(Coercible (WrapMono mono (Element mono)) mono => r) -> r
withMonoCoercible = forall a. a -> a
id
#else
withMonoCoercible = \x -> x
#endif