{- |
Module      :  Network.Monad.Class
Copyright   :  (c) Henning Thielemann, 2009
License     :  BSD

Maintainer  :  http@henning-thielemann.de
Stability   :  experimental
Portability :  non-portable (not tested)


With this monad we abstract from the IO monad,
which also allows us to process data lazily or offline.
-}

{- How to use ByteString:
http://nominolo.blogspot.com/2007/05/networkhttp-bytestrings.html
-}
module Network.Monad.Transfer where

import qualified Network.Stream as Stream
import Control.Monad.IO.Class (MonadIO(liftIO), )

import qualified Control.Monad.Exception.Asynchronous as Async
import qualified Control.Monad.Exception.Synchronous  as Sync
import Control.Applicative (WrappedMonad(WrapMonad), unwrapMonad, )

import Data.Monoid (Monoid, )



type SyncExceptional m =
        Sync.ExceptionalT Stream.ConnError m

type AsyncExceptional m =
        Async.ExceptionalT Stream.ConnError m

data T m body =
   Cons {
      forall (m :: * -> *) body. T m body -> AsyncExceptional m body
readLine   :: AsyncExceptional m body,
      forall (m :: * -> *) body.
T m body -> Int -> AsyncExceptional m body
readBlock  :: Int -> AsyncExceptional m body,
      forall (m :: * -> *) body. T m body -> body -> SyncExceptional m ()
writeBlock :: body -> SyncExceptional m ()
   }


liftSync :: Monad m =>
   m (Stream.Result a) -> SyncExceptional m a
liftSync :: forall (m :: * -> *) a.
Monad m =>
m (Result a) -> SyncExceptional m a
liftSync = forall (m :: * -> *) e a.
Monad m =>
m (Either e a) -> ExceptionalT e m a
Sync.fromEitherT

liftAsync :: (Monad m, Monoid a) =>
   m (Stream.Result a) -> AsyncExceptional m a
liftAsync :: forall (m :: * -> *) a.
(Monad m, Monoid a) =>
m (Result a) -> AsyncExceptional m a
liftAsync =
   forall (m :: * -> *) e0 a (n :: * -> *) e1 b.
(m (Exceptional e0 a) -> n (Exceptional e1 b))
-> ExceptionalT e0 m a -> ExceptionalT e1 n b
Async.mapExceptionalT forall (m :: * -> *) a. WrappedMonad m a -> m a
unwrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall (m :: * -> *) a e.
(Functor m, Monoid a) =>
ExceptionalT e m a -> ExceptionalT e m a
Async.fromSynchronousMonoidT forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   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 (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   forall (m :: * -> *) a.
Monad m =>
m (Result a) -> SyncExceptional m a
liftSync


liftIOSync :: MonadIO io =>
   IO (Stream.Result a) -> SyncExceptional io a
liftIOSync :: forall (io :: * -> *) a.
MonadIO io =>
IO (Result a) -> SyncExceptional io a
liftIOSync = forall (m :: * -> *) a.
Monad m =>
m (Result a) -> SyncExceptional m a
liftSync forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO

liftIOAsync :: (MonadIO io, Monoid a) =>
   IO (Stream.Result a) -> AsyncExceptional io a
liftIOAsync :: forall (io :: * -> *) a.
(MonadIO io, Monoid a) =>
IO (Result a) -> AsyncExceptional io a
liftIOAsync = forall (m :: * -> *) a.
(Monad m, Monoid a) =>
m (Result a) -> AsyncExceptional m a
liftAsync forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO
{-
liftIOAsync =
   Async.ExceptionalT .
   liftM (Async.fromSynchronous mempty) .
   Sync.runExceptionalT .
   liftIOSync
-}
--   Async.fromSynchronousMonoidT . liftIOSync