- Libraries - Haskell.org

ANNOUNCE: incremental-parser library package
by Mario Blažević 14 Apr '11

14 Apr '11

The first version of incremental-parser has been released on Hackage [1]. It's yet another parser combinator library, providing the usual set of Applicative and Monad combinators. Apart from this, it has three twists that make it unique. First, the parser is incremental. That means it can be fed its input in chunks, and in proper circumstances it can also provide the parsed output in chunks. For this to be possible the result type must be a Monoid. The complete parsing result is then a concatenation of the partial results. In order to make the incremental parsing easier, the combinator set is optimized for monoidal results. The usual combinator many1, for example, assumes the result type is a monoid and concatenates its components instead of constructing a list. In Parsec: > many1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m [a] In incremental-parser: > many1 :: (Monoid s, Monoid r) => Parser s r -> Parser s r The second weirdness is that the the parser is generic in its input stream type, but this type is parameterized in a holistic way. There is no separate token type. Primitive parsers that need to peek into the input require its type to be an instance of a monoid subclass. In Parsec: > string :: Stream s m Char => String -> ParsecT s u m String > char :: Stream s m Char => Char -> ParsecT s u m Char > anyToken :: (Stream s m t, Show t) => ParsecT s u m t In Attoparsec: > string :: ByteString -> Parser ByteString > word8 :: Word8 -> Parser Word8 > anyWord8 :: Parser Word8 In incremental-parser: > string :: (LeftCancellativeMonoid s, MonoidNull s) => s -> Parser s s > token :: (Eq s, FactorialMonoid s) => s -> Parser s s > anyToken :: FactorialMonoid s => Parser s s The monoid subclasses referenced above provide methods for analyzing and subdividing the input stream. The classes are not particularly demanding, and any reasonable input stream should be able to accommodate them easily. The library comes with instances for lists, ByteString, and Text. > class Monoid m => MonoidNull m where > mnull :: m -> Bool > class Monoid m => LeftCancellativeMonoid m where > mstripPrefix :: m -> m -> Maybe m > class Monoid m => FactorialMonoid m where > factors :: m -> [m] > primePrefix :: m -> m > ... Finally, the library being implemented on the basis of Brzozowski derivatives, it can provide both the symmetric and the left-biased choice, <|> and <<|>. This is the same design choice made by Text.ParserCombinators.ReadP and uu-parsinglib. Parsec and its progeny on the other hand provide only the faster left-biased choice, at some cost to the expressiveness of the combinator language. [1] http://hackage.haskell.org/package/incremental-parser-0.1

6 7

Proposal: Improve the API for TChan, TMVar, and TVar
by wren ng thornton 09 Apr '11

09 Apr '11

I've found the following functions helpful for working with STM. Some of them are just filling out the API so that TVars, TMVars, and IORefs match better. And all the non-TVar functions can be optimized considerably by including them in the STM library rather than defining them externally. The implementations are obvious, so I'll just include the types here; see the patch if you're interested. -- | Non-blocking version of 'readTChan'. tryReadTChan :: TChan a -> STM (Maybe a) -- | Get the next value from the 'TChan' without removing it, -- blocking if the channel is empty. peekTChan :: TChan a -> STM a -- | Non-blocking version of 'peekTChan'. tryPeekTChan :: TChan a -> STM (Maybe a) -- | Non-blocking version of 'readTMVar'. tryReadTMVar :: TMVar a -> STM (Maybe a) -- | Like 'modifyIORef' but for 'TVar'. modifyTVar :: TVar a -> (a -> a) -> STM () -- | Strict version of 'modifyTVar'. modifyTVar' :: TVar a -> (a -> a) -> STM () -- | Like 'swapTMVar' but for 'TVar'. swapTVar :: TVar a -> a -> STM a Discussion period: 2 weeks. -- Live well, ~wren

4 10

ANN: SafeSemaphore, Proposal: replace QSem/QSemN
by Chris Kuklewicz 08 Apr '11

08 Apr '11

There is a leak in base. A leak in the semaphores. Drip, drip, drip. I would like to announce a new package SafeSemaphore, at > http://hackage.haskell.org/package/SafeSemaphore My intent is for this to supersede the implementation of semaphore in Control.Concurrent.QSem and Control.Concurrent.QSemN currently in the base package. This is needed because there is a quantity loss bug in QSem and QSemN. Any thread blocked while waiting might be killed. In this case a later signal will pass quantity to the dead thread. This quantity is never received and is thus lost to the program. This is logged in GHC's bug tracker at http://hackage.haskell.org/trac/ghc/ticket/3160 The MSem and MSemN modules in SafeSemaphore fix this problem and are extended replacement for QSem/QSemN with what I think is an improved and extended API. Under the hood a MSem/MSemN only ever allocates three MVars, instead of one MVar for every blocking waiter that QSem/QSemN allocate. The related Haskell wiki page at > http://haskell.org/haskellwiki/SafeConcurrent shows the included TestKillSem.hs file and its output. This shows how the QSem/QSemN bug can be triggered and shows that MSem/MSemN is immune to this leak. Cheers, Chris Kuklewicz

1 0

Re: Missing MaybeT MonadFix instance
by Ross Paterson 08 Apr '11

08 Apr '11

On Fri, Apr 01, 2011 at 08:51:52PM -0400, Job Vranish wrote: > Is there a particular reason that the transformers version of the > MaybeT monad does not have a MonadFix instance? I don't think so. The original MaybeT package had an instance instance (MonadFix m) => MonadFix (MaybeT m) where -- I hope this is correct. At a minimum, it typechecks. mfix f = MaybeT (mfix (maybe (return Nothing) (runMaybeT . f))) which would loop if f returned Nothing, while your instance, which is equivalent to instance (MonadFix m) => MonadFix (MaybeT m) where mfix f = MaybeT (mfix (runMaybeT . f . unJust)) where unJust = fromMaybe (error "mfix MaybeT: Nothing") is compatible with the MonadFix instance for Maybe, so it should probably go in. I see IdentityT is also missing a MonadFix instance, which is easily added: instance (MonadFix m) => MonadFix (IdentityT m) where mfix f = IdentityT (mfix (runIdentityT . f))

3 2

Re: Data.HashTable performance
by Johan Tibell 06 Apr '11

06 Apr '11

On Wed, Apr 6, 2011 at 1:13 PM, Manuel M T Chakravarty <mchakravarty(a)me.com> wrote: > Your package absolutely should go into the Haskell Platform! This is such essential functionality that we shouldn't leave it for people to find it on Hackage. I intend to flesh out the API a bit more during the next month, so it's on par with Data.Map. If I have the energy I'll make a proposal to add it to the HP at that point. Johan

2 1

Filemanip on Windows
by Dominic Steinitz 06 Apr '11

06 Apr '11

I tried to install filemanip on a windows system but it failed at the build stage: C:\temp\filemanip-0.3.5.2>runghc Setup.lhs build Preprocessing library filemanip-0.3.5.2... Building filemanip-0.3.5.2... System\FilePath\Manip.hs:25:7: Could not find module `System.Posix.Temp': Use -v to see a list of the files searched for. It seems that Manip.hs depends on System.Posix.Temp but the cabal file says it doesn't on windows: if !os(windows) build-depends: unix I amended Manip.hs to work on windows and I am pretty sure it will still work on unix. I've attached the amended source (I would have attached a patch but I'm not familiar with the source control system you are using). I also noticed that someone else had submitted a patch for windows support: https://bitbucket.org/bos/filemanip/issue/1/patch-for-windows-support. Did this every get incorporated? For some reason I wasn't able to look at it but it may be better than my patch. Dominic. {-# LANGUAGE FlexibleInstances, ScopedTypeVariables, TypeSynonymInstances #-} -- | -- Module: System.FilePath.Manip -- Copyright: Bryan O'Sullivan -- License: BSD3 -- Maintainer: Bryan O'Sullivan <bos(a)serpentine.com> -- Stability: unstable -- Portability: Unix-like systems (requires flexible instances) module System.FilePath.Manip ( Streamable(..) , renameWith , modifyWith , modifyWithBackup , modifyInPlace ) where import Control.Exception import Control.Monad (liftM) import Data.Bits ((.&.)) import System.Directory (removeFile, getTemporaryDirectory) import System.IO (Handle, IOMode(..), hClose, openFile, openTempFile) import System.PosixCompat.Files (fileMode, getFileStatus, rename, setFileMode) import qualified Data.ByteString.Char8 as B import qualified Data.ByteString.Lazy.Char8 as L import qualified System.IO as I -- | Use a renaming function to generate a new name for a file, then -- rename it. renameWith :: (FilePath -> FilePath) -- ^ function to rename with -> FilePath -- ^ file to rename -> IO () renameWith f path = rename path (f path) -- | Type class for string manipulation over files. class Streamable a where -- | Read the entire contents of a 'Handle'. readAll :: Handle -> IO a -- | Write an entire string to a 'Handle'. writeAll :: Handle -> a -> IO () instance Streamable B.ByteString where readAll = B.hGetContents writeAll = B.hPut instance Streamable L.ByteString where readAll = L.hGetContents writeAll = L.hPut instance Streamable String where readAll = I.hGetContents writeAll = I.hPutStr -- | Modify a file in place using the given function. This is -- performed by writing to a temporary file, then renaming it on top of -- the existing file when done. modifyInPlace :: Streamable a => (a -> a) -- ^ transformation function -> FilePath -- ^ name of file to modify -> IO () modifyInPlace = modifyWith (flip rename) -- | Modify a file in place using the given function. The original -- copy of the file is saved under a new name. This is performed by -- writing to a temporary file; renaming the original file to its new -- name; then renaming the temporary file to the original name. -- -- Example: -- -- @ -- -- save original file with a \".bak\" extension -- 'modifyWithBackup' (\<.\> \"bak\") -- @ modifyWithBackup :: Streamable a => (FilePath -> FilePath) -- ^ chooses new name for original file -> (a -> a) -- ^ transformation function -> FilePath -- ^ name of file to modify -> IO () modifyWithBackup f = modifyWith backup where backup path tmpPath = renameWith f path >> rename tmpPath path -- | Modify a file in place using the given function. The new content -- is written to a temporary file. Once this is complete, the file -- manipulation action is called. Its arguments are the names of the -- original and temporary files. -- -- Example: -- -- @ -- 'modifyInPlace' = 'modifyWith' (flip rename) -- @ modifyWith :: Streamable a => (FilePath -> FilePath -> IO ()) -- ^ file manipulation action -> (a -> a) -- ^ transformation function -> FilePath -> IO () modifyWith after transform path = bracket (openFile path ReadMode) hClose $ \ih -> do tmpDir <- getTemporaryDirectory (tmpPath, oh) <- openTempFile tmpDir "XXX.XXX" let ignore = return () nukeTmp = handle (\(_::IOException) -> ignore) (removeFile tmpPath) handle (\(e::IOException) -> nukeTmp >> throw e) $ do bracket_ ignore (hClose oh) $ readAll ih >>= return . transform >>= writeAll oh handle (\(_::IOException) -> nukeTmp) $ do mode <- fileMode `liftM` getFileStatus path setFileMode tmpPath (mode .&. 0777) after path tmpPath

1 0

Conversion to git
by Ian Lynagh 06 Apr '11

06 Apr '11

Hi all, The latest GHC git conversion plan is to convert GHC and all associated repos to git on: *** Tuesday, March the 15th *** In some cases this will mean simply converting the master repos, while in others it'll mean setting up git (lagging) mirrors for the GHC build to use. We've made a list of which repos we suggest should be converted, and which should be mirrored, here: http://hackage.haskell.org/trac/ghc/wiki/DarcsConversion#Planforlibraries Can you please let us know if you think any of the repos have been put in the wrong category? Thanks Ian

5 10

Data.HashTable performance
by Frank Kuehnel 06 Apr '11

06 Apr '11

Out of curiosity, I've tested a few Hashtable implementations: http://zufaellige-reflektion.blogspot.com/2011/04/associative-arrays-showdo… Are there any clues why Haskell's Data.HashTable doesn't perform better? I would have expected a similar performance like with F# on the Mono 2.0 platform. Thanks, Frank

6 6

ANN: stm-chans: Additional types of channels for STM.
by wren ng thornton 06 Apr '11

06 Apr '11

-------------------------------------------- -- stm-chans 1.0.0 -------------------------------------------- The stm-chans package offers a collection of channel types, similar to Control.Concurrent.STM.TChan but with additional features. In particular it offers these types: * Control.Concurrent.STM.TBChan: Bounded FIFO channels. When the channel is full, writers will block/retry. This ensures that the writers do not get too far ahead of the readers, which helps to make sure that memory and cpu resources are used responsibly. * Control.Concurrent.STM.TMChan: Closeable FIFO channels. This is like TChan (Maybe a) but with a monotonicity guarantee that once Nothing is returned all future reads will be Nothing as well. * Control.Concurrent.STM.TBMChan: Bounded Closeable FIFO channels. This combines the capabilities of TBChan and TMChan. In addition, the stm-chans package offers a (partial) compatibility layer for some API improvements still making their way into the stm package[1]. These new functions include: * tryReadTChan :: TChan a -> STM (Maybe a) A version of readTChan which does not retry. Instead it returns Nothing if no value is available. * peekTChan :: TChan a -> STM a Get the next value from the TChan without removing it, retrying if the channel is empty. * tryPeekTChan :: TChan a -> STM (Maybe a) A version of peekTChan which does not retry. Instead it returns Nothing if no value is available. [1] http://article.gmane.org/gmane.comp.lang.haskell.libraries/15507 -------------------------------------------- -- Links -------------------------------------------- Homepage: http://code.haskell.org/~wren/ Hackage: http://hackage.haskell.org/package/stm-chans Darcs: http://community.haskell.org/~wren/stm-chans Haddock (Darcs version): http://community.haskell.org/~wren/stm-chans/dist/doc/html/stm-chans -- Live well, ~wren

2 3

Show instance in System.Event.Manager causes conflicts
by Conal Elliott 04 Apr '11

04 Apr '11

System.Event.Manager [1] contains the following type alias and Show instance: -- | Callback invoked on I/O events. type IOCallback = FdKey -> Event -> IO () instance Show IOCallback where show _ = "IOCallback" This specialized instance conflicts with the more general instance Show (a -> b) defined in Text.Show.Functions. Stefan found this conflict when trying to compile the checkers package on ghc 7.0.3. I suspect it will arise with other packages as well. My suggestion is to remove the specialized Show instance and instead import Text.Show.Functions as needed. Other thoughts? [1] http://hackage.haskell.org/packages/archive/base/4.3.1.0/doc/html/src/Syste… - Conal

4 3