neither 0.1.0 → 0.2.0

raw patch · 3 files changed

+11/−138 lines, 3 filesdep +monad-peelPVP ok

version bump matches the API change (PVP)

Dependencies added: monad-peel

API changes (from Hackage documentation)

Files

• Control/Monad/Invert.hs +0/−128
• Data/Neither.hs +8/−7
• neither.cabal +3/−3

@@ -1,128 +0,0 @@-{-# LANGUAGE TypeFamilies #-}-module Control.Monad.Invert-    ( -- * Typeclass-      MonadInvertIO (..)-      -- * Exceptions-    , finally-    , catch-    , block-    , unblock-    , bracket-    , bracket_-    , onException-      -- * Memory allocation-    , alloca-    , allocaBytes-    , withForeignPtr-    ) where--import Prelude hiding (catch)-import Control.Monad.Trans.Identity-import Control.Monad.Trans.Reader-import Control.Monad.Trans.Writer-import Control.Monad.Trans.Error-import Control.Monad.Trans.State-import Control.Monad (liftM)-import qualified Control.Exception as E-import Data.Monoid (Monoid)-import qualified Foreign.Marshal.Alloc as A-import Foreign.Storable (Storable)-import Foreign.Ptr (Ptr)-import Foreign.ForeignPtr (ForeignPtr)-import qualified Foreign.ForeignPtr as F-import Control.Monad.IO.Class (MonadIO)--class MonadIO m => MonadInvertIO m where-    data InvertedIO m :: * -> *-    type InvertedArg m-    invertIO :: m a -> InvertedArg m -> IO (InvertedIO m a)-    revertIO :: (InvertedArg m -> IO (InvertedIO m a)) -> m a--instance MonadInvertIO m => MonadInvertIO (IdentityT m) where-    newtype InvertedIO (IdentityT m) a =-        InvIdentIO { runInvIdentIO :: InvertedIO m a }-    type InvertedArg (IdentityT m) = InvertedArg m-    invertIO = liftM (fmap InvIdentIO) . invertIO . runIdentityT-    revertIO f = IdentityT $ revertIO $ liftM runInvIdentIO . f--instance (Error e, MonadInvertIO m) => MonadInvertIO (ErrorT e m) where-    newtype InvertedIO (ErrorT e m) a =-        InvErrorIO { runInvErrorIO :: InvertedIO m (Either e a) }-    type InvertedArg (ErrorT e m) = InvertedArg m-    invertIO = liftM (fmap InvErrorIO) . invertIO . runErrorT-    revertIO f = ErrorT $ revertIO $ liftM runInvErrorIO . f--instance MonadInvertIO m => MonadInvertIO (ReaderT r m) where-    newtype InvertedIO (ReaderT r m) a =-        InvReaderIO { runInvReaderIO :: InvertedIO m a }-    type InvertedArg (ReaderT r m) = (r, InvertedArg m)-    invertIO (ReaderT f) (r, arg) = liftM InvReaderIO $ invertIO (f r) arg-    revertIO f = ReaderT $ \r -> revertIO (\a -> liftM runInvReaderIO (f (r, a)))--instance (Monoid w, MonadInvertIO m) => MonadInvertIO (WriterT w m) where-    newtype InvertedIO (WriterT w m) a =-        InvWriterIO { runInvWriterIO :: InvertedIO m (a, w) }-    type InvertedArg (WriterT w m) = InvertedArg m-    invertIO = liftM (fmap InvWriterIO) . invertIO . runWriterT-    revertIO f = WriterT $ revertIO $ liftM runInvWriterIO . f--instance MonadInvertIO m => MonadInvertIO (StateT s m) where-    newtype InvertedIO (StateT s m) a =-        InvStateIO { runInvStateIO :: InvertedIO m (a, s) }-    type InvertedArg (StateT s m) = (s, InvertedArg m)-    invertIO (StateT f) (r, arg) = liftM InvStateIO $ invertIO (f r) arg-    revertIO f = StateT $ \r -> revertIO (\a -> liftM runInvStateIO (f (r, a)))--instance MonadInvertIO IO where-    newtype InvertedIO IO a = InvIO { runInvIO :: a }-    type InvertedArg IO = ()-    invertIO = const . liftM InvIO-    revertIO = liftM runInvIO . ($ ())--finally :: MonadInvertIO m => m a -> m b -> m a-finally action after =-    revertIO $ \a -> invertIO action a `E.finally` invertIO after a--onException :: MonadInvertIO m => m a -> m b -> m a-onException action after =-    revertIO $ \a -> invertIO action a `E.onException` invertIO after a--catch :: (E.Exception e, MonadInvertIO m) => m a -> (e -> m a) -> m a-catch action handler =-    revertIO $ \a -> invertIO action a `E.catch` (\e -> invertIO (handler e) a)--block :: MonadInvertIO m => m a -> m a-block action = revertIO $ \a -> E.block $ invertIO action a--unblock :: MonadInvertIO m => m a -> m a-unblock action = revertIO $ \a -> E.unblock $ invertIO action a---- | There is a very important distinction between this function and--- 'bracket_': in this version, the monadic side effects from the--- initialization function and kept, while in bracket_ they are discarded.-bracket :: MonadInvertIO m-        => m a-        -> (a -> m b)-        -> (a -> m c)-        -> m c-bracket acquire cleanup action = revertIO $ \a -> E.bracket-    (invertIO acquire a)-    (\x -> invertIO (revertIO (const $ return x) >>= cleanup) a)-    (\x -> invertIO (revertIO (const $ return x) >>= action) a)---- | See 'bracket'.-bracket_ :: MonadInvertIO m => m a -> m b -> m c -> m c-bracket_ acquire cleanup action = revertIO $ \a -> E.bracket_-    (invertIO acquire a)-    (invertIO cleanup a)-    (invertIO action a)--alloca :: (Storable a, MonadInvertIO m) => (Ptr a -> m b) -> m b-alloca f = revertIO $ \x -> A.alloca $ flip invertIO x . f--allocaBytes :: MonadInvertIO m => Int -> (Ptr a -> m b) -> m b-allocaBytes i f = revertIO $ \x -> A.allocaBytes i $ flip invertIO x . f--withForeignPtr :: MonadInvertIO m => ForeignPtr a -> (Ptr a -> m b) -> m b-withForeignPtr p f =-    revertIO $ \x -> F.withForeignPtr p $ flip invertIO x . f

@@ -42,8 +42,9 @@ import Data.Typeable import Data.Data import Control.Monad.IO.Class+import Control.Monad.IO.Peel import Control.Monad.Trans.Class-import Control.Monad.Invert+import Control.Monad.Trans.Peel  class Neither e where   left :: a -> e a b@@ -142,9 +143,9 @@ instance MonadIO m => MonadIO (MEitherT e m) where     liftIO = lift . liftIO -instance MonadInvertIO m => MonadInvertIO (MEitherT e m) where-    newtype InvertedIO (MEitherT e m) a =-        InvErrorIO { runInvErrorIO :: InvertedIO m (MEither e a) }-    type InvertedArg (MEitherT e m) = InvertedArg m-    invertIO = liftM (fmap InvErrorIO) . invertIO . runMEitherT-    revertIO f = MEitherT $ revertIO $ liftM runInvErrorIO . f+instance MonadTransPeel (MEitherT e) where+  peel = return $ \m -> do+    xe <- runMEitherT m+    return $ either throwMEither return xe+instance MonadPeelIO m => MonadPeelIO (MEitherT e m) where+  peelIO = liftPeel peelIO

@@ -1,5 +1,5 @@ name:            neither-version:         0.1.0+version:         0.2.0 license:         BSD3 license-file:    LICENSE author:          Michael Snoyman <michael@snoyman.com>@@ -20,9 +20,9 @@ library     build-depends:   base >= 4 && < 5,                      transformers >= 0.2.1 && < 0.3,-                     failure >= 0.1.0 && < 0.2+                     failure >= 0.1.0 && < 0.2,+                     monad-peel >= 0.1 && < 0.2     exposed-modules: Data.Neither-                     Control.Monad.Invert     ghc-options:     -Wall  source-repository head