{-# Language
 RankNTypes
,FunctionalDependencies
,FlexibleContexts
,ScopedTypeVariables
#-}

module Traversable_r where

import Data.Monoid (Endo(..))
import Endo1
import Data.Functor.Identity
import Control.Applicative (Const(..))
import Data.Coerce
import Data.Functor.Apply
import Data.Maybe (fromJust)


----
-- Functor_r

class Functor_r r f where
 fmap_r :: (r a -> r b) -> f a -> f b

----
-- Foldable1_r

class Foldable_r r t => Foldable1_r r t | t -> r where
 foldr1_r :: (r a -> Maybe b -> b) -> t a -> b
 foldr1_r f xs = (runEndo1 (foldMap1_r (Endo1 . f) xs)) Nothing
 foldMap1_r :: Semigroup m => (r a -> m) -> t a -> m
 foldMap1_r f xs = (foldr1_r ((\ a b -> a <> fromJust b) . f) xs)

----
-- Traversable1_r

class (Foldable1_r r t, Traversable_r r t) => Traversable1_r r t | t -> r where
 traverse1_r :: Apply f => (r a -> f (r b)) -> t a -> f (t b)

foldMap1_rDefault :: forall r t m a . (Traversable1_r r t,Semigroup m) => (r a -> m) -> t a -> m
foldMap1_rDefault = coerce (traverse1_r :: (r a -> Const m (r ())) -> t a -> Const m (t ()))
{-# INLINE foldMap1_rDefault #-}

----
-- Foldable_r

class Functor_r r t => Foldable_r r t | t -> r where
 {-# MINIMAL foldMap_r | foldr_r #-}
 foldMap_r :: Monoid m => (r a -> m) -> t a -> m
 {-# INLINE foldMap_r #-}
 foldMap_r f = foldr_r (mappend . f) mempty
 foldr_r :: (r a -> b -> b) -> b -> t a -> b
 foldr_r f z t = appEndo (foldMap_r (Endo . f) t) z

----
-- Traversable_r

class Foldable_r r t => Traversable_r r t | t -> r where
 traverse_r :: (Applicative f) => (r a -> f (r b)) -> t a -> f (t b)

foldMap_rDefault :: forall r t m a . (Traversable_r r t,Monoid m) => (r a -> m) -> t a -> m
foldMap_rDefault = coerce (traverse_r :: (r a -> Const m (r ())) -> t a -> Const m (t ()))
{-# INLINE foldMap_rDefault #-}

fmap_rDefault :: forall r t a b . Traversable_r r t => (r a -> r b) -> t a -> t b
{-# INLINE fmap_rDefault #-}
fmap_rDefault = coerce (traverse_r :: (r a -> Identity (r b)) -> t a -> Identity (t b))