diff --git a/Control/Monad/Constrictor.hs b/Control/Monad/Constrictor.hs
new file mode 100644
--- /dev/null
+++ b/Control/Monad/Constrictor.hs
@@ -0,0 +1,127 @@
+{-# LANGUAGE CPP                        #-}
+{-# LANGUAGE DeriveFoldable             #-}
+{-# LANGUAGE DeriveFunctor              #-}
+{-# LANGUAGE DeriveGeneric              #-}
+{-# LANGUAGE DeriveTraversable          #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE ScopedTypeVariables        #-}
+
+module Control.Monad.Constrictor
+  ( 
+  -- * strict monadic functions 
+    (<$!>)
+  , fmap'
+  , liftM'
+  , liftM2'
+  , mapM'
+ 
+  -- * strict applicative functions
+  , traverse'
+  
+  -- * a wrapped applicative functor
+  , Ap(..)
+  
+  -- * strict monadic folds
+  , foldlMapM'
+  , foldrMapM'
+  
+  -- * non-strict applicative folds for completeness 
+  , foldlMapA
+  , foldrMapA
+  ) where
+
+import Control.Applicative
+import Control.Monad ((<$!>))
+import Control.Monad.Trans.Cont (evalCont, cont)
+import Data.Foldable
+import Data.Functor.Compose (Compose(..))
+import Data.Monoid hiding ((<>))
+import Data.Semigroup
+import Data.Traversable (traverse)
+import GHC.Generics (Generic,Generic1)
+
+-- A wrapped Applicative Functor.
+newtype Ap f a = Ap { getAp :: f a }
+  deriving (Applicative,Eq,Foldable,Functor,Generic,Generic1
+           ,Monad,Ord,Read,Show,Traversable)
+
+instance (Applicative f, Semigroup a) => Semigroup (Ap f a) where
+  (Ap x) <> (Ap y) = Ap $ liftA2 (<>) x y
+
+instance (Applicative f, Monoid a) => Monoid (Ap f a) where
+  mempty = Ap $ pure mempty
+#if !(MIN_VERSION_base(4,11,0))
+  mappend (Ap x) (Ap y) = Ap $ liftA2 (mappend) x y
+#endif
+
+-- | Lazy in the monoidal accumulator. Monoidal accumulation
+--   happens from left to right.
+foldlMapA :: forall t b a f. (Foldable t, Monoid b, Applicative f) => (a -> f b) -> t a -> f b
+foldlMapA f = foldr f' (pure mempty)
+  where
+    f' :: a -> f b -> f b
+    f' x y = liftA2 mappend (f x) y
+
+-- | Lazy in the monoidal accumulator. Monoidal accumulation
+--   happens from left to right.
+foldrMapA :: forall t b a f. (Foldable t, Monoid b, Applicative f) => (a -> f b) -> t a -> f b
+foldrMapA f = foldl f' (pure mempty)
+  where
+    f' :: f b -> a -> f b
+    f' y x = liftA2 (flip mappend) (f x) y
+
+-- | Strict in the monoidal accumulator.
+--   For monads strict in the left argument of bind,
+--   this will run in constant space.
+--   Monoidal accumulation happens from left to right.
+foldlMapM' :: forall t b a m. (Foldable t, Monoid b, Monad m) => (a -> m b) -> t a -> m b
+foldlMapM' f xs = foldr f' pure xs mempty
+  where
+  f' :: a -> (b -> m b) -> b -> m b
+  f' x k bl = do
+    br <- f x
+    k $! (mappend bl br) 
+
+-- Strict in the monoidal accumulator. 
+-- Monoidal accumulation happens from left to right.
+foldrMapM' :: forall t b a m. (Foldable t, Monoid b, Monad m) => (a -> m b) -> t a -> m b
+foldrMapM' f xs = foldl f' pure xs mempty
+  where
+  f' :: (b -> m b) -> a -> b -> m b
+  f' k x br = do
+    bl <- f x
+    k $! (mappend bl br) 
+
+-- | Strict version of 'Data.Functor.fmap'.
+--
+-- Note this is equivalent to 'Control.Monad.<$!>',
+-- and is provided for convenience.
+fmap' :: Monad m => (a -> b) -> m a -> m b
+fmap' = (<$!>)
+
+-- | Strict version of 'Control.Monad.liftM'.
+--
+-- Note this is equivalent to 'Control.Monad.<$!>',
+-- and is provided for convenience.
+liftM' :: Monad m => (a -> b) -> m a -> m b
+liftM' = (<$!>)
+
+-- | Strict version of 'Control.Monad.liftM2'.
+--
+liftM2' :: Monad m => (a -> b -> c) -> m a -> m b -> m c
+liftM2' f a b = do
+  x <- a
+  y <- b
+  pure $! f x y
+
+-- | Strict version of 'Data.Traversable.traverse'.
+--
+-- Note the increased constraint from 'Functor' to 'Applicative'.
+traverse' :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
+traverse' f = fmap evalCont . getCompose . traverse (Compose . fmap (\a -> cont $ \k -> k $! a) . f)
+
+-- | Strict version of 'Control.Monad.mapM'.
+--
+-- This is just 'traverse'' specialised to 'Monad'.
+mapM' :: (Traversable t, Monad m) => (a -> m b) -> t a-> m (t b)
+mapM' = traverse'
diff --git a/constrictor.cabal b/constrictor.cabal
--- a/constrictor.cabal
+++ b/constrictor.cabal
@@ -1,21 +1,22 @@
 name:                constrictor
-version:             0.1.0.0
+version:             0.1.0.1
 synopsis:            strict versions of many things in base
--- description:         
+description:         strict versions of many functions in base,
+                     including some functions not present, such
+                     as foldlMapA/M, foldrMapA/M.
 homepage:            https://github.com/chessai/constrictor.git
 license:             MIT
 license-file:        LICENSE
 author:              chessai
 maintainer:          chessai1996@gmail.com
--- copyright:           
+copyright:           2018 (c) chessai 
 category:            Control
 build-type:          Simple
 extra-source-files:  ChangeLog.md
 cabal-version:       >=1.10
 
 library
-  -- exposed-modules:     
-  -- other-modules:       
-  -- other-extensions:    
+  exposed-modules:     Control.Monad.Constrictor 
   build-depends:       base >=4.7 && < 5.0
+                     , transformers 
   default-language:    Haskell2010