Normalize spaces and apply a few hlint-style simplification

Author: sergv

src/Streaming/Internal.hs

@@ -167,15 +167,15 @@ instance (Monad m, Functor f, Eq1 m, Eq1 f) => Eq1 (Stream f m) where
     where
       liftEqExposed (Return x) (Return y) = eq x y
       liftEqExposed (Effect m) (Effect n) = liftEq liftEqExposed m n
-      liftEqExposed (Step f) (Step g) = liftEq liftEqExposed f g
+      liftEqExposed (Step f)   (Step g)   = liftEq liftEqExposed f g
       liftEqExposed _ _ = False
 
 instance (Monad m, Functor f, Ord1 m, Ord1 f) => Ord1 (Stream f m) where
   liftCompare cmp xs ys = liftCmpExposed (unexposed xs) (unexposed ys)
     where
       liftCmpExposed (Return x) (Return y) = cmp x y
       liftCmpExposed (Effect m) (Effect n) = liftCompare liftCmpExposed m n
-      liftCmpExposed (Step f) (Step g) = liftCompare liftCmpExposed f g
+      liftCmpExposed (Step f)   (Step g)   = liftCompare liftCmpExposed f g
       liftCmpExposed (Return _) _ = LT
       liftCmpExposed _ (Return _) = GT
       liftCmpExposed _ _ = error "liftCmpExposed: stream was exposed!"
@@ -200,7 +200,7 @@ instance (Monad m, Show r, Show (m ShowSWrapper), Show (f (Stream f m r)))
     flip fmap (inspect xs) $ \front ->
       SS $ \d -> showParen (d > 10) $
         case front of
-          Left r ->  showString "Return " . showsPrec 11 r
+          Left  r -> showString "Return " . showsPrec 11 r
           Right f -> showString "Step "   . showsPrec 11 f)
 
 #if MIN_VERSION_base(4,9,0)
@@ -212,7 +212,7 @@ instance (Monad m, Functor f, Show (m ShowSWrapper), Show (f ShowSWrapper))
     flip fmap (inspect xs) $ \front ->
       SS $ \d -> showParen (d > 10) $
         case front of
-          Left r ->  showString "Return " . sp 11 r
+          Left  r -> showString "Return " . sp 11 r
           Right f -> showString "Step "   .
                      showsPrec 11 (fmap (SS . (\str i -> liftShowsPrec sp sl i str)) f))
 
@@ -226,18 +226,18 @@ instance (Functor f, Monad m) => Functor (Stream f m) where
   fmap f = loop where
     loop stream = case stream of
       Return r -> Return (f r)
-      Effect m  -> Effect (do {stream' <- m; return (loop stream')})
-      Step g -> Step (fmap loop g)
+      Effect m -> Effect (do {stream' <- m; return (loop stream')})
+      Step   g -> Step (fmap loop g)
   {-# INLINABLE fmap #-}
   a <$ stream0 = loop stream0 where
     loop stream = case stream of
       Return _ -> Return a
       Effect m -> Effect (do {stream' <- m; return (loop stream')})
-      Step f -> Step (fmap loop f)
+      Step   f -> Step (fmap loop f)
   {-# INLINABLE (<$) #-}
 
 instance (Functor f, Monad m) => Monad (Stream f m) where
-  return = Return
+  return = pure
   {-# INLINE return #-}
   (>>) = (*>)
   {-# INLINE (>>) #-}
@@ -248,7 +248,7 @@ instance (Functor f, Monad m) => Monad (Stream f m) where
     loop stream where
     loop stream0 = case stream0 of
       Step fstr -> Step (fmap loop fstr)
-      Effect m   -> Effect (fmap loop m)
+      Effect m  -> Effect (fmap loop m)
       Return r  -> f r
   {-# INLINABLE (>>=) #-}
 
@@ -288,7 +288,7 @@ instance (Functor f, Monad m) => Applicative (Stream f m) where
   stream1 *> stream2 = loop stream1 where
     loop stream = case stream of
       Return _ -> stream2
-      Effect m  -> Effect (fmap loop m)
+      Effect m -> Effect (fmap loop m)
       Step f   -> Step (fmap loop f)
   {-# INLINABLE (*>) #-}
 
@@ -330,17 +330,17 @@ instance Functor f => MonadTrans (Stream f) where
 instance Functor f => MFunctor (Stream f) where
   hoist trans = loop  where
     loop stream = case stream of
-      Return r  -> Return r
-      Effect m   -> Effect (trans (fmap loop m))
-      Step f    -> Step (fmap loop f)
+      Return r -> Return r
+      Effect m -> Effect (trans (fmap loop m))
+      Step f   -> Step (fmap loop f)
   {-# INLINABLE hoist #-}
 
 
 instance Functor f => MMonad (Stream f) where
   embed phi = loop where
     loop stream = case stream of
       Return r -> Return r
-      Effect  m -> phi m >>= loop
+      Effect m -> phi m >>= loop
       Step   f -> Step (fmap loop f)
   {-# INLINABLE embed #-}
 
@@ -371,7 +371,7 @@ instance (Functor f, MonadError e m) => MonadError e (Stream f m) where
     loop x = case x of
       Return r -> Return r
       Effect m -> Effect $ fmap loop m `catchError` (return . f)
-      Step g -> Step (fmap loop g)
+      Step   g -> Step (fmap loop g)
   {-# INLINABLE catchError #-}
 
 {-| Map a stream to its church encoding; compare @Data.List.foldr@.
@@ -390,7 +390,7 @@ destroy stream0 construct theEffect done = theEffect (loop stream0) where
   loop stream = case stream of
     Return r -> return (done r)
     Effect m -> m >>= loop
-    Step fs -> return (construct (fmap (theEffect . loop) fs))
+    Step fs  -> return (construct (fmap (theEffect . loop) fs))
 {-# INLINABLE destroy #-}
 
 
@@ -433,7 +433,7 @@ streamFold done theEffect construct stream  = destroy stream construct theEffect
 
 {- | Reflect a church-encoded stream; cp. @GHC.Exts.build@
 
-> streamFold return_ effect_ step_ (streamBuild psi)  = psi return_ effect_ step_
+> streamFold return_ effect_ step_ (streamBuild psi) = psi return_ effect_ step_
 -}
 streamBuild
   :: (forall b . (r -> b) -> (m b -> b) -> (f b -> b) ->  b) ->  Stream f m r
@@ -453,7 +453,7 @@ inspect :: Monad m =>
 inspect = loop where
   loop stream = case stream of
     Return r -> return (Left r)
-    Effect m  -> m >>= loop
+    Effect m -> m >>= loop
     Step fs  -> return (Right fs)
 {-# INLINABLE inspect #-}
 
@@ -471,9 +471,9 @@ unfold :: (Monad m, Functor f)
 unfold step = loop where
   loop s0 = Effect $ do
     e <- step s0
-    case e of
-      Left r -> return (Return r)
-      Right fs -> return (Step (fmap loop fs))
+    return $ case e of
+       Left  r  -> Return r
+       Right fs -> Step (fmap loop fs)
 {-# INLINABLE unfold #-}
 
 
@@ -488,9 +488,9 @@ maps :: (Monad m, Functor f)
      => (forall x . f x -> g x) -> Stream f m r -> Stream g m r
 maps phi = loop where
   loop stream = case stream of
-    Return r  -> Return r
-    Effect m   -> Effect (fmap loop m)
-    Step f    -> Step (phi (fmap loop f))
+    Return r -> Return r
+    Effect m -> Effect (fmap loop m)
+    Step   f -> Step (phi (fmap loop f))
 {-# INLINABLE maps #-}
 
 
@@ -507,9 +507,9 @@ maps phi = loop where
 mapsM :: (Monad m, Functor f) => (forall x . f x -> m (g x)) -> Stream f m r -> Stream g m r
 mapsM phi = loop where
   loop stream = case stream of
-    Return r  -> Return r
-    Effect m   -> Effect (fmap loop m)
-    Step f    -> Effect (fmap Step (phi (fmap loop f)))
+    Return r -> Return r
+    Effect m -> Effect (fmap loop m)
+    Step   f -> Effect (fmap Step (phi (fmap loop f)))
 {-# INLINABLE mapsM #-}
 
 {- | Map layers of one functor to another with a transformation. Compare
@@ -519,7 +519,6 @@ mapsM phi = loop where
 > mapsPost f . mapsPost g = mapsPost (f . g)
 > mapsPost f = mapsPost f
 
-
      @mapsPost@ is essentially the same as 'maps', but it imposes a 'Functor' constraint on
      its target functor rather than its source functor. It should be preferred if 'fmap'
      is cheaper for the target functor than for the source functor.
@@ -532,7 +531,7 @@ mapsPost phi = loop where
   loop stream = case stream of
     Return r -> Return r
     Effect m -> Effect (fmap loop m)
-    Step f -> Step $ fmap loop $ phi f
+    Step   f -> Step $ fmap loop $ phi f
 {-# INLINABLE mapsPost #-}
 
 {- | Map layers of one functor to another with a transformation involving the base monad.
@@ -557,7 +556,7 @@ mapsMPost phi = loop where
   loop stream = case stream of
     Return r -> Return r
     Effect m -> Effect (fmap loop m)
-    Step f -> Effect $ fmap (Step . fmap loop) (phi f)
+    Step   f -> Effect $ fmap (Step . fmap loop) (phi f)
 {-# INLINABLE mapsMPost #-}
 
 {-| Rearrange a succession of layers of the form @Compose m (f x)@.
@@ -581,7 +580,7 @@ decompose :: (Monad m, Functor f) => Stream (Compose m f) m r -> Stream f m r
 decompose = loop where
   loop stream = case stream of
     Return r -> Return r
-    Effect m ->  Effect (fmap loop m)
+    Effect m -> Effect (fmap loop m)
     Step (Compose mstr) -> Effect $ do
       str <- mstr
       return (Step (fmap loop str))
@@ -592,8 +591,8 @@ decompose = loop where
 run :: Monad m => Stream m m r -> m r
 run = loop where
   loop stream = case stream of
-    Return r -> return r
-    Effect  m -> m >>= loop
+    Return r   -> return r
+    Effect  m  -> m >>= loop
     Step mrest -> mrest >>= loop
 {-# INLINABLE run #-}
 
@@ -614,16 +613,16 @@ intercalates :: (Monad m, Monad (t m), MonadTrans t) =>
 intercalates sep = go0
   where
     go0 f = case f of
-      Return r -> return r
-      Effect m -> lift m >>= go0
+      Return r  -> return r
+      Effect m  -> lift m >>= go0
       Step fstr -> do
         f' <- fstr
         go1 f'
     go1 f = case f of
-      Return r -> return r
-      Effect m     -> lift m >>= go1
+      Return r  -> return r
+      Effect m  -> lift m >>= go1
       Step fstr ->  do
-        _ <- sep
+        _  <- sep
         f' <- fstr
         go1 f'
 {-# INLINABLE intercalates #-}
@@ -657,7 +656,7 @@ concats :: (Monad m, Functor f) => Stream (Stream f m) m r -> Stream f m r
 concats  = loop where
   loop stream = case stream of
     Return r -> return r
-    Effect m  -> lift m >>= loop
+    Effect m -> lift m >>= loop
     Step fs  -> fs >>= loop
 {-# INLINE concats #-}
 
@@ -687,11 +686,11 @@ concats  = loop where
 splitsAt :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m (Stream f m r)
 splitsAt  = loop  where
   loop !n stream
-    | n <= 0 = Return stream
+    | n <= 0    = Return stream
     | otherwise = case stream of
-        Return r       -> Return (Return r)
-        Effect m        -> Effect (fmap (loop n) m)
-        Step fs        -> case n of
+        Return r -> Return (Return r)
+        Effect m -> Effect (fmap (loop n) m)
+        Step fs  -> case n of
           0 -> Return (Step fs)
           _ -> Step (fmap (loop (n-1)) fs)
 {-# INLINABLE splitsAt #-}
@@ -755,14 +754,14 @@ distribute = loop where
 -- | Repeat a functorial layer (a \"command\" or \"instruction\") forever.
 repeats :: (Monad m, Functor f) => f () -> Stream f m r
 repeats f = loop where
-  loop = Effect (return (Step (fmap (\_ -> loop) f)))
+  loop = Effect (return (Step (loop <$ f)))
 
 -- | Repeat an effect containing a functorial layer, command or instruction forever.
 repeatsM :: (Monad m, Functor f) => m (f ()) -> Stream f m r
 repeatsM mf = loop where
   loop = Effect $ do
      f <- mf
-     return $ Step $ fmap (\_ -> loop) f
+     return $ Step $ loop <$ f
 
 {- | Repeat a functorial layer, command or instruction a fixed number of times.
 
@@ -796,7 +795,7 @@ hoistUnexposed trans = loop where
 inspectC :: Monad m => (r -> m a) -> (f (Stream f m r) -> m a) -> Stream f m r -> m a
 inspectC f g = loop where
   loop (Return r) = f r
-  loop (Step x) = g x
+  loop (Step x)   = g x
   loop (Effect m) = m >>= loop
 {-# INLINE inspectC #-}
 
@@ -806,9 +805,9 @@ inspectC f g = loop where
 hoistExposed :: (Functor m, Functor f) => (forall b. m b -> n b) -> Stream f m a -> Stream f n a
 hoistExposed trans = loop where
   loop stream = case stream of
-    Return r  -> Return r
-    Effect m   -> Effect (trans (fmap loop m))
-    Step f    -> Step (fmap loop f)
+    Return r -> Return r
+    Effect m -> Effect (trans (fmap loop m))
+    Step f   -> Step (fmap loop f)
 {-# INLINABLE hoistExposed #-}
 
 -- | The same as 'hoistExposed', but with a 'Functor' constraint on
@@ -819,7 +818,7 @@ hoistExposedPost trans = loop where
   loop stream = case stream of
     Return r -> Return r
     Effect m -> Effect (fmap loop (trans m))
-    Step f -> Step (fmap loop f)
+    Step   f -> Step (fmap loop f)
 {-# INLINABLE hoistExposedPost #-}
 
 {-# DEPRECATED mapsExposed "Use maps instead." #-}
@@ -852,7 +851,7 @@ destroyExposed
 destroyExposed stream0 construct theEffect done = loop stream0 where
   loop stream = case stream of
     Return r -> done r
-    Effect m  -> theEffect (fmap loop m)
+    Effect m -> theEffect (fmap loop m)
     Step fs  -> construct (fmap loop fs)
 {-# INLINABLE destroyExposed #-}
 
@@ -866,7 +865,7 @@ unexposed :: (Functor f, Monad m) => Stream f m r -> Stream f m r
 unexposed = Effect . loop where
   loop stream = case stream of
     Return r -> return (Return r)
-    Effect  m -> m >>= loop
+    Effect m -> m >>= loop
     Step   f -> return (Step (fmap (Effect . loop) f))
 {-# INLINABLE unexposed #-}
 
@@ -1101,7 +1100,7 @@ expand :: (Monad m, Functor f)
        -> Stream f m r -> Stream g (Stream h m) r
 expand ext = loop where
   loop (Return r) = Return r
-  loop (Step f) = Effect $ Step $ ext (Return . Step) (fmap loop f)
+  loop (Step f)   = Effect $ Step $ ext (Return . Step) (fmap loop f)
   loop (Effect m) = Effect $ Effect $ fmap (Return . loop) m
 {-# INLINABLE expand #-}
 
@@ -1116,7 +1115,7 @@ expandPost :: (Monad m, Functor g)
        -> Stream f m r -> Stream g (Stream h m) r
 expandPost ext = loop where
   loop (Return r) = Return r
-  loop (Step f) = Effect $ Step $ ext (Return . Step . fmap loop) f
+  loop (Step f)   = Effect $ Step $ ext (Return . Step . fmap loop) f
   loop (Effect m) = Effect $ Effect $ fmap (Return . loop) m
 {-# INLINABLE expandPost #-}
 
@@ -1347,9 +1346,9 @@ untilJust :: (Monad m, Applicative f) => m (Maybe r) -> Stream f m r
 untilJust act = loop where
   loop = Effect $ do
     m <- act
-    case m of
-      Nothing -> return $ Step $ pure loop
-      Just a -> return $ Return a
+    return $ case m of
+      Nothing -> Step $ pure loop
+      Just a  -> Return a
 
 
 cutoff :: (Monad m, Functor f) => Int -> Stream f m r -> Stream f m (Maybe r)

src/Streaming/Prelude.hs

@@ -1117,7 +1117,7 @@ for :: (Monad m, Functor f) => Stream (Of a) m r -> (a -> Stream f m x) -> Strea
 for str0 act = loop str0 where
   loop str = case str of
     Return r         -> Return r
-    Effect m          -> Effect $ fmap loop m
+    Effect m         -> Effect $ fmap loop m
     Step (a :> rest) -> act a *> loop rest
 {-# INLINABLE for #-}
 
@@ -1329,7 +1329,7 @@ mapM :: Monad m => (a -> m b) -> Stream (Of a) m r -> Stream (Of b) m r
 mapM f = loop where
   loop str = case str of
     Return r       -> Return r
-    Effect m        -> Effect (fmap loop m)
+    Effect m       -> Effect (fmap loop m)
     Step (a :> as) -> Effect $ do
       a' <- f a
       return (Step (a' :> loop as) )