iteratee 0.3.1 → 0.3.4

raw patch · 5 files changed

+55/−39 lines, 5 filessetup-changedPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CONTRIBUTORS +2/−0
• Setup.hs +2/−0
• iteratee.cabal +11/−4
• src/Data/Iteratee/Base.hs +34/−35
• src/Data/Iteratee/WrappedByteString.hs +6/−0

@@ -5,5 +5,7 @@ John Lato Echo Nolan Paulo Tanimoto+Magnus Therning Johan Tibell Bas van Dijk+Valery Vorotyntsev

@@ -1,3 +1,5 @@+#! /usr/bin/runhaskell+ module Main (main) where  import Distribution.Simple (defaultMain)

@@ -1,5 +1,5 @@ name:          iteratee-version:       0.3.1+version:       0.3.4 synopsis:      Iteratee-based I/O description:   The IterateeGM monad provides strict, safe, and functional I/O. In addition@@ -30,6 +30,10 @@   description: Build test executables.   default:     False +flag includeCodecs+  description: Build Tiff and Wave codec modules+  default:     False+ library   hs-source-dirs:     src@@ -68,12 +72,15 @@     Data.Iteratee.Base.LooseMap     Data.Iteratee.Binary     Data.Iteratee.Char-    Data.Iteratee.Codecs.Tiff-    Data.Iteratee.Codecs.Wave     Data.Iteratee.IO     Data.Iteratee.IO.Handle     Data.Iteratee.WrappedByteString +  if flag(includeCodecs)+    exposed-modules:+      Data.Iteratee.Codecs.Tiff+      Data.Iteratee.Codecs.Wave+   other-modules:     Data.Iteratee.IO.Base @@ -109,4 +116,4 @@  source-repository head   type:     darcs-  location: http://inmachina.net/~jwlato/haskell/iteratee+  location: http://tanimoto.us/~jwlato/haskell/iteratee

@@ -444,10 +444,9 @@ length = length' 0   where   length' = IterateeG . step-  step i (Chunk xs) = return $ Cont-                               (length' $! i + fromIntegral (LL.length xs))-                               Nothing-  step i stream     = return $ Done i stream+  step i (Chunk xs) = let a = i + (LL.length xs)+                      in a `seq` return $ Cont (length' a) Nothing+  step i stream     = return $ Done (fromIntegral i) stream   -- ---------------------------------------------------@@ -466,21 +465,20 @@ -- stream of the read elements. Unless the stream is terminated early, we -- read exactly n elements (even if the iteratee has accepted fewer). take :: (SC.StreamChunk s el, Monad m) =>-  Int ->-  EnumeratorN s el s el m a+  Int -> EnumeratorN s el s el m a take 0 iter = return iter-take n' iter = IterateeG (step n')+take n iter = IterateeG step   where-  step n chk@(Chunk str)-    | SC.null str = return $ Cont (take n iter) Nothing-    | SC.length str < n = liftM (flip Cont Nothing) inner-      where inner = liftM (check (n - SC.length str)) (runIter iter chk)-  step n (Chunk str) = done (Chunk s1) (Chunk s2)-    where (s1, s2) = SC.splitAt n str-  step _n stream            = done stream stream-  check n (Done x _)        = drop n >> return (return x)-  check n (Cont x Nothing)  = take n x-  check n (Cont _ (Just e)) = drop n >> throwErr e+  step s@(Chunk str)+    | LL.null str       = return $ Cont (take n iter) Nothing+    | LL.length str < n = liftM (flip Cont Nothing) inner+      where inner = check (n - LL.length str) `liftM` runIter iter s+  step (Chunk str) = done (Chunk s1) (Chunk s2)+    where (s1, s2) = LL.splitAt n str+  step str = done str str+  check n' (Done x _)        = drop n' >> return (return x)+  check n' (Cont x Nothing)  = take n' x+  check n' (Cont _ (Just e)) = drop n' >> throwErr e   done s1 s2 = liftM (flip Done s2) (runIter iter s1 >>= checkIfDone return)  @@ -491,23 +489,24 @@ -- of processing of the outer stream once the processing of the inner stream -- finished early. takeR :: (SC.StreamChunk s el, Monad m) =>-  Int ->-  IterateeG s el m a ->-  IterateeG s el m (IterateeG s el m a)+  Int -> EnumeratorN s el s el m a takeR 0 iter = return iter-takeR n iter = IterateeG (step n)+takeR n iter = IterateeG step   where-  step n' s@(Chunk str)+  step s@(Chunk str)     | LL.null str        = return $ Cont (takeR n iter) Nothing     | LL.length str <= n = runIter iter s >>= check (n - LL.length str)     | otherwise          = done (Chunk str1) (Chunk str2)-      where (str1, str2) = LL.splitAt n' str-  step _n str            = done str str-  check _n' (Done a str)   = return $ Done (return a) str-  check n'  (Cont k mErr)  = return $ Cont (takeR n' k) mErr+      where (str1, str2) = LL.splitAt n str+  step str = done str str+  check _ (Done a str)  = return $ Done (return a) str+  check n' (Cont k mErr) = return $ Cont (takeR n' k) mErr   done s1 s2 = liftM (flip Done s2) (runIter iter s1 >>= checkIfDone return) +{-# SPECIALIZE takeR :: Int -> IterateeG [] el IO a -> IterateeG [] el IO (IterateeG [] el IO a) #-}+{-# SPECIALIZE takeR :: Monad m => Int -> IterateeG [] el m a -> IterateeG [] el m (IterateeG [] el m a) #-} + -- |Map the stream: yet another iteratee transformer -- Given the stream of elements of the type el and the function el->el', -- build a nested stream of elements of the type el' and apply the@@ -517,11 +516,11 @@ mapStream :: (SC.StreamChunk s el, SC.StreamChunk s el', Monad m) =>  (el -> el')   -> EnumeratorN s el s el' m a-mapStream f i = IterateeG ((check <=< runIter i) . strMap (SC.cMap f))+mapStream f i = step i   where-    go iter = IterateeG ((check <=< runIter iter) . strMap (SC.cMap f))+    step iter = IterateeG ((check <=< runIter iter) . strMap (SC.cMap f))     check (Done a _)    = return $ Done (return a) (Chunk LL.empty)-    check (Cont k mErr) = return $ Cont (go k) mErr+    check (Cont k mErr) = return $ Cont (step k) mErr  -- |Map a stream without changing the element type.  For StreamChunks -- with limited element types (e.g. bytestrings)@@ -529,11 +528,11 @@ rigidMapStream :: (SC.StreamChunk s el, Monad m) =>   (el -> el)   -> EnumeratorN s el s el m a-rigidMapStream f i =  go i+rigidMapStream f i = step i   where-    go iter = IterateeG ((check <=< runIter iter) . strMap (LL.rigidMap f))+    step iter = IterateeG ((check <=< runIter iter) . strMap (LL.rigidMap f))     check (Done a _)    = return $ Done (return a) (Chunk LL.empty)-    check (Cont k mErr) = return $ Cont (go k) mErr+    check (Cont k mErr) = return $ Cont (step k) mErr  -- |Yet another stream mapping function.  For container instances with -- class contexts, such as uvector or storablevector, this allows@@ -545,11 +544,11 @@     Monad m) =>   (el -> el')   -> EnumeratorN s el s el' m a-looseMapStream f i =  go i+looseMapStream f i = step i   where-    go iter = IterateeG ((check <=< runIter iter) . strMap (looseMap f))+    step iter = IterateeG ((check <=< runIter iter) . strMap (looseMap f))     check (Done a _)    = return $ Done (return a) (Chunk LL.empty)-    check (Cont k mErr) = return $ Cont (go k) mErr+    check (Cont x mErr) = return $ Cont (step x) mErr   -- |Convert one stream into another, not necessarily in `lockstep'

@@ -90,6 +90,12 @@   toList        = BC.unpack . unWrap   rigidMap f    = WrapBS . BC.map f . unWrap +instance LL.StringLike (WrappedByteString Char) where+  toString = BC.unpack . unWrap+  fromString = WrapBS . BC.pack+  lines      = LL.fromList . map WrapBS . BC.lines . unWrap+  words      = LL.fromList . map WrapBS . BC.words . unWrap+ instance SC.StreamChunk WrappedByteString Char where   cMap          = bcmap