Haskell: Hiding failures in lazy IO

Question

This is a noob question.

I'd like to write a function which provides a lazy stream of images, presumably something like:

imageStream :: [IO Image]

Unfortunately, the function which reads images can fail, so it looks like:

readImage :: IO (Maybe Image)

So, the function I can write looks like:

maybeImageStream :: [IO (Maybe Image)]

How do I implement a function such as the following, while still keeping lazy IO?

flattenImageStream :: [IO (Maybe Image)] -> [IO Image]

Semantically, when you ask flattenImageStream for the next image, it should iterate through the list and attempt to read each image. It does this until it finds an image that loads, and returns it.

EDIT: There seems to be some disagreement in the answers. Some have suggested solutions that use sequence, but I'm pretty sure I tested that and found it destroys laziness. (I'll test it again to be sure when I get back to my computer.) Someone also suggested using unsafeInterleaveIO. From the documentation for that function, it seems it would work, but obviously I want to respect the type system as much as possible.

Answer 1

You can use ListT from pipes, which provides a safer alternative to lazy IO that does the right thing in this case.

The way you model your lazy stream of potentially failing images is:

imageStream :: ListT IO (Maybe Image)

Assuming that you had some image loading function of type:

loadImage :: FileName -> IO (Maybe Image)

.. then the way you build such a stream would be something like:

imageStream = do
    fileName <- Select $ each ["file1.jpg", "file2.jpg", "file3.jpg"]
    lift $ loadImage fileName

If you use the dirstream library, then you can even lazily stream over the directory contents, too.

The function that filters out only the successful results would have this type:

flattenImageStream :: (Monad m) => ListT m (Maybe a) -> ListT m a
flattenImageStream stream = do
    ma <- stream
    case ma of
        Just a  -> return a
        Nothing -> mzero

Notice that this function works for any base monad, m. There is nothing IO-specific about it. It also preserves laziness!

Applying flattenImage to imageStream, gives us something of type:

finalStream :: List IO Image
finalStream = flattenImage imageStream

Now let's say that you have some function that consumes these images, of type:

useImage :: Image -> IO ()

If you want to process the final ListT using the useImage function, you just write:

main = runEffect $
    for (every finalStream) $ \image -> do
        lift $ useImage image

That will then lazily consume the image stream.

Of course, you could also play code golf and combine all of that into the following much shorter version:

main = runEffect $ for (every image) (lift . useImage)
  where
    image = do
        fileName   <- Select $ each ["file1.jpg", "file2.jpg", "file3.jpg"]
        maybeImage <- lift $ loadImage fileName           
        case maybeImage of
            Just img -> return img
            Nothing  -> mzero

I'm also thinking of adding a fail definition for ListT so that you could just write:

main = runEffect $ for (every image) (lift . useImage)
  where
    image = do
        fileName <- Select $ each ["file1.jpg", "file2.jpg", "file3.jpg"]
        Just img <- lift $ loadImage fileName           
        return img

Answer 2

as suggested u can turn [m a] into m [a] using sequence

so you get:

imageStream :: IO [Image]

then you can use cayMaybes from Data.Maybe to keep just the Just values:

catMaybes `liftM` imageStream