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

Repeat an action indefinitely.

Using ApplicativeDo: 'forever as' can be understood as the pseudo-do expression

do as
   as
   ..

with as repeating.

Examples

A common use of forever is to process input from network sockets, Handles, and channels (e.g. MVar and Chan).

For example, here is how we might implement an echo server, using forever both to listen for client connections on a network socket and to echo client input on client connection handles:

echoServer :: Socket -> IO ()
echoServer socket = forever $ do
  client <- accept socket
  forkFinally (echo client) (\_ -> hClose client)
  where
    echo :: Handle -> IO ()
    echo client = forever $
      hGetLine client >>= hPutStrLn client

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 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

Functor WithError

Defined in Util.Computation

Methods

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

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

MonadFail WithError

Defined in Util.Computation

Methods

fail :: String -> 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

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

MonadFail m => MonadFail (MonadWithError m)

Defined in Util.Computation

Methods

fail :: String -> 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)