Util.Computation

Documentation

type Answer a = Either SomeException a

done :: Monad m => m ()

(#) :: a -> (a -> b) -> b

exceptions and handlers

propagate :: Answer a -> IO a

try :: Exception e => IO a -> IO (Either e a)

Similar to catch, but returns an Either result which is (Right a) if no exception of type e was raised, or (Left ex) if an exception of type e was raised and its value is ex. If any other type of exception is raised than it will be propogated up to the next enclosing exception handler.

  try a = catch (Right `liftM` a) (return . Left)

Note that System.IO.Error also exports a function called try with a similar type to try, except that it catches only the IO and user families of exceptions (as required by the Haskell 98 IO module).

tryUntilOK :: IO a -> IO a

raise :: IOError -> IO a

selectors

when :: Monad m => Bool -> m () -> m ()

Conditional execution of monadic expressions. For example,

       when debug (putStr "Debugging\n")

will output the string Debugging\n if the Boolean value debug is True, and otherwise do nothing.

unless :: Monad m => Bool -> m () -> m ()

The reverse of when.

incase :: Maybe a -> (a -> IO b) -> IO ()

iterators

forever :: Monad m => m a -> m b

forever act repeats the action infinitely.

foreverUntil :: Monad m => m Bool -> m ()

foreach :: Monad m => [a] -> (a -> m b) -> m ()

while :: Monad m => m a -> (a -> Bool) -> m a

configure command

type Config w = w -> IO w

configure :: w -> [Config w] -> IO w

config :: IO () -> Config w

The new-style configuration command

class HasConfig option configuration where

Methods

($$) :: option -> configuration -> configuration

configUsed :: option -> configuration -> Bool

Returning results or error messages.

data WithError a

Instances

Monad WithError

Functor WithError

Applicative WithError

hasError :: String -> WithError a

hasValue :: a -> WithError a

fromWithError :: WithError a -> Either String a

fromWithError1 :: a -> WithError a -> a

toWithError :: Either String a -> WithError a

isError :: WithError a -> Bool

mapWithError :: (a -> b) -> WithError a -> WithError b

mapWithError' :: (a -> WithError b) -> WithError a -> WithError b

mapWithErrorIO :: (a -> IO b) -> WithError a -> IO (WithError b)

mapWithErrorIO' :: (a -> IO (WithError b)) -> WithError a -> IO (WithError b)

pairWithError :: WithError a -> WithError b -> WithError (a, b)

listWithError :: [WithError a] -> WithError [a]

coerceWithError :: WithError a -> a

coerceWithErrorIO :: WithError a -> IO a

coerceWithErrorStringIO :: String -> WithError a -> IO a

coerceWithErrorOrBreakIOPrefix :: String -> (String -> a) -> WithError a -> IO a

coerce or use the supplied break function (to be used with addFallOut)

The first argument is prepended to any error message. The value is evaluated immediately.

coerceWithErrorOrBreakPrefix :: String -> (String -> a) -> WithError a -> a

coerce or use the supplied break function (to be used with addFallOut)

The first argument is prepended to any error message.

newtype MonadWithError m a

Constructors

MonadWithError (m (WithError a))

Instances

Monad m => Monad (MonadWithError m)

Monad m => Functor (MonadWithError m)

Monad m => Applicative (MonadWithError m)

monadifyWithError :: Monad m => WithError a -> MonadWithError m a

toMonadWithError :: Monad m => m a -> MonadWithError m a

coerceWithErrorOrBreak :: (String -> a) -> WithError a -> a

coerce or use the supplied break function (to be used with addFallOut)

coerceWithErrorOrBreakIO :: (String -> a) -> WithError a -> IO a

coerce or use the supplied break function (to be used with addFallOut) The value is evaluated immediately.

concatWithError :: [WithError a] -> WithError [a]

swapIOWithError :: WithError (IO a) -> IO (WithError a)

exceptionToError :: Exception e => (e -> Maybe String) -> IO a -> IO (WithError a)