{- |
Provide the explicit class dictionary as context via a Reader monad.
-}
module Network.Monad.Reader where

import qualified Network.Monad.Transfer as Transfer

import qualified Network.Stream as Stream
import Control.Monad.Trans.Reader (ReaderT, asks, )
import Control.Monad.Trans.Class (lift, )

import qualified Control.Monad.Exception.Asynchronous as Async
import qualified Control.Monad.Exception.Synchronous  as Sync



type T body m = ReaderT (Transfer.T m body) m

type SyncExceptional body m =
   Sync.ExceptionalT Stream.ConnError (T body m)

type AsyncExceptional body m =
   Async.ExceptionalT Stream.ConnError (T body m)


{-# INLINE readLine #-}
readLine :: (Monad m) => AsyncExceptional body m body
readLine :: forall (m :: * -> *) body. Monad m => AsyncExceptional body m body
readLine =
   forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
Async.ExceptionalT forall a b. (a -> b) -> a -> b
$
   do AsyncExceptional m body
action <- forall (m :: * -> *) r a. Monad m => (r -> a) -> ReaderT r m a
asks forall (m :: * -> *) body. T m body -> AsyncExceptional m body
Transfer.readLine
      forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
Async.runExceptionalT AsyncExceptional m body
action

{-# INLINE readBlock #-}
readBlock :: (Monad m) => Int -> AsyncExceptional body m body
readBlock :: forall (m :: * -> *) body.
Monad m =>
Int -> AsyncExceptional body m body
readBlock Int
n =
   forall e (m :: * -> *) a. m (Exceptional e a) -> ExceptionalT e m a
Async.ExceptionalT forall a b. (a -> b) -> a -> b
$
   do Int -> AsyncExceptional m body
action <- forall (m :: * -> *) r a. Monad m => (r -> a) -> ReaderT r m a
asks forall (m :: * -> *) body.
T m body -> Int -> AsyncExceptional m body
Transfer.readBlock
      forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall e (m :: * -> *) a. ExceptionalT e m a -> m (Exceptional e a)
Async.runExceptionalT forall a b. (a -> b) -> a -> b
$ Int -> AsyncExceptional m body
action Int
n

{-# INLINE writeBlock #-}
writeBlock :: (Monad m) => body -> SyncExceptional body m ()
writeBlock :: forall (m :: * -> *) body.
Monad m =>
body -> SyncExceptional body m ()
writeBlock body
body =
   do body -> SyncExceptional m ()
action <- forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) r a. Monad m => (r -> a) -> ReaderT r m a
asks forall (m :: * -> *) body. T m body -> body -> SyncExceptional m ()
Transfer.writeBlock
      forall (m :: * -> *) e0 a (n :: * -> *) e1 b.
(m (Exceptional e0 a) -> n (Exceptional e1 b))
-> ExceptionalT e0 m a -> ExceptionalT e1 n b
Sync.mapExceptionalT forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall a b. (a -> b) -> a -> b
$ body -> SyncExceptional m ()
action body
body