Util.Computation

Documentation

type Answer a = Either SomeException a

done :: Monad m => m ()

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

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)

tryUntilOK :: IO a -> IO a

raise :: IOError -> IO a

selectors

when :: Applicative f => Bool -> f () -> f ()

Conditional execution of Applicative expressions. For example,

when debug (putStrLn "Debugging")

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

unless :: Applicative f => Bool -> f () -> f ()

The reverse of when.

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

iterators

forever :: Applicative f => f a -> f 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

Minimal complete definition

($$), configUsed

Methods

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

configUsed :: option -> configuration -> Bool

Returning results or error messages.

data WithError a

Instances

Monad WithError

Defined in Util.Computation

Methods

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

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

return :: a -> WithError a

fail :: String -> WithError a

Functor WithError

Defined in Util.Computation

Methods

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

(<$) :: a -> WithError b -> WithError a

Applicative WithError

Defined in Util.Computation

Methods

pure :: a -> WithError a

(<*>) :: WithError (a -> b) -> WithError a -> WithError b

liftA2 :: (a -> b -> c) -> WithError a -> WithError b -> WithError c

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

(<*) :: WithError a -> WithError b -> WithError a

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)

Defined in Util.Computation

Methods

(>>=) :: MonadWithError m a -> (a -> MonadWithError m b) -> MonadWithError m b

(>>) :: MonadWithError m a -> MonadWithError m b -> MonadWithError m b

return :: a -> MonadWithError m a

fail :: String -> MonadWithError m a

Monad m => Functor (MonadWithError m)

Defined in Util.Computation

Methods

fmap :: (a -> b) -> MonadWithError m a -> MonadWithError m b

(<$) :: a -> MonadWithError m b -> MonadWithError m a

Monad m => Applicative (MonadWithError m)

Defined in Util.Computation

Methods

pure :: a -> MonadWithError m a

(<*>) :: MonadWithError m (a -> b) -> MonadWithError m a -> MonadWithError m b

liftA2 :: (a -> b -> c) -> MonadWithError m a -> MonadWithError m b -> MonadWithError m c

(*>) :: MonadWithError m a -> MonadWithError m b -> MonadWithError m b

(<*) :: MonadWithError m a -> MonadWithError m b -> MonadWithError m a

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)