result 0.2.2.0 → 0.2.3.0

raw patch · 2 files changed

+66/−2 lines, 2 filesdep +mtldep +transformersPVP ok

version bump matches the API change (PVP)

Dependencies added: mtl, transformers

API changes (from Hackage documentation)

Files

• result.cabal +5/−2
• src/Control/Monad/Trans/Result.hs +61/−0

@@ -1,5 +1,5 @@ name:                result-version:             0.2.2.0+version:             0.2.3.0 synopsis:            Encode success or at least one error homepage:            https://github.com/srijs/haskell-result license:             MIT@@ -14,10 +14,13 @@  library   hs-source-dirs:      src-  exposed-modules:     Data.Result+  exposed-modules:     Data.Result,+                       Control.Monad.Trans.Result   build-depends:       base >= 4 && < 5,                        bifunctors,+                       mtl,                        semigroups,+                       transformers,                        keys   default-language:    Haskell2010 

@@ -0,0 +1,61 @@+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}++module Control.Monad.Trans.Result+  ( ResultT, runResultT+  , raiseT, accumulateT+  ) where+++import Control.Applicative (liftA2)+import Control.Monad (join)+import Control.Monad.Trans.Class+import qualified Control.Monad.State.Class as State++import Data.Functor.Identity+import Data.Result+++data ResultT e m a = ResultT { runResultT :: m (Result e a) }+++instance Functor f => Functor (ResultT e f) where+  fmap f (ResultT m) =+    ResultT (fmap (fmap f) m)+++instance Applicative f => Applicative (ResultT e f) where+  pure a =+    ResultT (pure (pure a))++  (ResultT mf) <*> (ResultT ma) =+    ResultT $+      liftA2 (<*>) mf ma+++instance Monad m => Monad (ResultT e m) where+  return =+    pure++  (ResultT m) >>= f =+    ResultT $+      m >>= fmap join . traverse (runResultT . f)+++instance MonadTrans (ResultT e) where+  lift m =+    ResultT (pure <$> m)+++raiseT :: Applicative f => e -> ResultT e f a+raiseT e =+  ResultT (pure (raise e))+++accumulateT :: (Traversable t , Applicative f) => t (ResultT e f a) -> ResultT e f (t a)+accumulateT results =+  ResultT (accumulate <$> traverse runResultT results)+++instance State.MonadState s m => State.MonadState s (ResultT e m) where+  state f =+    ResultT (pure <$> State.state f)