ChasingBottoms-1.3.1.9: For testing partial and infinite values.

Copyright | (c) Nils Anders Danielsson 2004-2020
License | See the file LICENCE.
Maintainer | http://www.cse.chalmers.se/~nad/
Stability | experimental
Portability | non-portable (preemptive scheduling)
Safe Haskell | Safe
Language | Haskell2010

Test.ChasingBottoms.TimeOut

Description

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

Synopsis

- data Result a
  - = Value a
  - | NonTermination
  - | Exception SomeException
- timeOut :: Int -> IO a -> IO (Result a)
- timeOut' :: Int -> a -> IO (Result a)
- timeOutMicro :: Int -> IO a -> IO (Result a)
- timeOutMicro' :: Int -> a -> IO (Result a)

# Documentation

data Result a Source #

Constructors

Value a |
NonTermination |
Exception SomeException |

#### Instances

Instances details

Show a => Show (Result a) Source # |
Instance details Defined in Test.ChasingBottoms.TimeOut Methods showsPrec :: Int -> Result a -> ShowS show :: Result a -> String showList :: [Result a] -> ShowS

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

``timeOut` n c` runs `c` for at most `n` seconds (modulo scheduling issues).

- If the computation terminates before that, then ``Value` v` is returned, where `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 ``Exception` e` is returned, where `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 ``timeOut'` 1 `bottom`` usually returns ``Exception` <something>`. (``timeOut` 1 (`return` `bottom`)` usually returns ``Value` `bottom``; in other words, the computation reaches whnf almost immediately, defeating the purpose of the time-out.)

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