From 53004f977617674ddec5d7315f0be92e0358ae7d Mon Sep 17 00:00:00 2001
From: Ross Paterson <ross@soi.city.ac.uk>
Date: Wed, 30 Aug 2006 13:38:05 +0000
Subject: [PATCH] add Data.Foldable.{for_,forM_} and
 Data.Traversable.{for,forM}

generalizing Control.Monad.{forM_,forM}
---
 Data/Foldable.hs    |   12 ++++++++++++
 Data/Traversable.hs |   12 ++++++++++++
 2 files changed, 24 insertions(+)

diff --git a/Data/Foldable.hs b/Data/Foldable.hs
index e624c1e..28cc6fa 100644
--- a/Data/Foldable.hs
+++ b/Data/Foldable.hs
@@ -26,7 +26,9 @@ module Data.Foldable (
 	foldlM,
 	-- ** Folding actions
 	traverse_,
+	for_,
 	mapM_,
+	forM_,
 	sequenceA_,
 	sequence_,
 	-- ** Specialized folds
@@ -169,11 +171,21 @@ foldlM f z xs = foldr f' return xs z
 traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
 traverse_ f = foldr ((*>) . f) (pure ())
 
+-- | 'for_' is 'traverse_' with its arguments flipped.
+for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
+{-# INLINE for_ #-}
+for_ = flip traverse_
+
 -- | Map each element of a structure to an monadic action, evaluate
 -- these actions from left to right, and ignore the results.
 mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
 mapM_ f = foldr ((>>) . f) (return ())
 
+-- | 'forM_' is 'mapM_' with its arguments flipped.
+forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
+{-# INLINE forM_ #-}
+forM_ = flip mapM_
+
 -- | Evaluate each action in the structure from left to right,
 -- and ignore the results.
 sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
diff --git a/Data/Traversable.hs b/Data/Traversable.hs
index 14edb79..c2c6033 100644
--- a/Data/Traversable.hs
+++ b/Data/Traversable.hs
@@ -29,6 +29,8 @@
 
 module Data.Traversable (
 	Traversable(..),
+	for,
+	forM,
 	fmapDefault,
 	foldMapDefault,
 	) where
@@ -106,6 +108,16 @@ instance Ix i => Traversable (Array i) where
 
 -- general functions
 
+-- | 'for' is 'traverse' with its arguments flipped.
+for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
+{-# INLINE for #-}
+for = flip traverse
+
+-- | 'forM' is 'mapM' with its arguments flipped.
+forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
+{-# INLINE forM #-}
+forM = flip mapM
+
 -- | This function may be used as a value for `fmap` in a `Functor` instance.
 fmapDefault :: Traversable t => (a -> b) -> t a -> t b
 fmapDefault f = getId . traverse (Id . f)
-- 
1.7.10.4