Popularity
4.4
Declining
Activity
0.0
Stable
4
4
0

Tags: Concurrency     Timeout

timeout-with-results alternatives and similar packages

Based on the "timeout" category.
Alternatively, view timeout-with-results alternatives based on common mentions on social networks and blogs.

• timeout

Generalized sleep and timeout functions
• timeout-control

Updatable timeouts as a Monad transformer

Do you think we are missing an alternative of timeout-with-results or a related project?

timeout-with-results

A Haskell library that allows timeouting a computation while allowing it to return partial results. Useful for AI-like algorithms that should return the best result found within a time limit.

It comes in two variants:

1. Simple, which only allows computations to save partial results, not retrieve what has been written already. If a computation times out, the last saved partial result is returned. It comes in two flavours: One that converts saved values to WHNF, the other to NF. (This is required so that the producing thread performs the computations, not the consuming thread.)
2. Based on MonadWriter. The types of partial results have to be monoids. Saving a partial result combines it with the saved value using `mappend`. It also adds the ability to run a contained computation within another one, without disturbing its output.

Examples

Computing pairs of prime twins

``````{-# LANGUAGE FlexibleContexts #-}
import Data.Numbers.Primes -- package 'primes'
import System.Timeout.Returning

-- | Loop forever, computing prime twins.
primeTwins :: MonadTimeout (Integer, Integer) m => [Integer] -> m (Maybe (Integer,Integer))
primeTwins (p : [email protected](p' : _))
| p' == p + 2   = partialResult (p, p') >> primeTwins ps
| otherwise     = primeTwins ps

-- | Print the largest pair of prime twins we were able to compute in 100ms.
main :: IO ()
main = runTimeoutNF 100000 (primeTwins primes) >>= print
``````

Number guessing game

``````{-# LANGUAGE FlexibleContexts #-}
import System.Random
import System.Timeout.Returning.Writer

-- | Let the user guess until she hits the number.
=> Int            -- ^ The number to be guessed.
-> m ()
guess n = loop
where
loop = do
is <- liftIO \$ putStr "Guess: " >> liftM reads getLine
case is of
((i,_) : _) -> do
tell [i]
case i `compare` n of
EQ  -> return ()
LT  -> liftIO (putStrLn "Guess larger.")  >> loop
GT  -> liftIO (putStrLn "Guess smaller.") >> loop
_ -> liftIO (putStrLn "Invalid number.") >> loop

-- | Guess a number.
main :: IO ()
main = do
let limit = 20
putStrLn "Guess a number from 1 to 100."
putStrLn \$ "You have " ++ show limit ++ " seconds."
n <- randomRIO (1, 100)
(r, w) <- runTimeout (limit * (10^6)) (guess n)
putStrLn ""
putStr "The number was: " >> print n
case r of
Just _      -> putStrLn "You win!"
otherwise   -> putStr "Time's up, you lose. Your guesses: " >> print w
``````