Revision d5868411 src/Ganeti/BasicTypes.hs

b/src/Ganeti/BasicTypes.hs
1
{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses #-}
1
{-# LANGUAGE FlexibleInstances #-}
2
{-# LANGUAGE FlexibleContexts #-}
3
{-# LANGUAGE MultiParamTypeClasses #-}
4
{-# LANGUAGE TypeFamilies #-}
2 5

  
3 6
{-
4 7

  
......
58 61
import Control.Applicative
59 62
import Control.Exception (try)
60 63
import Control.Monad
64
import Control.Monad.Base
61 65
import Control.Monad.Error.Class
62 66
import Control.Monad.Trans
67
import Control.Monad.Trans.Control
63 68
import Data.Function
64 69
import Data.List
65 70
import Data.Maybe
......
171 176
                   . liftM (either (failError . show) return)
172 177
                   . (try :: IO a -> IO (Either IOError a))
173 178

  
179
instance (MonadBase IO m, Error a) => MonadBase IO (ResultT a m) where
180
  liftBase = ResultT . liftBase
181
                   . liftM (either (failError . show) return)
182
                   . (try :: IO a -> IO (Either IOError a))
183

  
184
instance (Error a) => MonadTransControl (ResultT a) where
185
  newtype StT (ResultT a) b = StResultT { runStResultT :: GenericResult a b }
186
  liftWith f = ResultT . liftM return $ f (liftM StResultT . runResultT)
187
  restoreT = ResultT . liftM runStResultT
188
  {-# INLINE liftWith #-}
189
  {-# INLINE restoreT #-}
190

  
191
instance (Error a, MonadBaseControl IO m)
192
         => MonadBaseControl IO (ResultT a m) where
193
  newtype StM (ResultT a m) b
194
    = StMResultT { runStMResultT :: ComposeSt (ResultT a) m b }
195
  liftBaseWith = defaultLiftBaseWith StMResultT
196
  restoreM = defaultRestoreM runStMResultT
197
  {-# INLINE liftBaseWith #-}
198
  {-# INLINE restoreM #-}
199

  
174 200
instance (Monad m, Error a, Monoid a) => MonadPlus (ResultT a m) where
175 201
  mzero = ResultT $ return mzero
176 202
  -- Ensure that 'y' isn't run if 'x' contains a value. This makes it a bit

Also available in: Unified diff