{-# LANGUAGE CPP                     #-}
{-# LANGUAGE TypeFamilies            #-}
{-# OPTIONS_GHC -fno-warn-orphans    #-}
module Data.MonoTraversable.Instances () where

import Data.DList.Instances ()
import           Data.Traversable.Instances ()
import Data.Functor.Apply (MaybeApply (..), WrappedApplicative)
import Control.Comonad (Cokleisli, Comonad, extract, extend)
import Control.Comonad.Store (StoreT)
import Control.Comonad.Env (EnvT)
import Control.Comonad.Traced (TracedT)
import Data.DList (DList)
import Data.Semigroupoid.Static (Static)
import qualified Data.DList as DL
import Data.Vector.Instances ()
import Data.MonoTraversable
import Data.Sequences
#if !MIN_VERSION_base(4,8,0)
import Control.Monad (liftM)
#endif
import Control.Monad.Trans.Identity (IdentityT)
import Data.Semigroup (Arg)
import Data.List.NonEmpty (NonEmpty)
import Data.Functor.Identity (Identity)
import Data.Tree (Tree)
import Data.Traversable (traverse)
import Control.Applicative (Applicative)
import Data.Monoid (Monoid)

#if !MIN_VERSION_comonad(5,0,0)
import Data.Functor.Coproduct (Coproduct)
#endif

type instance Element (DList a) = a
instance MonoFoldable (DList a) where
    otoList :: DList a -> [Element (DList a)]
otoList = DList a -> [Element (DList a)]
forall a. DList a -> [a]
DL.toList
    headEx :: DList a -> Element (DList a)
headEx = DList a -> Element (DList a)
forall a. DList a -> a
DL.head
    {-# INLINE otoList #-}
    {-# INLINE headEx #-}
instance MonoTraversable (DList a) where
     otraverse :: (Element (DList a) -> f (Element (DList a)))
-> DList a -> f (DList a)
otraverse f :: Element (DList a) -> f (Element (DList a))
f = ([a] -> DList a) -> f [a] -> f (DList a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [a] -> DList a
forall a. [a] -> DList a
DL.fromList (f [a] -> f (DList a))
-> (DList a -> f [a]) -> DList a -> f (DList a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> [a] -> f [a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
Data.Traversable.traverse a -> f a
Element (DList a) -> f (Element (DList a))
f ([a] -> f [a]) -> (DList a -> [a]) -> DList a -> f [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DList a -> [a]
forall a. DList a -> [a]
DL.toList
#if !MIN_VERSION_base(4,8,0)
     omapM f = liftM DL.fromList . mapM f . DL.toList
#endif
instance MonoFunctor (DList a)
instance MonoPointed (DList a)
instance GrowingAppend (DList a)

instance SemiSequence (DList a) where
    type Index (DList a) = Int
    cons :: Element (DList a) -> DList a -> DList a
cons = Element (DList a) -> DList a -> DList a
forall a. a -> DList a -> DList a
DL.cons
    snoc :: DList a -> Element (DList a) -> DList a
snoc = DList a -> Element (DList a) -> DList a
forall a. DList a -> a -> DList a
DL.snoc

    reverse :: DList a -> DList a
reverse = DList a -> DList a
forall seq. IsSequence seq => seq -> seq
defaultReverse
    sortBy :: (Element (DList a) -> Element (DList a) -> Ordering)
-> DList a -> DList a
sortBy = (Element (DList a) -> Element (DList a) -> Ordering)
-> DList a -> DList a
forall seq.
IsSequence seq =>
(Element seq -> Element seq -> Ordering) -> seq -> seq
defaultSortBy
    intersperse :: Element (DList a) -> DList a -> DList a
intersperse = Element (DList a) -> DList a -> DList a
forall seq. IsSequence seq => Element seq -> seq -> seq
defaultIntersperse
    find :: (Element (DList a) -> Bool) -> DList a -> Maybe (Element (DList a))
find = (Element (DList a) -> Bool) -> DList a -> Maybe (Element (DList a))
forall seq.
MonoFoldable seq =>
(Element seq -> Bool) -> seq -> Maybe (Element seq)
defaultFind
    {-# INLINE intersperse #-}
    {-# INLINE reverse #-}
    {-# INLINE find #-}
    {-# INLINE sortBy #-}
    {-# INLINE cons #-}
    {-# INLINE snoc #-}

instance IsSequence (DList a) where
    fromList :: [Element (DList a)] -> DList a
fromList = [Element (DList a)] -> DList a
forall a. [a] -> DList a
DL.fromList
    replicate :: Index (DList a) -> Element (DList a) -> DList a
replicate = Index (DList a) -> Element (DList a) -> DList a
forall a. Int -> a -> DList a
DL.replicate
    tailEx :: DList a -> DList a
tailEx = DList a -> DList a
forall a. DList a -> DList a
DL.tail
    {-# INLINE fromList #-}
    {-# INLINE replicate #-}
    {-# INLINE tailEx #-}

type instance Element (Cokleisli w a b) = b
instance MonoFunctor (Cokleisli w a b)
instance MonoPointed (Cokleisli w a b)

type instance Element (WrappedApplicative f a) = a
instance Control.Applicative.Applicative f => MonoPointed (WrappedApplicative f a)
instance Functor f => MonoFunctor (WrappedApplicative f a)

type instance Element (MaybeApply f a) = a
instance Functor f => MonoFunctor (MaybeApply f a)
instance MonoPointed (MaybeApply f a) where
    opoint :: Element (MaybeApply f a) -> MaybeApply f a
opoint = Either (f a) a -> MaybeApply f a
forall (f :: * -> *) a. Either (f a) a -> MaybeApply f a
MaybeApply (Either (f a) a -> MaybeApply f a)
-> (a -> Either (f a) a) -> a -> MaybeApply f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either (f a) a
forall a b. b -> Either a b
Right
    {-# INLINE opoint #-}

type instance Element (TracedT m w a) = a
instance (Comonad w, Data.Monoid.Monoid m) => MonoComonad (TracedT m w a) where
    oextract :: TracedT m w a -> Element (TracedT m w a)
oextract = TracedT m w a -> Element (TracedT m w a)
forall (w :: * -> *) a. Comonad w => w a -> a
extract
    oextend :: (TracedT m w a -> Element (TracedT m w a))
-> TracedT m w a -> TracedT m w a
oextend = (TracedT m w a -> Element (TracedT m w a))
-> TracedT m w a -> TracedT m w a
forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
extend
instance Functor w => MonoFunctor (TracedT m w a)

type instance Element (StoreT s w a) = a
instance Comonad w => MonoComonad (StoreT s w a) where
    oextract :: StoreT s w a -> Element (StoreT s w a)
oextract = StoreT s w a -> Element (StoreT s w a)
forall (w :: * -> *) a. Comonad w => w a -> a
extract
    oextend :: (StoreT s w a -> Element (StoreT s w a))
-> StoreT s w a -> StoreT s w a
oextend = (StoreT s w a -> Element (StoreT s w a))
-> StoreT s w a -> StoreT s w a
forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
extend
instance Functor w => MonoFunctor (StoreT s w a)

type instance Element (EnvT e w a) = a
instance Comonad w => MonoComonad (EnvT e w a) where
    oextract :: EnvT e w a -> Element (EnvT e w a)
oextract = EnvT e w a -> Element (EnvT e w a)
forall (w :: * -> *) a. Comonad w => w a -> a
extract
    oextend :: (EnvT e w a -> Element (EnvT e w a)) -> EnvT e w a -> EnvT e w a
oextend = (EnvT e w a -> Element (EnvT e w a)) -> EnvT e w a -> EnvT e w a
forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
extend
instance Functor w => MonoFunctor (EnvT e w a)

#if !MIN_VERSION_comonad(5,0,0)
type instance Element (Coproduct f g a) = a
instance (Functor f, Functor g) => MonoFunctor (Coproduct f g a)
instance (Comonad f, Comonad g) => MonoComonad (Coproduct f g a) where
    oextract = extract
    oextend = extend
#endif

type instance Element (Static f a b) = b
instance Applicative f => MonoPointed (Static f a b)
instance Functor f => MonoFunctor (Static f a b)

instance Comonad w => MonoComonad (IdentityT w a) where
    oextract :: IdentityT w a -> Element (IdentityT w a)
oextract = IdentityT w a -> Element (IdentityT w a)
forall (w :: * -> *) a. Comonad w => w a -> a
extract
    oextend :: (IdentityT w a -> Element (IdentityT w a))
-> IdentityT w a -> IdentityT w a
oextend = (IdentityT w a -> Element (IdentityT w a))
-> IdentityT w a -> IdentityT w a
forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
extend

-- Comonad
instance MonoComonad (Tree a) where
    oextract :: Tree a -> Element (Tree a)
oextract = Tree a -> Element (Tree a)
forall (w :: * -> *) a. Comonad w => w a -> a
extract
    oextend :: (Tree a -> Element (Tree a)) -> Tree a -> Tree a
oextend = (Tree a -> Element (Tree a)) -> Tree a -> Tree a
forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
extend
instance MonoComonad (NonEmpty a) where
    oextract :: NonEmpty a -> Element (NonEmpty a)
oextract = NonEmpty a -> Element (NonEmpty a)
forall (w :: * -> *) a. Comonad w => w a -> a
extract
    oextend :: (NonEmpty a -> Element (NonEmpty a)) -> NonEmpty a -> NonEmpty a
oextend = (NonEmpty a -> Element (NonEmpty a)) -> NonEmpty a -> NonEmpty a
forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
extend
instance MonoComonad (Identity a) where
    oextract :: Identity a -> Element (Identity a)
oextract = Identity a -> Element (Identity a)
forall (w :: * -> *) a. Comonad w => w a -> a
extract
    oextend :: (Identity a -> Element (Identity a)) -> Identity a -> Identity a
oextend = (Identity a -> Element (Identity a)) -> Identity a -> Identity a
forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
extend
instance Monoid m => MonoComonad (m -> a) where
    oextract :: (m -> a) -> Element (m -> a)
oextract = (m -> a) -> Element (m -> a)
forall (w :: * -> *) a. Comonad w => w a -> a
extract
    oextend :: ((m -> a) -> Element (m -> a)) -> (m -> a) -> m -> a
oextend = ((m -> a) -> Element (m -> a)) -> (m -> a) -> m -> a
forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
extend
instance MonoComonad (e, a) where
    oextract :: (e, a) -> Element (e, a)
oextract = (e, a) -> Element (e, a)
forall (w :: * -> *) a. Comonad w => w a -> a
extract
    oextend :: ((e, a) -> Element (e, a)) -> (e, a) -> (e, a)
oextend = ((e, a) -> Element (e, a)) -> (e, a) -> (e, a)
forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
extend
instance MonoComonad (Arg a b) where
    oextract :: Arg a b -> Element (Arg a b)
oextract = Arg a b -> Element (Arg a b)
forall (w :: * -> *) a. Comonad w => w a -> a
extract
    oextend :: (Arg a b -> Element (Arg a b)) -> Arg a b -> Arg a b
oextend = (Arg a b -> Element (Arg a b)) -> Arg a b -> Arg a b
forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
extend