Clean up trailing whitespace

Author: sergv

src/Streaming/Prelude.hs

@@ -8,7 +8,7 @@
     articulated in the latter two modules. Because we dispense with piping and
     conduiting, the distinction between all of these modules collapses. Some things are
     lost but much is gained: on the one hand, everything comes much closer to ordinary
-    beginning Haskell programming and, on the other, acquires the plasticity of programming 
+    beginning Haskell programming and, on the other, acquires the plasticity of programming
     directly with a general free monad type. The leading type, @Stream (Of a) m r@ is chosen to permit an api
     that is as close as possible to that of @Data.List@ and the @Prelude@.
 
@@ -64,7 +64,7 @@ module Streaming.Prelude (
     , stdinLn
     , readLn
     , fromHandle
-    , readFile 
+    , readFile
     , iterate
     , iterateM
     , repeat
@@ -76,7 +76,7 @@ module Streaming.Prelude (
     , enumFrom
     , enumFromThen
     , unfoldr
-    
+
 
 
     -- * Consuming streams of elements
@@ -86,7 +86,7 @@ module Streaming.Prelude (
     , mapM_
     , print
     , toHandle
-    , writeFile 
+    , writeFile
     , effects
     , erase
     , drained
@@ -229,7 +229,7 @@ module Streaming.Prelude (
     , merge
     , mergeOn
     , mergeBy
-    
+
     -- * Maybes
     -- $maybes
     , catMaybes
@@ -878,7 +878,7 @@ filter thePred = loop where
       else loop as
 {-# INLINE filter #-}  -- ~ 10% faster than INLINABLE in simple bench
 
-                         
+
 -- ---------------
 -- filterM
 -- ---------------
@@ -1709,7 +1709,7 @@ reread step s = loop where
       Just a  -> return (Step (a :> loop))
 {-# INLINABLE reread #-}
 
-{-| Strict left scan, streaming, e.g. successive partial results. The seed 
+{-| Strict left scan, streaming, e.g. successive partial results. The seed
     is yielded first, before any action of finding the next element is performed.
 
 
@@ -1731,13 +1731,13 @@ reread step s = loop where
 -}
 scan :: Monad m => (x -> a -> x) -> x -> (x -> b) -> Stream (Of a) m r -> Stream (Of b) m r
 scan step begin done str = Step (done begin :> loop begin str)
-  where                   
+  where
   loop !acc stream = do
     case stream of
       Return r -> Return r
       Effect m -> Effect (fmap (loop acc) m)
-      Step (a :> rest) -> 
-        let !acc' = step acc a 
+      Step (a :> rest) ->
+        let !acc' = step acc a
         in Step (done acc' :> loop acc' rest)
 {-# INLINABLE scan #-}
 
@@ -1758,7 +1758,7 @@ scanM :: Monad m => (x -> a -> m x) -> m x -> (x -> m b) -> Stream (Of a) m r ->
 scanM step begin done str = Effect $ do
     x <- begin
     b <- done x
-    return (Step (b :> loop x str))  
+    return (Step (b :> loop x str))
   where
     loop !x stream = case stream of -- note we have already yielded from x
       Return r -> Return r
@@ -2055,7 +2055,7 @@ toList_ = fold_ (\diff a ls -> diff (a: ls)) id (\diff -> diff [])
 
 >  mapped toList :: Stream (Stream (Of a)) m r -> Stream (Of [a]) m
 
-    Like 'toList_', 'toList' breaks streaming; unlike 'toList_' it /preserves the return value/ 
+    Like 'toList_', 'toList' breaks streaming; unlike 'toList_' it /preserves the return value/
     and thus is frequently useful with e.g. 'mapped'
 
 >>> S.print $ mapped S.toList $ chunksOf 3 $ each [1..9]
@@ -2068,7 +2068,7 @@ t<Enter>
 ["s","t"]
 u<Enter>
 v<Enter>
-["u","v"] 
+["u","v"]
 -}
 toList :: Monad m => Stream (Of a) m r -> m (Of [a] r)
 toList = fold (\diff a ls -> diff (a: ls)) id (\diff -> diff [])
@@ -2300,7 +2300,7 @@ stdinLn = fromHandle IO.stdin
 -}
 
 readLn :: (MonadIO m, Read a) => Stream (Of a) m ()
-readLn = loop where 
+readLn = loop where
   loop = do
     eof <- liftIO IO.isEOF
     unless eof $ do
@@ -2846,7 +2846,7 @@ mergeBy cmp = loop
           LT -> Step (a :> loop rest0 str1)
           EQ -> Step (a :> loop rest0 str1) -- left-biased
           GT -> Step (b :> loop str0 rest1)
-{-# INLINABLE mergeBy #-}        
+{-# INLINABLE mergeBy #-}
 
 {- $maybes
     These functions discard the 'Nothing's that they encounter. They are analogous
@@ -2855,7 +2855,7 @@ mergeBy cmp = loop
 
 {-| The 'catMaybes' function takes a 'Stream' of 'Maybe's and returns
     a 'Stream' of all of the 'Just' values. 'concat' has the same behavior,
-    but is more general; it works for any foldable container type. 
+    but is more general; it works for any foldable container type.
 -}
 catMaybes :: Monad m => Stream (Of (Maybe a)) m r -> Stream (Of a) m r
 catMaybes = loop where
@@ -2870,7 +2870,7 @@ catMaybes = loop where
 {-| The 'mapMaybe' function is a version of 'map' which can throw out elements. In particular,
     the functional argument returns something of type @'Maybe' b@. If this is 'Nothing', no element
     is added on to the result 'Stream'. If it is @'Just' b@, then @b@ is included in the result 'Stream'.
-    
+
 -}
 mapMaybe :: Monad m => (a -> Maybe b) -> Stream (Of a) m r -> Stream (Of b) m r
 mapMaybe phi = loop where
@@ -2882,9 +2882,9 @@ mapMaybe phi = loop where
       Just b -> Step (b :> loop snext)
 {-# INLINABLE mapMaybe #-}
 
-{-| 'slidingWindow' accumulates the first @n@ elements of a stream, 
+{-| 'slidingWindow' accumulates the first @n@ elements of a stream,
      update thereafter to form a sliding window of length @n@.
-     It follows the behavior of the slidingWindow function in 
+     It follows the behavior of the slidingWindow function in
      <https://hackage.haskell.org/package/conduit-combinators-1.0.4/docs/Data-Conduit-Combinators.html#v:slidingWindow conduit-combinators>.
 
 >>> S.print $ slidingWindow 4 $ S.each "123456"
@@ -2894,25 +2894,25 @@ fromList "3456"
 
 -}
 
-slidingWindow :: Monad m 
-  => Int 
-  -> Stream (Of a) m b 
+slidingWindow :: Monad m
+  => Int
+  -> Stream (Of a) m b
   -> Stream (Of (Seq.Seq a)) m b
-slidingWindow n = setup (max 1 n :: Int) mempty 
-  where 
-    window !sequ str = do 
-      e <- lift (next str) 
-      case e of 
+slidingWindow n = setup (max 1 n :: Int) mempty
+  where
+    window !sequ str = do
+      e <- lift (next str)
+      case e of
         Left r -> return r
-        Right (a,rest) -> do 
+        Right (a,rest) -> do
           yield (sequ Seq.|> a)
           window (Seq.drop 1 $ sequ Seq.|> a) rest
     setup 0 !sequ str = do
-       yield sequ 
-       window (Seq.drop 1 sequ) str 
-    setup m sequ str = do 
-      e <- lift $ next str 
-      case e of 
+       yield sequ
+       window (Seq.drop 1 sequ) str
+    setup m sequ str = do
+      e <- lift $ next str
+      case e of
         Left r ->  yield sequ >> return r
         Right (x,rest) -> setup (m-1) (sequ Seq.|> x) rest
 {-# INLINABLE slidingWindow #-}

streaming.cabal

@@ -4,13 +4,13 @@ cabal-version:       >=1.10
 build-type:          Simple
 synopsis:            an elementary streaming prelude and general stream type.
 
-description:         This package contains two modules, <http://hackage.haskell.org/package/streaming/docs/Streaming.html Streaming> 
+description:         This package contains two modules, <http://hackage.haskell.org/package/streaming/docs/Streaming.html Streaming>
                      and <http://hackage.haskell.org/package/streaming/docs/Streaming-Prelude.html Streaming.Prelude>.
                      The principal module, <http://hackage.haskell.org/package/streaming-0.1.4.3/docs/Streaming-Prelude.html Streaming.Prelude>, exports an elementary streaming prelude focused on
                      a simple \"source\" or \"producer\" type, namely @Stream (Of a) m r@.
                      This is a sort of effectful version of
                      @([a],r)@ in which successive elements of type @a@ arise from some sort of monadic
-                     action before the succession ends with a value of type @r@. 
+                     action before the succession ends with a value of type @r@.
                      Everything in the library is organized to make
                      programming with this type as simple as possible,
                      by the simple expedient of making it as close to @Prelude@
@@ -21,25 +21,25 @@ description:         This package contains two modules, <http://hackage.haskell.
                      > 1<Enter>
                      > 2<Enter>
                      > 3<Enter>
-                     > 6 :> () 
+                     > 6 :> ()
                      .
                      sums the first three valid integers from user input. Similarly,
                      .
-                     > >>> S.stdoutLn $ S.map (map toUpper) $ S.take 2 S.stdinLn 
+                     > >>> S.stdoutLn $ S.map (map toUpper) $ S.take 2 S.stdinLn
                      > hello<Enter>
                      > HELLO
                      > world!<Enter>
                      > WORLD!
                      .
                      upper-cases the first two lines from stdin as they arise,
                      and sends them to stdout. And so on,
-                     with filtering, mapping, breaking, chunking, zipping, unzipping, replicating 
-                     and so forth: 
+                     with filtering, mapping, breaking, chunking, zipping, unzipping, replicating
+                     and so forth:
                      we program with streams of @Int@s or @String@s directly as
                      if they constituted something like a list. That's because streams really do constitute something
-                     like a list, and the associated operations can mostly have the same names. 
-                     (A few, like @reverse@, don't stream and thus disappear; 
-                     others like @unzip@ are here given properly streaming formulation for the first time.) 
+                     like a list, and the associated operations can mostly have the same names.
+                     (A few, like @reverse@, don't stream and thus disappear;
+                     others like @unzip@ are here given properly streaming formulation for the first time.)
                      And we everywhere
                      oppose \"extracting a pure list from IO\",
                      which is the origin of typical Haskell memory catastrophes.
@@ -53,7 +53,7 @@ description:         This package contains two modules, <http://hackage.haskell.
                      .
                      > main = mapM newIORef [1..10^8::Int] >>= mapM readIORef >>= mapM_ print
                      .
-                     The new user notices that this exhausts memory, and worries about the efficiency of Haskell @IORefs@. 
+                     The new user notices that this exhausts memory, and worries about the efficiency of Haskell @IORefs@.
                      But of course it exhausts memory! Look what it says!
                      The problem is immediately cured by writing
                      .
@@ -100,7 +100,7 @@ description:         This package contains two modules, <http://hackage.haskell.
                      elementary streaming library - since one possesses @Stream ((,) a) m r@
                      or equivalently @Stream (Of a) m r@. This
                      is the type of a \'generator\' or \'producer\' or \'source\' or whatever
-                     you call an effectful stream of items. 
+                     you call an effectful stream of items.
                      /The present Streaming.Prelude is thus the simplest streaming library that can replicate anything like the API of the Prelude and Data.List/.
                      .
                      The emphasis of the library is on interoperation; for
@@ -117,7 +117,7 @@ description:         This package contains two modules, <http://hackage.haskell.
                      a complex framework, but in a way that integrates transparently with
                      the rest of Haskell, using ideas - e.g. rank 2 types, which are here
                      implicit or explicit in most mapping - that the user can carry elsewhere,
-                     rather than chaining her understanding to the curiosities of 
+                     rather than chaining her understanding to the curiosities of
                      a so-called streaming IO framework (as necessary as that is for certain purposes.)
                      .
                      See the