diff --git a/colonnade.cabal b/colonnade.cabal
--- a/colonnade.cabal
+++ b/colonnade.cabal
@@ -1,5 +1,5 @@
 name:                colonnade
-version:             0.4
+version:             0.4.1
 synopsis:            Generic types and functions for columnar encoding and decoding
 description:         Please see README.md
 homepage:            https://github.com/andrewthad/colonnade#readme
diff --git a/src/Colonnade/Encoding.hs b/src/Colonnade/Encoding.hs
--- a/src/Colonnade/Encoding.hs
+++ b/src/Colonnade/Encoding.hs
@@ -2,7 +2,9 @@
 
 import Colonnade.Types
 import Data.Vector (Vector)
+import Data.Foldable
 import qualified Data.Vector as Vector
+import qualified Colonnade.Internal as Internal
 
 mapContent :: Functor f => (c1 -> c2) -> Encoding f c1 a -> Encoding f c2 a
 mapContent f (Encoding v) = Encoding
@@ -29,10 +31,25 @@
               -> (content -> m b)
               -> a
               -> m b
-runRowMonadic (Encoding v) g a = fmap (mconcat . Vector.toList) 
-  $ Vector.forM v 
+runRowMonadic (Encoding v) g a =
+  --   fmap (mconcat . Vector.toList)
+  -- $ Vector.forM v
+  flip Internal.foldMapM v
   $ \e -> g (oneEncodingEncode e a)
 
+runRowMonadicWith :: (Monad m)
+              => b
+              -> (b -> b -> b)
+              -> Encoding f content a
+              -> (content -> m b)
+              -> a
+              -> m b
+runRowMonadicWith bempty bappend (Encoding v) g a =
+  foldrM (\e br -> do
+    bl <- g (oneEncodingEncode e a)
+    return (bappend bl br)
+  ) bempty v
+
 runHeader :: (c1 -> c2) -> Encoding Headed c1 a -> Vector c2
 runHeader g (Encoding v) =
   Vector.map (g . getHeaded . oneEncodingHead) v
@@ -44,14 +61,23 @@
 runHeaderMonadic (Encoding v) g =
   fmap (mconcat . Vector.toList) $ Vector.mapM (g . getHeaded . oneEncodingHead) v
 
+runHeaderMonadic_ ::
+     (Monad m)
+  => Encoding Headed content a
+  -> (content -> m b)
+  -> m ()
+runHeaderMonadic_ (Encoding v) g = Vector.mapM_ (g . getHeaded . oneEncodingHead) v
+
 fromMaybe :: c -> Encoding f c a -> Encoding f c (Maybe a)
 fromMaybe c (Encoding v) = Encoding $ flip Vector.map v $
   \(OneEncoding h encode) -> OneEncoding h (maybe c encode)
 
 columns :: (b -> a -> c)
-        -> (b -> f c) 
-        -> Vector b 
+        -> (b -> f c)
+        -> Vector b
         -> Encoding f c a
 columns getCell getHeader bs =
   Encoding $ Vector.map (\b -> OneEncoding (getHeader b) (getCell b)) bs
+
+
 
diff --git a/src/Colonnade/Internal.hs b/src/Colonnade/Internal.hs
--- a/src/Colonnade/Internal.hs
+++ b/src/Colonnade/Internal.hs
@@ -1,6 +1,8 @@
 {-# LANGUAGE DeriveFunctor #-}
 module Colonnade.Internal where
 
+import Data.Foldable (foldrM)
+
 newtype EitherWrap a b = EitherWrap
   { getEitherWrap :: Either a b
   } deriving (Functor)
@@ -15,3 +17,7 @@
 mapLeft :: (a -> b) -> Either a c -> Either b c
 mapLeft _ (Right a) = Right a
 mapLeft f (Left a) = Left (f a)
+
+foldMapM :: (Foldable t, Monoid b, Monad m) => (a -> m b) -> t a -> m b
+foldMapM f = foldrM (\a b -> fmap (flip mappend b) (f a)) mempty
+