Portability | non-portable (preemptive scheduling) |
---|---|

Stability | experimental |

Maintainer | http://www.cse.chalmers.se/~nad/ |

Safe Haskell | Safe-Infered |

When dealing with "hard bottoms", i.e. non-terminating computations that do not result in exceptions, the following functions may be handy.

Note that a computation is considered to have terminated when it has reached weak head normal form (i.e. something distinct from bottom).

# Documentation

timeOut :: Int -> IO a -> IO (Result a)Source

runs `timeOut`

n c`c`

for at most `n`

seconds (modulo
scheduling issues).

- If the computation terminates before that, then

is returned, where`Value`

v`v`

is the resulting value. Note that this value may be equal to bottom, e.g. if`c =`

.`return`

`bottom`

- If the computation does not terminate, then
`NonTermination`

is returned. - If the computation raises an exception, then

is returned, where`Exception`

e`e`

is the exception.

Note that a user-defined exception is used to terminate the
computation, so if `c`

catches all exceptions, or blocks
asynchronous exceptions, then `timeOut`

may fail to function
properly.

timeOut' :: Int -> a -> IO (Result a)Source

`timeOut'`

is a variant which can be used for pure
computations. The definition,

`timeOut'`

n =`timeOut`

n .`evaluate`

ensures that

usually returns `timeOut'`

1 `bottom`

. (`Exception`

<something>

usually
returns `timeOut`

1 (`return`

`bottom`

)

; in other words, the computation
reaches whnf almost immediately, defeating the purpose of the
time-out.)
`Value`

`bottom`

timeOutMicro :: Int -> IO a -> IO (Result a)Source

`timeOutMicro`

takes a delay in microseconds. Note that the
resolution is not necessarily very high (the last time I checked it
was 0.02 seconds when using the standard runtime system settings
for GHC).

timeOutMicro' :: Int -> a -> IO (Result a)Source

`timeOutMicro'`

is the equivalent variant of `timeOutMicro`

:

`timeOutMicro'`

n =`timeOutMicro`

n .`evaluate`