diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,11 @@
+# composition-prelude
+
+# 1.5.2.0
+
+  * Add monadic versions of various composition operators.
+  * Performance improvements related to the inliner
+
+# 1.5.1.0
+
+  * Add `threadM`
+  * Generalize `thread` to work on any `Foldable` of functions
diff --git a/composition-prelude.cabal b/composition-prelude.cabal
--- a/composition-prelude.cabal
+++ b/composition-prelude.cabal
@@ -1,6 +1,6 @@
 cabal-version: 1.18
 name: composition-prelude
-version: 1.5.1.0
+version: 1.5.2.0
 license: BSD3
 license-file: LICENSE
 copyright: Copyright: (c) 2017-2018 Vanessa McHale
@@ -14,6 +14,7 @@
 category: Control, Data
 build-type: Simple
 extra-doc-files: README.md
+                 CHANGELOG.md
 
 source-repository head
     type: darcs
diff --git a/src/Control/Composition.hs b/src/Control/Composition.hs
--- a/src/Control/Composition.hs
+++ b/src/Control/Composition.hs
@@ -10,6 +10,19 @@
     , (-.**)
     , (-.***)
     , (-.****)
+    -- * Monadic composition
+    , (<=<)
+    , (>=>)
+    -- * Monadic postcomposition
+    , (<=*<)
+    , (<=**<)
+    , (>=**>)
+    , (>=*>)
+    -- * Monadic precomposition
+    , (<-=*<)
+    , (>-=*>)
+    , (<-=**<)
+    , (>-=**>)
     -- * Fancy function application
     , (-$)
     -- * Monadic helpers
@@ -59,36 +72,82 @@
 
 -- | Backwards function application
 (-$) :: (a -> b -> c) -> b -> a -> c
-(-$) f x y = f y x
+(-$) = flip
 
 -- | As an example:
 --
 -- > λ:> ((*2) .* (+)) 1 3 4
 -- > 16
 (.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
-(.*) f g x y = f (g x y)
+(.*) f g = \x y -> f (g x y) -- FIXME use lambda approach for better inlining? Like (.) does
 
 (.**) :: (d -> e) -> (a -> b -> c -> d) -> a -> b -> c -> e
-(.**) f g x y z = f (g x y z)
+(.**) f g = \x y z -> f (g x y z)
 
 (.***) :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f
-(.***) f g w x y z = f (g w x y z)
+(.***) f g = \w x y z -> f (g w x y z)
 
 (.****) :: (f -> g) -> (a -> b -> c -> d -> e -> f) -> a -> b -> c -> d -> e -> g
-(.****) f g v w x y z = f (g v w x y z)
+(.****) f g = \v w x y z -> f (g v w x y z)
 
+-- | A monadic version of '.*'. Compare '<=<'.
+--
+-- As an example, one could use this to rewrite
+--
+-- > \x y z -> f (g x y z) z
+--
+-- to
+--
+-- > f <=*< g
+--
+-- @since 1.5.2.0
+(<=*<) :: Monad m => (c -> m d) -> (a -> b -> m c) -> a -> b -> m d
+(<=*<) f g = \x y -> f =<< g x y
+
+-- | The bleeding fish operator
+--
+-- @since 1.5.2.0
+(<=**<) :: Monad m => (d -> m e) -> (a -> b -> c -> m d) -> a -> b -> c -> m e
+(<=**<) f g = \x y z -> f =<< g x y z
+
+-- | Compare '>=>'.
+--
+-- @since 1.5.2.0
+(>=*>) :: Monad m => (a -> b -> m c) -> (c -> m d) -> a -> b -> m d
+(>=*>) g f = \x y -> f =<< g x y
+
+-- | @since 1.5.2.0
+(>=**>) :: Monad m => (a -> b -> c -> m d) -> (d -> m e) -> a -> b -> c -> m e
+(>=**>) g f = \x y z -> f =<< g x y z
+
+-- | @since 1.5.2.0
+(<-=*<) :: Monad m => (b -> m c) -> (a -> c -> m d) -> a -> b -> m d
+(<-=*<) f g = \x y -> g x =<< f y
+
+-- | @since 1.5.2.0
+(>-=*>) :: Monad m => (a -> c -> m d) -> (b -> m c) -> a -> b -> m d
+(>-=*>) g f = \x y -> g x =<< f y
+
+-- | @since 1.5.2.0
+(<-=**<) :: Monad m => (c -> m d) -> (a -> b -> d -> m e) -> a -> b -> c -> m e
+(<-=**<) f g = \x y z -> g x y =<< f z
+
+-- | @since 1.5.2.0
+(>-=**>) :: Monad m => (a -> b -> d -> m e) -> (c -> m d) -> a -> b -> c -> m e
+(>-=**>) g f = \x y z -> g x y =<< f z
+
 -- | The Oedipus combinator
 (-.*) :: (b -> c) -> (a -> c -> d) -> a -> b -> d
-(-.*) f g x y = g x (f y)
+(-.*) f g = \x y -> g x (f y)
 
 (-.**) :: (c -> d) -> (a -> b -> d -> e) -> a -> b -> c -> e
-(-.**) f g x y z = g x y (f z)
+(-.**) f g = \x y z -> g x y (f z)
 
 (-.***) :: (d -> e) -> (a -> b -> c -> e -> f) -> a -> b -> c -> d -> f
-(-.***) f g w x y z = g w x y (f z)
+(-.***) f g = \w x y z -> g w x y (f z)
 
 (-.****) :: (e -> f) -> (a -> b -> c -> d -> f -> g) -> a -> b -> c -> d -> e -> g
-(-.****) f g v w x y z = g v w x y (f z)
+(-.****) f g = \v w x y z -> g v w x y (f z)
 
 -- | Backwards function composition. This is a specialization of '<&>'.
 (-.) :: (a -> b) -> (b -> c) -> a -> c