module Data.Exists.Defaults where
import Data.Exists.Internal
import Prelude (String, Int, ShowS, Monad, (.))
import Control.Applicative (Applicative)
import Control.Monad (liftM)
import Data.Monoid (Monoid)
import Prelude (Show (..),
Functor (..))
import Data.Foldable (Foldable (..))
import Data.Traversable (Traversable (..))
import Data.Functor.Contravariant (Contravariant (..))
import Data.Functor.Extend (Extend (..))
import Control.Comonad (Comonad (..))
import Control.Comonad.Env.Class (ComonadEnv (..))
import Control.Comonad.Traced.Class (ComonadTraced (..))
import Control.Comonad.Store.Class (ComonadStore (..))
import Data.Copointed (Copointed (..))
showDefault :: ExistentialWith Show e => e -> String
showDefault = apply show
showsPrecDefault :: ExistentialWith Show e => Int -> e -> ShowS
showsPrecDefault n e s = apply (\a -> showsPrec n a s) e
fmapDefault :: ExistentialWith1 Functor e => (a -> b) -> e a -> e b
fmapDefault f = apply1 (exists1 . fmap f)
foldDefault :: (ExistentialWith1 Foldable e, Monoid m) => e m -> m
foldDefault = apply1 fold
foldMapDefault :: (ExistentialWith1 Foldable e, Monoid m) => (a -> m) -> e a -> m
foldMapDefault f = apply1 (foldMap f)
foldrDefault :: ExistentialWith1 Foldable e => (a -> b -> b) -> b -> e a -> b
foldrDefault f x = apply1 (foldr f x)
foldlDefault :: ExistentialWith1 Foldable e => (a -> b -> a) -> a -> e b -> a
foldlDefault f x = apply1 (foldl f x)
foldr1Default :: ExistentialWith1 Foldable e => (a -> a -> a) -> e a -> a
foldr1Default f = apply1 (foldr1 f)
foldl1Default :: ExistentialWith1 Foldable e => (a -> a -> a) -> e a -> a
foldl1Default f = apply1 (foldl1 f)
traverseDefault :: (ExistentialWith1 Traversable e, Applicative f) => (a -> f b) -> e a -> f (e b)
traverseDefault f = apply1 (fmap exists1 . traverse f)
sequenceADefault :: (ExistentialWith1 Traversable e, Applicative f) => e (f a) -> f (e a)
sequenceADefault = apply1 (fmap exists1 . sequenceA)
mapMDefault :: (ExistentialWith1 Traversable e, Monad m) => (a -> m b) -> e a -> m (e b)
mapMDefault f = apply1 (liftM exists1 . mapM f)
sequenceDefault :: (ExistentialWith1 Traversable e, Monad m) => e (m a) -> m (e a)
sequenceDefault = apply1 (liftM exists1 . sequence)
contramapDefault :: ExistentialWith1 Contravariant e => (a -> b) -> e b -> e a
contramapDefault f = apply1 (exists1 . contramap f)
duplicateDefault :: ExistentialWith1 Extend e => e a -> e (e a)
duplicateDefault = apply1 (exists1 . fmap exists1 . duplicate)
extractDefault :: ExistentialWith1 Comonad e => e a -> a
extractDefault = apply1 extract
askDefault :: ExistentialWith1 (ComonadEnv env) e => e a -> env
askDefault = apply1 ask
traceDefault :: ExistentialWith1 (ComonadTraced m) e => m -> e a -> a
traceDefault a = apply1 (trace a)
posDefault :: ExistentialWith1 (ComonadStore s) e => e a -> s
posDefault = apply1 pos
peekDefault :: ExistentialWith1 (ComonadStore s) e => s -> e a -> a
peekDefault a = apply1 (peek a)
peeksDefault :: ExistentialWith1 (ComonadStore s) e => (s -> s) -> e a -> a
peeksDefault f = apply1 (peeks f)
seekDefault :: ExistentialWith1 (ComonadStore s) e => s -> e a -> e a
seekDefault a = apply1 (exists1 . seek a)
seeksDefault :: ExistentialWith1 (ComonadStore s) e => (s -> s) -> e a -> e a
seeksDefault f = apply1 (exists1 . seeks f)
copointDefault :: ExistentialWith1 Copointed e => e a -> a
copointDefault = apply1 copoint