import GHC.Arr
#elif defined(__HUGS__)
import Hugs.Array
+#elif defined(__NHC__)
+import Array
#endif
-- | Data structures that can be folded.
-- instances for Prelude types
instance Foldable Maybe where
- foldr f z Nothing = z
+ foldr _ z Nothing = z
foldr f z (Just x) = f x z
- foldl f z Nothing = z
+ foldl _ z Nothing = z
foldl f z (Just x) = f z x
instance Foldable [] where
foldr1 = Prelude.foldr1
foldl1 = Prelude.foldl1
-#ifndef __NHC__
instance Ix i => Foldable (Array i) where
- foldr f z = Prelude.foldr f z . elems
-#endif
+ foldr f z = Prelude.foldr f z . elems
-- | Fold over the elements of a structure,
-- associating to the right, but strictly.
foldr' :: Foldable t => (a -> b -> b) -> b -> t a -> b
-foldr' f z xs = foldl f' id xs z
+foldr' f z0 xs = foldl f' id xs z0
where f' k x z = k $! f x z
-- | Monadic fold over the elements of a structure,
-- associating to the right, i.e. from right to left.
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
-foldrM f z xs = foldl f' return xs z
+foldrM f z0 xs = foldl f' return xs z0
where f' k x z = f x z >>= k
-- | Fold over the elements of a structure,
-- associating to the left, but strictly.
foldl' :: Foldable t => (a -> b -> a) -> a -> t b -> a
-foldl' f z xs = foldr f' id xs z
+foldl' f z0 xs = foldr f' id xs z0
where f' x k z = k $! f z x
-- | Monadic fold over the elements of a structure,
-- associating to the left, i.e. from left to right.
foldlM :: (Foldable t, Monad m) => (a -> b -> m a) -> a -> t b -> m a
-foldlM f z xs = foldr f' return xs z
+foldlM f z0 xs = foldr f' return xs z0
where f' x k z = f z x >>= k
-- | Map each element of a structure to an action, evaluate