On Sunday 25 September 2011, 00:27:54, Ovidiu Deac wrote:
> Thanks a lot! It took me a while to understand what you meant but
> eventually I got it.
>> This is the final version and it looks much better:
>> f :: MyMonad String
> f = do
> liftIO $ putStrLn "Please enter a file name: "
> name ← liftIO getLine
> hFile ← ErrorT $ (openFile name ReadMode ↠ return.Right)
> `catch` λ_ → return.Left $ KnownErr "open failed"
Note that
action >>= return . function
is
liftM function action
(and ought to be the same as `fmap function action' if the Monad has a
Functor instance).
It's mostly a matter of taste, but I prefer the fmap/liftM version (and
fmap can be more efficient).
> content ← liftIO $ hGetContents hFile
> return content
These two lines can be replaced by the shorter
liftIO $ hGetContents hFile
By desugaring and the Monad laws,
do value <- action
return value
~> (desugaring)
action >>= \value -> return value === action >>= return === action
(the first === is eta-reduction (\value -> return value) === return, the
second is a Monad law - I don't remember the canonical numbering, but the
Monad laws are
return x >>= f === f x
action >>= return === action
(action >>= g) >>= h === action >>= (\x -> h x >>= g)
)
>> Somehow I understand but I don't have the feeling yet why I apply
> ErrorT to the whole catched expression instead of liftIO. Do you have
> a nice explanation for it?
Hm, not sure whether I can come up with something nice.
Let's look at the types.
newtype ErrorT e m a = ErrorT { runErrorT :: m (Either e a) }
Thus, in your case, the value constructor ErrorT is a function with type
ErrorT :: IO (Either MyType a) -> MyMonad a
On the other hand, again specialised to your situation,
liftIO :: IO a -> MyMonad a
liftIO lifts any IO-action (which in general has no knowledge of MyType) to
a MyMonad-action. That lifting consists of two steps, first the IO-action
is transformed into an IO-action with return type (Either MyType a), then
that is wrapped in ErrorT.
In particular,
liftIO action = ErrorT $ do { x <- action; return (Right x); }
or, by the definition of liftM,
liftIO action = ErrorT (liftM Right action)
pointfree:
liftIO = ErrorT . liftM Right -- [1]
The first part of that, adding the (Either MyType), is done in the catch,
so after the catch, only the second half of liftIO remains to be done,
applying the value constructor ErrorT.
[1] In particular, liftIO cannot produce any actions that fail in the
(ErrorT e IO) monad, and IO-failures cannot be caught or handled there.
To handle IO-failures in (ErrorT e IO), you need a construct as above, it
could have the general form
catchIO :: IO a -> (IOError -> e) -> ErrorT e IO a
catchIO action trans =
ErrorT $ liftM Right action `catch` (\err -> return (Left $ trans err))
or
ErrorT $ liftM Right action `catch` (return . Left . trans)
if you use Prelude.catch, with Control.Exception.catch, the type would be
catchIO :: Exception ex => IO a -> (ex -> e) -> ErrorT a IO a
with the same implementation.
With that, the line above would become
hFile <- openFile name ReadMode `catchIO` const (KnownErr "open failed")
But that is rather limited, it would often be desirable to do some IO
immediately upon encountering the error, and maybe one can even completely
recover from the error, so a more useful type would be
liftCatchIO :: Exception ex =>
IO a -> (ex -> IO (Either e a)) -> ErrorT e IO a
liftCatchIO action handler = ErrorT $ liftM Right action `catch` handler
and the above
hFile <- liftCatchIO (openFile name ReadMode)
(\_ -> return (Left $ KnownErr "open failed"))