timeout-with-results: Runs a time-limited computation alowing it to return intermediate results.

[ concurrency, library ] [ Propose Tags ]

Evaluates a computation withing a given timeout limit, alowing it to return intermediate results. Useful for AI algorithms that should return the best result within a given wallclock time limit.

[Skip to Readme]


Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


  • No Candidates
Versions [RSS] 0.1, 0.1.1, 0.2
Dependencies base (>=4 && <5), deepseq (>=1.1), mtl (>=2), parallel (>=3) [details]
License LicenseRef-LGPL
Copyright (c) 2012 Petr Pudlák
Author Petr Pudlák
Maintainer Petr Pudlák <petr.mvd@gmail.com>
Category Concurrency
Home page https://github.com/ppetr/timeout-with-results
Bug tracker https://github.com/ppetr/timeout-with-results/issues
Source repo head: git clone git://github.com/ppetr/timeout-with-results.git
Uploaded by PetrPudlak at 2012-12-14T20:21:43Z
Reverse Dependencies 1 direct, 0 indirect [details]
Downloads 2445 total (7 in the last 30 days)
Rating (no votes yet) [estimated by Bayesian average]
Your Rating
  • λ
  • λ
  • λ
Status Docs uploaded by user
Build status unknown [no reports yet]

Readme for timeout-with-results-0.2

[back to package description]


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


Computing pairs of prime twins

{-# LANGUAGE FlexibleContexts #-}
import Control.Monad
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 : ps@(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 Control.Monad
import Control.Monad.IO.Class
import System.Random
import System.Timeout.Returning.Writer

-- | Let the user guess until she hits the number.
guess :: (MonadIO m, MonadWriter [Int] m)
      => Int            -- ^ The number to be guessed.
      -> m ()
guess n = loop
    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


Copyright 2012, Petr Pudlák

Contact: petr.pudlak.name.


This program is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this program. If not, see http://www.gnu.org/licenses/.