UnexceptionalIO

When you've caught all the exceptions that can be handled safely, this is what you're left with.

runEitherIO . fromIO ≡ id

It is intended that you use qualified imports with this library.

import UnexceptionalIO (UIO)
import qualified UnexceptionalIO as UIO

Documentation

data UIO a

IO without any PseudoException

Instances

Monad UIO

Methods

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

(>>) :: UIO a -> UIO b -> UIO b

return :: a -> UIO a

fail :: String -> UIO a

Functor UIO

Methods

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

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

MonadFix UIO

Methods

mfix :: (a -> UIO a) -> UIO a

Applicative UIO

Methods

pure :: a -> UIO a

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

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

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

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

Unexceptional UIO

Methods

lift :: UIO a -> UIO a

class Monad m => Unexceptional m where

Polymorphic base without any PseudoException

Minimal complete definition

lift

Methods

lift :: UIO a -> m a

Instances

Unexceptional IO

Methods

lift :: UIO a -> IO a

Unexceptional UIO

Methods

lift :: UIO a -> UIO a

fromIO :: Unexceptional m => IO a -> m (Either SomeNonPseudoException a)

Catch any exception but PseudoException in an IO action

run :: UIO a -> IO a

Re-embed UIO into IO

runEitherIO :: Exception e => UIO (Either e a) -> IO a

Re-embed UIO and possible exception back into IO

Unsafe entry points

fromIO' :: (Exception e, Unexceptional m) => IO a -> m (Either e a)

You promise that e covers all exceptions but PseudoException thrown by this IO action

This function is partial if you lie

unsafeFromIO :: Unexceptional m => IO a -> m a

You promise there are no exceptions but PseudoException thrown by this IO action

Pseudo exceptions

data SomeNonPseudoException

Every SomeException but PseudoException

Instances

Show SomeNonPseudoException

Methods

showsPrec :: Int -> SomeNonPseudoException -> ShowS

show :: SomeNonPseudoException -> String

showList :: [SomeNonPseudoException] -> ShowS

Exception SomeNonPseudoException

Methods

toException :: SomeNonPseudoException -> SomeException

fromException :: SomeException -> Maybe SomeNonPseudoException

displayException :: SomeNonPseudoException -> String

data PseudoException

Not everything handled by the exception system is a run-time error you can handle. This is the class of pseudo-exceptions you usually can do nothing about, just log or exit.

Additionally, except for ExitCode any of these psuedo-exceptions you could never guarentee to have caught, since they can come from anywhere at any time, we could never guarentee that UIO does not contain them.

Constructors

ProgrammerError ProgrammerError

Mistakes programmers make

ExternalError ExternalError

Errors thrown by the runtime

Exit ExitCode

Process exit requests

Instances

Show PseudoException

Methods

showsPrec :: Int -> PseudoException -> ShowS

show :: PseudoException -> String

showList :: [PseudoException] -> ShowS

Exception PseudoException

Methods

toException :: PseudoException -> SomeException

fromException :: SomeException -> Maybe PseudoException

displayException :: PseudoException -> String

data ProgrammerError

Pseudo-exceptions caused by a programming error

Partial functions, error, undefined, etc

Constructors

TypeError TypeError

ArithException ArithException

ArrayException ArrayException

AssertionFailed AssertionFailed

ErrorCall ErrorCall

NestedAtomically NestedAtomically

NoMethodError NoMethodError

PatternMatchFail PatternMatchFail

RecConError RecConError

RecSelError RecSelError

RecUpdError RecSelError

Instances

Show ProgrammerError

Methods

showsPrec :: Int -> ProgrammerError -> ShowS

show :: ProgrammerError -> String

showList :: [ProgrammerError] -> ShowS

Exception ProgrammerError

Methods

toException :: ProgrammerError -> SomeException

fromException :: SomeException -> Maybe ProgrammerError

displayException :: ProgrammerError -> String

data ExternalError

Pseudo-exceptions thrown by the runtime environment

Constructors

CompactionFailed CompactionFailed

AsyncException SomeAsyncException

BlockedIndefinitelyOnSTM BlockedIndefinitelyOnSTM

BlockedIndefinitelyOnMVar BlockedIndefinitelyOnMVar

Deadlock Deadlock

NonTermination NonTermination

Instances

Show ExternalError

Methods

showsPrec :: Int -> ExternalError -> ShowS

show :: ExternalError -> String

showList :: [ExternalError] -> ShowS

Exception ExternalError

Methods

toException :: ExternalError -> SomeException

fromException :: SomeException -> Maybe ExternalError

displayException :: ExternalError -> String

Pseudo exception helpers

bracket :: Unexceptional m => UIO a -> (a -> UIO ()) -> (a -> UIO c) -> m c

When you're doing resource handling, PseudoException matters. You still need to use the bracket pattern to handle cleanup.

forkFinally :: Unexceptional m => UIO a -> (Either PseudoException a -> UIO ()) -> m ThreadId

Mirrors forkFinally, but since the body is UIO, the thread must terminate successfully or because of PseudoException

fork :: Unexceptional m => UIO () -> m ThreadId

Mirrors forkIO, but re-throws any PseudoException to the parent thread