diff --git a/Control/Concurrent/Futures.hs b/Control/Concurrent/Futures.hs new file mode 100644 --- /dev/null +++ b/Control/Concurrent/Futures.hs @@ -0,0 +1,80 @@ +{- | +Module : +Description : This package implements various kinds of concurrency abstractions using futures. +Maintainer : mwillig@gmx.de +Stability : experimental +Portability : portable + +This package implements futures and various kinds of concurrency abstractions +using futures. + +Threads can synchronise their values via futures. +Future values are lazily evaluated so they explicitly suspend the computation. +Each future object is associated with a background thread that computes the future value. +As long as this expression has not been evaluated, the value of the future is unknown. +Whenever an unknown future is accessed the computation will suspend on this future. +Once the value has been evaluated the computation resumes. A handle is a component +that points to an unevaluated future and computes its value on demand. +Therefore, handles are used to associate a value to a future. They provide +a synchronisation mechanism for processes. + +Example +This example shows how you can use "Buffer" to concurrently compute the values of +nodes from a binary tree. + +> data BTree a = BLeaf a | BNode a (BTree a) (BTree a) + +> concSumB :: (Num a) => BTree a -> IO a +> concSumB t = do +> result <- newBuf +> case t of +> BLeaf a -> putBuf result a; +> BNode a t1 t2 -> sumB result t +> out <- getBuf result +> return out + +> sumB :: (Num a) => Buffer a -> BTree a -> IO () +> sumB mvar tree = do +> case tree of +> BLeaf a -> putBuf mvar a +> BNode a t1 t2 -> do +> sem <- newBuf +> forkIO (sumB sem t1) +> forkIO (sumB sem t2) +> erg1 <-getBuf sem +> erg2 <-getBuf sem +> putBuf mvar (erg1 + erg2 + a) + +You can test the function with the following test data + +> bintree = BNode 1 (BNode 24 (BLeaf 2) (BNode 6 (BLeaf 24) (BLeaf 3)))(BNode 33 (BLeaf 7) (BLeaf 8)) +> concSumB bintree + +-} +module Control.Concurrent.Futures ( + module Control.Concurrent.Futures.Futures, + module Control.Concurrent.Futures.Buffer, + module Control.Concurrent.Futures.Chan, + module Control.Concurrent.Futures.QSem, + module Control.Concurrent.Futures.HQSem, + module Control.Concurrent.Futures.BChan, + module Control.Concurrent.Futures.Barrier, + module Control.Concurrent.Futures.Examples, + ) where + +import Control.Concurrent.Futures.Futures +import Control.Concurrent.Futures.Buffer +import Control.Concurrent.Futures.Chan +import Control.Concurrent.Futures.QSem +import Control.Concurrent.Futures.HQSem +import Control.Concurrent.Futures.BChan +import Control.Concurrent.Futures.Barrier +import Control.Concurrent.Futures.Examples + + +-- internal function +--wait :: Bool -> IO Bool +--wait x = do +-- case x of +-- True -> return x +-- otherwise -> return x diff --git a/Control/Concurrent/Futures/BChan.hs b/Control/Concurrent/Futures/BChan.hs new file mode 100644 --- /dev/null +++ b/Control/Concurrent/Futures/BChan.hs @@ -0,0 +1,50 @@ +{- | +Module : +Description : This module implements a bounded channel concurrency primitive using channels and quantity semaphores +Maintainer : mwillig@gmx.de +Stability : experimental +Portability : non-portable (requires Futures) + +This modules combines a quantity semaphore from the module Control.Concurrent.Fututes.QSem and a channel from +module Control.Concurrent.Fututes.Chan to a new synchronisation primitive. Bounded channels have a limited +capacity of storage cells. +Warning: All operations on bounded channels should only be used within the +global wrapper function 'Futures.withFuturesDo'! +-} +module Control.Concurrent.Futures.BChan ( + BChan, + newBChan, + readBChan, + writeBChan + +) where +import Control.Concurrent.Futures.Chan +import Control.Concurrent.Futures.QSem + +--data BChan a = BChan a (Chan a, QSem ) +--type BChanType a = (ChanType a, QSem) + +type BChan a = (Chan a, QSem) + +-- | Creates a new bounded channel +newBChan :: Int -> IO (BChan a) +newBChan n = do + chan <- newChan + qsem <- newQSem n + return (chan , qsem) + +-- | Performs an up-operation on the QSem of the bounded channel and then reads +-- a value from the channel. The read operation may block. +readBChan :: BChan a -> IO a +readBChan (chan, sem) = do + up sem + readChan chan + +-- | Performs a down-operations on the QSem of the bounded channel and writes a +-- new value to it. The down-operation may block. +writeBChan :: BChan a -> a -> IO () +writeBChan (chan, sem) val = do + down sem + writeChan chan val + + diff --git a/Control/Concurrent/Futures/Buffer.hs b/Control/Concurrent/Futures/Buffer.hs new file mode 100644 --- /dev/null +++ b/Control/Concurrent/Futures/Buffer.hs @@ -0,0 +1,101 @@ +{- | +Module : +Description : This module implements a buffer with cells and futures. +Maintainer : mwillig@gmx.de +Stability : experimental +Portability : non-portable (requires Futures) + +This module implements one-place buffers using futures. +Warning: All operations on buffers should only be used within the global wrapper function +'Futures.withFuturesDo'! +-} +module Control.Concurrent.Futures.Buffer ( + Buffer, +-- Cell, +-- cell, +-- testAndSet, + wait, + newBuf, + putBuf, + getBuf +) where + +import Control.Concurrent.Futures.Futures as Futures +import Control.Concurrent.MVar +import System.IO + +-- -- The buffer type contains of 3 cells and a handle. +type Buffer a = (Cell Bool, Cell Bool, Cell a, Cell (Bool -> IO ())) + +----------------------------------------------------------------------- +---Cells + +-- | A cell type. Cells provide an automic 'exchange' operation. +type Cell a = MVar a + +-- | Creates a new cell. +cell :: a -> IO (Cell a) +cell a = newMVar a + +exchange :: Cell a -> a -> IO a +exchange a b = swapMVar a b + +-- | TestAndSet on cells provides test and set functions in one atomic operation. +testAndSet :: Cell Bool -> IO t -> IO Bool +testAndSet cell code = do + val <- (exchange cell True) + case val of + True -> return True + False -> do + code + exchange cell False + +-- | A test on cells +--tsExample = do +-- c <- Buffer.cell False +-- code <- (\x -> do putStrLn "The code." return x) +-- Buffer.testAndSet c code +-- return c +------------------------------------------------------------------------------- + +-- | Waits its argument to become true +wait :: Bool -> IO Bool +wait x = do + case x of + True -> return x + otherwise -> return x + +-- | Creates a new empty buffer. +newBuf :: IO (Buffer a) +newBuf = do + (h,f) <- Futures.newhandled + (h',f') <- Futures.newhandled + putg <- cell True + getg <- cell f + stored <- cell f' + handler <- cell h + return (putg,getg,stored,handler) + +-- | Puts a new value to a buffer. 'putBuf' blocks if +-- the buffer is full. +putBuf :: Buffer a -> a -> IO () +putBuf (putg,getg,stored,handler) val = do + (h,f) <- Futures.newhandled + old_value <- exchange putg f + wait old_value + exchange stored val + old_handler <- exchange handler h + old_handler True + +-- | Gets the contents of a non-empty buffer. If the buffer is empty, then +-- this function blocks until the buffer is filled. +getBuf :: Buffer a -> IO a +getBuf (putg,getg,stored,handler) = do + (h,f) <- Futures.newhandled + (h',f') <- Futures.newhandled + old_value <- exchange getg f + wait old_value + val <- exchange stored f' + old_handler <- exchange handler h + old_handler True + return val diff --git a/Control/Concurrent/Futures/Chan.hs b/Control/Concurrent/Futures/Chan.hs new file mode 100644 --- /dev/null +++ b/Control/Concurrent/Futures/Chan.hs @@ -0,0 +1,106 @@ +{- | +Module : +Description : This module implements a channel concurrency primitive using Buffers. +Maintainer : mwillig@gmx.de +Stability : experimental +Portability : non-portable (requires Futures) + +This module implements a channel synchronisation primitive using buffers that block on +futures. A channel is a linked list of buffers. It has a read-end at one side and a +write-end at the other. Elements put into the channel can be read out in +a first in, first out order. A read and a write operation can be executed in +parallel by several threads. A channel has no capacity bounding. + +The module contains similar functions as 'Control.Concurrent.Futures.Chan'. + +Warning: All operations on channels should only be used within the global wrapper function +'Futures.withFuturesDo'! +-} +module Control.Concurrent.Futures.Chan ( + Chan, + ChanType, + newChan, + writeChan, + readChan, + writeChanContents, + getChanContents, + mergeChan + ) where + +-- qualified, because channel functions are also defined in +-- Control.Concurrent +import qualified Control.Concurrent +import System.IO.Unsafe ( unsafeInterleaveIO ) +import Control.Concurrent.Futures.Buffer +import Control.Concurrent.Futures.Futures + +-- | A channel consists of a read-end buffer and a write-end buffer. +-- The Itemtype is required to link the buffers in the channel. +data Chan a + = Chan (Buffer (ItemType a)) + (Buffer (ItemType a)) + +type ChanType a = ((Buffer (ItemType a)), (Buffer (ItemType a))) +type ItemType a = (Buffer(Item a)) +data Item a = Item a (ItemType a) + +-- | Creates a new empty channel. +newChan :: IO (Chan a) +newChan = do + hole <- newBuf + read_end <- newBuf + write_end <- newBuf + putBuf read_end hole + putBuf write_end hole + return (Chan read_end write_end) + +-- | Writes one value to a channel. A 'writeChan' never blocks, since channels have +-- no bounding limiters. +writeChan :: Chan a -> a -> IO () +writeChan (Chan read_end write_end) val = do + new_hole <- newBuf + old_hole <- getBuf write_end + putBuf write_end new_hole + putBuf old_hole (Item val new_hole) + + +-- | Reads out an item from the read-head of the channel. +-- It blocks on a empty channel. +readChan :: Chan a -> IO a +readChan (Chan read_end write_end) = do + chan_head <- getBuf read_end + (Item val content) <- getBuf chan_head + putBuf read_end content + return val + + +-- | Implements the same behaviour as writeChanContents from the module Control.Concurrent.Chan. +writeChanContents :: Chan a -> [a] -> IO () +writeChanContents chan (x:xs) = do + Control.Concurrent.forkIO (writeChan chan x) + writeChanContents chan xs + >>= return +writeChanContents chan [] = return () + +-- | Implements the same behaviour as getChanContents from the module Control.Concurrent.Chan. +-- It reads permanently from the channel. +getChanContents :: Chan a -> IO [a] +getChanContents ch + = unsafeInterleaveIO ( do + x <- readChan ch + xs <- getChanContents ch + return (x:xs) + ) + +-- | Writes two equally typed lists to a given channel in parallel. +mergeChan :: [a] -> [a] -> Chan a -> IO (Chan a) +mergeChan l1 l2 cm = do + Control.Concurrent.forkIO (merge l1 cm) + Control.Concurrent.forkIO (merge l2 cm) + return cm + +-- internal function +merge (x:xs) c = do + Control.Concurrent.forkIO (writeChan c x) + (merge xs c) +merge [] c = return () diff --git a/Control/Concurrent/Futures/Futures.hs b/Control/Concurrent/Futures/Futures.hs new file mode 100644 --- /dev/null +++ b/Control/Concurrent/Futures/Futures.hs @@ -0,0 +1,155 @@ +{- | +Module : +Description : This module implements several kinds of futures using Concurrent Haskell +Maintainer : sabel@ki.cs.uni-frankfurt.de +Stability : provisional +Portability : portable + +This module implements explicit futures ('EFuture', 'efuture', 'force') as well as several variants of implicit futures +('future', 'recursiveFuture', 'strictFuture', 'strictRecursiveFuture', 'lazyFuture', 'lazyRecursiveFuture') +While explicit futures must be forced (using 'force') if their value is needed, this is not necessary for implicit futures. +For implicit futures it is necessary to put them into the global wrapper 'withFuturesDo'. +-} + +module Control.Concurrent.Futures.Futures ( + EFuture, + efuture, + force, + future, + recursiveFuture, + withFuturesDo, + strictFuture, + strictRecursiveFuture, + lazyFuture, + lazyRecursiveFuture, + hbind, + newhandled, + bhandle + ) where +import Control.Concurrent +import Control.Exception(evaluate) +import System.IO.Unsafe + +--import Data.IO + +-- | The type 'EFuture' implements explicit futures, i.e. if the value of the future is need it must be forced explicitly using 'force' +type EFuture a = MVar a + +-- | 'efuture' creates an explicit future, i.e. the computation is performed concurrently. The future value can be forced using 'force' +efuture :: IO a -> IO (EFuture a) +efuture act = + do ack <- newEmptyMVar + forkIO (act >>= putMVar ack) + return ack + +-- | 'force' forces the value of an explicit future ('EFuture'), i.e. the calling thread blocks until the result becomes available. +force :: EFuture a -> IO a +force = takeMVar + + +-- | 'future' creates an implicit future. A non-blocking concurrent computation is started. If the value of the future is needed, then +-- the future will be forced implicitly. The concurrent computation is killed if the calling thread stops, even if 'future' is used +-- within 'withFuturesDo'. +future :: IO a -> IO a +future code = do ack <-newEmptyMVar + thread <- forkIO (code >>= putMVar ack) + unsafeInterleaveIO (do result <- takeMVar ack + killThread thread + return result) + +-- | 'recursiveFuture' behaves similar to 'future' with the difference that the future is recursive, i.e. the future created by +-- 'recursiveFuture' is used as argument of the code of the future. +recursiveFuture :: (a -> IO a) -> IO a +recursiveFuture code = do ack <- newEmptyMVar + res <- unsafeInterleaveIO (takeMVar ack) + thread <- forkIO (code res >>= putMVar ack) + unsafeInterleaveIO (do res' <- evaluate res + killThread thread + return res') + +-- -------------------------------------------------- +-- not-exported functions for the global manager, they shouldn't be visible outside this module. +-- + +-- The manager is an MVar containing a list of unit-tuples +type Manager = MVar [()] + +-- creating a new Manager +newManager :: IO Manager +newManager = newMVar [] + +-- register a future to a manager +register :: a -> Manager -> IO () +register l man = do + list <- takeMVar man + putMVar man ((seq l ()):list) + +-- synchronizeMan forces the evaluation of all registered futures +synchronizeMan :: Manager -> IO () +synchronizeMan man = do + list <- takeMVar man + seqList list + +seqList [] = return () +seqList (x:xs) = seq x (seqList xs) + + +globalMan = unsafePerformIO newManager + +-- +-- -------------------------------------------------- + +-- | 'withFuturesDo' is the global wrapper which should be used around the code involving futures. +-- I.e., instead of writing @main=code@ one should use @main=withFuturesDo code@. Note, that there +-- should be only one call to 'withFuturesDo' in a program. +withFuturesDo :: IO () -> IO () +withFuturesDo code = do code + synchronizeMan globalMan + + +-- | creating a strict future is similar to 'future' with the difference that if used inside 'withFuturesDo' +-- it is guaranteed that the concurrent computation is forced (and finished) before the main thread terminates. +-- Warning: 'strictFuture' should only be used within the global wrapper 'withFuturesDo'! +strictFuture :: IO a -> IO a +strictFuture code = do fut <- future code + register fut globalMan + return fut + +-- | a recursive variant of 'strictFuture' (see 'recursiveFuture' and 'future) +-- Warning: 'strictRecursiveFuture' should only be used within the global wrapper 'withFuturesDo'! +strictRecursiveFuture :: (a -> IO a) -> IO a +strictRecursiveFuture code = do fut <- recursiveFuture code + register fut globalMan + return fut + +-- | a lazy future. Initially, no concurrent computation is started, but if the lazy future gets (implicitly) forced, +-- then the lazy future becomes a strict future. +-- Warning: 'lazyFuture' should only be used within the global wrapper 'withFuturesDo'! +lazyFuture :: IO a -> IO a +lazyFuture code = unsafeInterleaveIO (strictFuture code) + +-- | a recursive variant of 'lazyFuture' (see 'recursiveFuture' and 'future) +-- Warning: 'lazyRecursiveFuture' should only be used within the global wrapper 'withFuturesDo'! +lazyRecursiveFuture :: (a -> IO a) -> IO a +lazyRecursiveFuture code = unsafeInterleaveIO (strictRecursiveFuture code) + +-- | a new handle component. +bhandle :: (a -> (a -> IO ()) -> t) -> IO t +bhandle x = do + f' <- newEmptyMVar + f <- lazyFuture (do + v <- takeMVar f' + putMVar f' v + return v + ) + h <- strictFuture (return (\z -> (putMVar f' z))) + return (x f h) + +-- | creates a new handle. +newhandled :: IO (a -> IO (), a) +newhandled = bhandle (\f -> \h -> (h,f)) + + +-- | binds a handle to its value. +hbind :: (t -> t1) -> t -> t1 +hbind h v = h v diff --git a/Control/Concurrent/Futures/HQSem.hs b/Control/Concurrent/Futures/HQSem.hs new file mode 100644 --- /dev/null +++ b/Control/Concurrent/Futures/HQSem.hs @@ -0,0 +1,67 @@ +{- | +Module : +Description : This module implements a quantity semaphores with handles +Maintainer : mwillig@gmx.de +Stability : experimental +Portability : non-portable (requires Futures) + +This module implements a quantity semaphore using handles that block on +futures. +A HQSem equals to QSemN in Control.Concurrent. +A Buffer euqals to QSem in Control.Concurrent. +Warning: All operations on quantity semaphores should only be used within the +global wrapper function 'Futures.withFuturesDo'! +-} +module Control.Concurrent.Futures.HQSem ( + HQSem, + newHQSem, + upHQSem, + downHQSem +) where + +import qualified Control.Concurrent +import System.IO.Unsafe ( unsafeInterleaveIO ) +import Control.Concurrent.Futures.Futures as Futures +import Control.Concurrent.Futures.Buffer + +-- | A handled quantity semaphores contains of a capacity and a waiting queue containing +-- handles. +type HQSem = Buffer (Int, [Bool -> IO ()]) + +-- | Creates a new quantity semaphore of capacity cnt. +newHQSem :: Int -> IO (HQSem) +newHQSem cnt = do + b <- newBuf + putBuf b (cnt,[]) + return b + + +-- | Increments the semaphore's value, if there are no waiters. +-- 'up' reads out of the waiting queue and binds a waiting handle to True. +-- Note: This operation equals to signalQSemN in Control.Concurrent.QSemN. +upHQSem :: HQSem -> IO () +upHQSem qsem = do + b <- getBuf qsem + case b of + (cnt,ls) -> case ls of + [] -> do putBuf qsem (cnt+1,ls) + x:xs -> do + x True + putBuf qsem (cnt,ls) + +-- | Decrements the semaphore's value. If the value has already reached 0, then +-- 'down' creates a new handle that is being added to the semaphore's waiting queue. +-- It blocks until the handle assigns a value to its future by a 'up'. +-- Note: This operation equals to waitQSemN in Control.Concurrent.QSemN. +downHQSem :: HQSem -> IO (Bool) +downHQSem qsem = do + b <-getBuf qsem + case b of + (cnt,ls) -> case (cnt==0) of + True -> do + (h,f) <- Futures.newhandled + putBuf qsem (cnt,h:ls) + (wait f) + False -> do + putBuf qsem (cnt-1,ls) + return True diff --git a/Control/Concurrent/Futures/QSem.hs b/Control/Concurrent/Futures/QSem.hs new file mode 100644 --- /dev/null +++ b/Control/Concurrent/Futures/QSem.hs @@ -0,0 +1,86 @@ +{- | +Module : +Description : This module implements a quantity semaphores with buffers +Maintainer : mwillig@gmx.de +Stability : experimental +Portability : non-portable (requires Futures) + +This module implements a quantity semaphore using buffers that block on +futures. + +A QSem equals to QSemN in Control.Concurrent. +A Buffer equals to QSem in Control.Concurrent. + +Warning: All operations on quantity semaphores should only be used within the +global wrapper function 'Futures.withFuturesDo'! +-} +module Control.Concurrent.Futures.QSem ( + QSem, + newQSem, + up, + down, + enter +) where + +import qualified Control.Concurrent +import System.IO.Unsafe ( unsafeInterleaveIO ) +import Control.Concurrent.Futures.Futures +import Control.Concurrent.Futures.Buffer + +-- | A quantity semaphores contains of a capacity and a waiting queue containing +-- buffers. +type QSem = Buffer (Int, [Buffer Bool]) + +-- | Creates a new quantity semaphore of capacity cnt. +newQSem :: Int -> IO (Buffer (Int, [Buffer Bool])) +newQSem cnt = do + b <- newBuf + putBuf b (cnt,[]) + return b + -- For comparison the implementation of the Concurrent Haskell Library +--newQSem :: Int -> IO QSem +--newQSem init = do +--sem <- newMVar (init,[]) +--return (QSem sem) + + +-- | Increments the semaphore's value, if there are no waiters. +-- 'up' reads out of the waiting queue and writes True into a waiting 'Buffer'. +-- Note: This operation equals to signalQSemN in Control.Concurrent.QSemN. +up :: QSem -> IO () +up qsem = do + (cnt,ls) <- getBuf qsem + case ls of + [] -> do putBuf qsem (cnt+1,ls) + x:xs -> do + putBuf x True + putBuf qsem (cnt,ls) + +-- | Decrements the semaphore's value. If the value has already reached zero, then +-- 'down' creates a new empty 'Buffer' that is being added to the semaphore's waiting queue. +-- It blocks until the buffer gets filled by a 'up'. +-- Note: This operation equals to waitQSemN in Control.Concurrent.QSemN. +down :: QSem -> IO Bool +down qsem = do + b <-getBuf qsem + case b of + (cnt,ls) -> case (cnt==0) of + True -> do + b1 <- newBuf + putBuf qsem (cnt,b1:ls) + getBuf b1 + False -> do + putBuf qsem (cnt-1,ls) + return True + +-- | Use the quantity semaphore to limit the computation of code. This function +-- performs a down on the given q. s., executues the code and returns after a up +-- on the q.s. . +enter :: QSem -> IO a -> IO () +enter qsem code = do + x <- down qsem + case x of + True -> do + code + up qsem + False -> return () diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,27 @@ +Copyright 2009, Martina Willig + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: +1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. +3. Neither the name of the author nor the names of his contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. diff --git a/README b/README new file mode 100644 --- /dev/null +++ b/README @@ -0,0 +1,35 @@ +Concurrency Abstractions with Futures +====================================== +More info on the package, releases, etc. can be found at + + http://haskell.forkIO.com/dotnet + +-------------------------------------- +Install distribution package +-------------------------------------- +1. Unzip the tarball +2. Navigate to the directory +3. Run the installation commands + runhaskell Setup configure + runhaskell Setup build + sudo runhaskell Setup install + +This last step will register thedistribution package. +Now in your Haskell programs, you can simply import the new modules from the distribution package. + +-------------------------------------- +Uninstall distribution package +-------------------------------------- +See a list of installed packages with this command + ghc-pkg list + +Unregister the package with + ghc-pkg unregister caf-x.x + +-------------------------------------- +Feedback +-------------------------------------- +Please send Feedback to + +willig@ki.informatik.uni-frankfurt.de + diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,4 @@ +-- file: ch05/Setup.hs +#!/usr/bin/env runhaskell +import Distribution.Simple +main = defaultMain diff --git a/caf.cabal b/caf.cabal new file mode 100644 --- /dev/null +++ b/caf.cabal @@ -0,0 +1,24 @@ +Name: caf +Version: 0.0.1 +Description: This library contains implementations of several kinds of futures and concurrency abstractions. +License: BSD3 +License-file: LICENSE +Author: Dr. David Sabel and Martina Willig +Maintainer: Martina Willig +Build-Type: Simple +Stability: experimental +Synopsis: A library of Concurrency Abstractions using Futures. +Category: Concurrency +Cabal-Version: >= 1.2 +Extra-Source-Files: README +library + Exposed-Modules: Control.Concurrent.Futures + Control.Concurrent.Futures.Futures + Control.Concurrent.Futures.Buffer + Control.Concurrent.Futures.Chan + Control.Concurrent.Futures.QSem + Control.Concurrent.Futures.BChan + Control.Concurrent.Futures.HQSem + Build-Depends: base >= 2.0 + +