Alternative IO error for <|>

Question

I am using the operator <|> for:

import qualified Data.ByteString.Lazy as B
import Network.HTTP.Conduit (simpleHttp)
import Data.Aeson
import Data.Maybe

data FooBar = FooBar {
    name :: !Text,
    surname :: !Text
    } deriving (Show,Generic)

instance FromJSON FooBar
instance ToJSON FooBar

getFeed :: String -> String -> IO (FooBar)
getFeed foo bar =  decode <$> (B.readFile foo <|> simpleHttp bar)

But when I try to compile it I get:

No instance for (Alternative IO) arising from a use of ‘<|>’
    In the second argument of ‘(<$>)’, namely
      ‘(B.readFile foo <|> simpleHttp bar)’
    In the expression:
      decode <$> (B.readFile foo <|> simpleHttp bar)
    In an equation for ‘getFeed’:
        getFeed env id
          = decode <$> (B.readFile foo <|> simpleHttp bar)

The error is a bit obscure to me. Any idea how to fix that? (BTW some insight from this reply: Confused by the meaning of the 'Alternative' type class and its relationship to other type classes)

Answer 1

Besides your actual problem, here's why IO can't be an Alternative.

First, what would you do for empty? It will need to have type forall a. IO a - an IO action that returns any type of value!

Second, how do you define failure (used for <|>)? For types such as Maybe, empty is obvious (Nothing) and failure can be defined as Nothing as well. So if the first argument is Nothing, return the second. But what about IO? The (confused) notion of failure on monads is magical and not represented at the type level, in other words, there is no explicit failure value.

It could work if you wrapped all your IO actions in Maybe (or Either) so that for example, readFile' :: FilePath -> IO (Maybe String). Then by lifting <|> you could combine actions. You would have to catch failures (exceptions) and translate them to Nothing in your wrapper.

(For convenience one could make an instance of Alternative for all Alternative f, Monad m => m f but that requires type composition? I'm not sure)

Answer 2

The error just says that IO is not an instance of Alternative and so <|> is not defined for it, as you can see from documentation. Is your intended meaning "try B.readFile foo and if it fails, use simpleHttp bar instead"? If so, you can do

catch (B.readFile foo) (\(_ :: SomeException) -> simpleHttp bar)

(catch is from Control.Exception, and you should use Data.ByteString.Strict instead of Lazy to make sure exception gets thrown inside the scope of catch; you'll also need ScopedTypeVariables extension to write the above instead of something like \e -> let _ = e :: SomeException in simpleHttp bar).

Answer 3

Here is an example of what you can do based on the blog post Playing Catch: Handling IO Exceptions with ErrorT.

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module Lib where

import qualified Data.ByteString.Lazy as B
import Network.HTTP.Conduit (simpleHttp)
import Control.Monad.Base
import Control.Applicative
import Control.Monad.Error
import System.IO.Error

newtype MyApp a = MyApp {
  getApp :: ErrorT String IO a
  } deriving (Functor, Applicative, Alternative, Monad, MonadIO, MonadError String, MonadBase IO)

myReadFile path = do
  r <- liftIO $ tryIOError $ B.readFile path 
  case r of
    Left e  -> throwError (strMsg "readFile error")
    Right x -> return x

mySimpleHttp bar = do
  r <- liftIO $ tryIOError $ simpleHttp bar
  case r of
    Left e -> throwError (strMsg "simpleHttp error")
    Right x -> return x

getFeed foo bar =  myReadFile foo <|> mySimpleHttp bar

runApp = runErrorT . getApp

doit = do result <- runApp $ getFeed "some/file.txt" "http://example.com/"
          case result of
            Left e  -> putStrLn $ "error: " ++ e
            Right r -> do putStrLn $ "got a result"; print r

I've been very explicit in this example - the article mentions ways you can reduce the amount of boiler-plate code.

My cabal build-depends: setting:

build-depends: base >= 4.7 && < 5, bytestring, mtl, http-conduit, transformers-base