specialized null and length methods where possible
authorRoss Paterson <ross@soi.city.ac.uk>
Sun, 6 Nov 2016 17:26:04 +0000 (17:26 +0000)
committerRoss Paterson <ross@soi.city.ac.uk>
Sun, 6 Nov 2016 17:26:04 +0000 (17:26 +0000)
Control/Applicative/Backwards.hs
Control/Monad/Trans/Identity.hs
Control/Monad/Trans/Writer/Lazy.hs
Control/Monad/Trans/Writer/Strict.hs
Data/Functor/Constant.hs
Data/Functor/Reverse.hs

index 16e9fe9..ebb8a0b 100644 (file)
@@ -28,7 +28,7 @@ module Control.Applicative.Backwards (
 
 import Data.Functor.Classes
 
-import Prelude hiding (foldr, foldr1, foldl, foldl1)
+import Prelude hiding (foldr, foldr1, foldl, foldl1, null, length)
 import Control.Applicative
 import Data.Foldable
 import Data.Traversable
@@ -89,6 +89,10 @@ instance (Foldable f) => Foldable (Backwards f) where
     {-# INLINE foldr1 #-}
     foldl1 f (Backwards t) = foldl1 f t
     {-# INLINE foldl1 #-}
+#if MIN_VERSION_base(4,8,0)
+    null (Backwards t) = null t
+    length (Backwards t) = length t
+#endif
 
 -- | Derived instance.
 instance (Traversable f) => Traversable (Backwards f) where
index 77a9050..878a6ef 100644 (file)
@@ -46,8 +46,9 @@ import Control.Monad.Fix (MonadFix(mfix))
 #if MIN_VERSION_base(4,4,0)
 import Control.Monad.Zip (MonadZip(mzipWith))
 #endif
-import Data.Foldable (Foldable(foldMap))
+import Data.Foldable
 import Data.Traversable (Traversable(traverse))
+import Prelude hiding (foldr, foldr1, foldl, foldl1, null, length)
 
 -- | The trivial monad transformer, which maps a monad to an equivalent monad.
 newtype IdentityT f a = IdentityT { runIdentityT :: f a }
@@ -78,8 +79,20 @@ instance (Functor m) => Functor (IdentityT m) where
     {-# INLINE fmap #-}
 
 instance (Foldable f) => Foldable (IdentityT f) where
-    foldMap f (IdentityT a) = foldMap f a
+    foldMap f (IdentityT t) = foldMap f t
     {-# INLINE foldMap #-}
+    foldr f z (IdentityT t) = foldr f z t
+    {-# INLINE foldr #-}
+    foldl f z (IdentityT t) = foldl f z t
+    {-# INLINE foldl #-}
+    foldr1 f (IdentityT t) = foldr1 f t
+    {-# INLINE foldr1 #-}
+    foldl1 f (IdentityT t) = foldl1 f t
+    {-# INLINE foldl1 #-}
+#if MIN_VERSION_base(4,8,0)
+    null (IdentityT t) = null t
+    length (IdentityT t) = length t
+#endif
 
 instance (Traversable f) => Traversable (IdentityT f) where
     traverse f (IdentityT a) = IdentityT <$> traverse f a
index 7af38dc..c7f689c 100644 (file)
@@ -64,9 +64,10 @@ import Control.Monad.Signatures
 #if MIN_VERSION_base(4,4,0)
 import Control.Monad.Zip (MonadZip(mzipWith))
 #endif
-import Data.Foldable (Foldable(foldMap))
+import Data.Foldable
 import Data.Monoid
 import Data.Traversable (Traversable(traverse))
+import Prelude hiding (null, length)
 
 -- ---------------------------------------------------------------------------
 -- | A writer monad parameterized by the type @w@ of output to accumulate.
@@ -167,6 +168,10 @@ instance (Functor m) => Functor (WriterT w m) where
 instance (Foldable f) => Foldable (WriterT w f) where
     foldMap f = foldMap (f . fst) . runWriterT
     {-# INLINE foldMap #-}
+#if MIN_VERSION_base(4,8,0)
+    null (WriterT t) = null t
+    length (WriterT t) = length t
+#endif
 
 instance (Traversable f) => Traversable (WriterT w f) where
     traverse f = fmap WriterT . traverse f' . runWriterT where
index b4bfba6..33058af 100644 (file)
@@ -67,9 +67,10 @@ import Control.Monad.Signatures
 #if MIN_VERSION_base(4,4,0)
 import Control.Monad.Zip (MonadZip(mzipWith))
 #endif
-import Data.Foldable (Foldable(foldMap))
+import Data.Foldable
 import Data.Monoid
 import Data.Traversable (Traversable(traverse))
+import Prelude hiding (null, length)
 
 -- ---------------------------------------------------------------------------
 -- | A writer monad parameterized by the type @w@ of output to accumulate.
@@ -170,6 +171,10 @@ instance (Functor m) => Functor (WriterT w m) where
 instance (Foldable f) => Foldable (WriterT w f) where
     foldMap f = foldMap (f . fst) . runWriterT
     {-# INLINE foldMap #-}
+#if MIN_VERSION_base(4,8,0)
+    null (WriterT t) = null t
+    length (WriterT t) = length t
+#endif
 
 instance (Traversable f) => Traversable (WriterT w f) where
     traverse f = fmap WriterT . traverse f' . runWriterT where
index e70f67d..3158bd9 100644 (file)
@@ -28,12 +28,13 @@ module Data.Functor.Constant (
 import Data.Functor.Classes
 
 import Control.Applicative
-import Data.Foldable (Foldable(foldMap))
+import Data.Foldable
 import Data.Monoid (Monoid(..))
 import Data.Traversable (Traversable(traverse))
 #if MIN_VERSION_base(4,8,0)
 import Data.Bifunctor (Bifunctor(..))
 #endif
+import Prelude hiding (null, length)
 
 -- | Constant functor.
 newtype Constant a b = Constant { getConstant :: a }
@@ -86,6 +87,10 @@ instance Functor (Constant a) where
 instance Foldable (Constant a) where
     foldMap _ (Constant _) = mempty
     {-# INLINE foldMap #-}
+#if MIN_VERSION_base(4,8,0)
+    null (Constant _) = True
+    length (Constant _) = 0
+#endif
 
 instance Traversable (Constant a) where
     traverse _ (Constant x) = pure (Constant x)
index 19196e6..ee8be9c 100644 (file)
@@ -29,7 +29,7 @@ module Data.Functor.Reverse (
 import Control.Applicative.Backwards
 import Data.Functor.Classes
 
-import Prelude hiding (foldr, foldr1, foldl, foldl1)
+import Prelude hiding (foldr, foldr1, foldl, foldl1, null, length)
 import Control.Applicative
 import Data.Foldable
 import Data.Traversable
@@ -91,6 +91,10 @@ instance (Foldable f) => Foldable (Reverse f) where
     {-# INLINE foldr1 #-}
     foldl1 f (Reverse t) = foldr1 (flip f) t
     {-# INLINE foldl1 #-}
+#if MIN_VERSION_base(4,8,0)
+    null (Reverse t) = null t
+    length (Reverse t) = length t
+#endif
 
 -- | Traverse from right to left.
 instance (Traversable f) => Traversable (Reverse f) where