Merge pull request #33 from sergv/fix-build-with-7.10.3-and-doctests

Fix build with 7.10.3 and fix doctests

Author: chessai

src/Data/Functor/Of.hs

@@ -1,18 +1,19 @@
 {-# LANGUAGE CPP, DeriveDataTypeable, DeriveTraversable, DeriveFoldable,
        DeriveGeneric #-}
-module Data.Functor.Of where
+module Data.Functor.Of (Of(..)) where
 import Data.Monoid (Monoid (..))
 import Data.Semigroup (Semigroup (..))
 import Control.Applicative
 import Data.Traversable (Traversable)
 import Data.Foldable (Foldable)
-#if MIN_VERSION_base(4,8,0)
 import Data.Bifunctor
-#endif
 import Data.Data
-import Data.Typeable
-import GHC.Generics (Generic, Generic1)
+#if MIN_VERSION_base(4,9,0)
 import Data.Functor.Classes
+import Data.Foldable (Foldable)
+import Data.Traversable (Traversable)
+#endif
+import GHC.Generics (Generic, Generic1)
 
 -- | A left-strict pair; the base functor for streams of individual elements.
 data Of a b = !a :> b
@@ -35,7 +36,7 @@ instance (Monoid a, Monoid b) => Monoid (Of a b) where
 instance Functor (Of a) where
   fmap f (a :> x) = a :> f x
   {-#INLINE fmap #-}
-  a <$ (b :> x)   = b :> a
+  a <$ (b :> _)   = b :> a
   {-#INLINE (<$) #-}
 
 #if MIN_VERSION_base(4,8,0)
@@ -51,40 +52,43 @@ instance Bifunctor Of where
 instance Monoid a => Applicative (Of a) where
   pure x = mempty :> x
   {-#INLINE pure #-}
-  m :> f <*> m' :> x = mappend m m' :> f x
+  (m :> f) <*> (m' :> x) = mappend m m' :> f x
   {-#INLINE (<*>) #-}
-  m :> x *> m' :> y  = mappend m m' :> y
+  (m :> _) *> (m' :> y)  = mappend m m' :> y
   {-#INLINE (*>) #-}
-  m :> x <* m' :> y  = mappend m m' :> x
+  (m :> x) <* (m' :> _)  = mappend m m' :> x
   {-#INLINE (<*) #-}
 
 instance Monoid a => Monad (Of a) where
-  return x = mempty :> x
+  return = pure
   {-#INLINE return #-}
-  m :> x >> m' :> y = mappend m m' :> y
+  (m :> _) >> (m' :> y) = mappend m m' :> y
   {-#INLINE (>>) #-}
-  m :> x >>= f = let m' :> y = f x in mappend m m' :> y
+  (m :> x) >>= f = let m' :> y = f x in mappend m m' :> y
   {-#INLINE (>>=) #-}
 
+#if MIN_VERSION_base(4,9,0)
 instance Show a => Show1 (Of a) where
   liftShowsPrec = liftShowsPrec2 showsPrec showList
 
+instance Eq a => Eq1 (Of a) where
+  liftEq = liftEq2 (==)
+
+instance Ord a => Ord1 (Of a) where
+  liftCompare = liftCompare2 compare
+
 instance Show2 Of where
   liftShowsPrec2 spa _sla spb _slb p (a :> b) =
     showParen (p > 5) $
     spa 6 a .
     showString " :> " .
     spb 6 b
 
-instance Eq a => Eq1 (Of a) where
-  liftEq = liftEq2 (==)
-
-instance Ord a => Ord1 (Of a) where
-  liftCompare = liftCompare2 compare
-
 instance Eq2 Of where
-  liftEq2 eq1 eq2 (x :> y) (z :> w) = eq1 x z && eq2 y w
+  liftEq2 f g (x :> y) (z :> w) = f x z && g y w
 
 instance Ord2 Of where
   liftCompare2 comp1 comp2 (x :> y) (z :> w) =
     comp1 x z `mappend` comp2 y w
+#endif
+

src/Streaming.hs

@@ -1,6 +1,5 @@
 {-# LANGUAGE RankNTypes #-}
 
-{-# OPTIONS_GHC -Wall #-}
 module Streaming
    (
    -- * An iterable streaming monad transformer
@@ -115,10 +114,10 @@ import Data.Bifunctor
     Some of these are quite abstract and pervade any use of the library,
     e.g.
 
->   maps ::    (forall x . f x -> g x)     -> Stream f m r -> Stream g m r
->   mapped ::  (forall x . f x -> m (g x)) -> Stream f m r -> Stream g m r
->   hoist ::   (forall x . m x -> n x)     -> Stream f m r -> Stream f n r -- from the MFunctor instance
->   concats :: Stream (Stream f m) m r -> Stream f m r   
+>   maps    :: (forall x . f x -> g x)     -> Stream f m r -> Stream g m r
+>   mapped  :: (forall x . f x -> m (g x)) -> Stream f m r -> Stream g m r
+>   hoist   :: (forall x . m x -> n x)     -> Stream f m r -> Stream f n r -- from the MFunctor instance
+>   concats :: Stream (Stream f m) m r     -> Stream f m r
 
     (assuming here and thoughout that @m@ or @n@ satisfies a @Monad@ constraint, and
     @f@ or @g@ a @Functor@ constraint.)
@@ -128,9 +127,9 @@ import Data.Bifunctor
 >   chunksOf     :: Int -> Stream f m r -> Stream (Stream f m) m r
 >   splitsAt     :: Int -> Stream f m r -> Stream f m (Stream f m r)
 >   zipsWith     :: (forall x y. f x -> g y -> h (x, y))
-                 -> Stream f m r -> Stream g m r -> Stream h m r
+>                -> Stream f m r -> Stream g m r -> Stream h m r
 >   zipsWith'    :: (forall x y p. (x -> y -> p) -> f x -> g y -> h p)
-                 -> Stream f m r -> Stream g m r -> Stream h m r
+>                -> Stream f m r -> Stream g m r -> Stream h m r
 >   intercalates :: Stream f m () -> Stream (Stream f m) m r -> Stream f m r
 >   unzips       :: Stream (Compose f g) m r ->  Stream f (Stream g m) r
 >   separate     :: Stream (Sum f g) m r -> Stream f (Stream g) m r  -- cp. partitionEithers