diff --git a/monadlist.cabal b/monadlist.cabal
--- a/monadlist.cabal
+++ b/monadlist.cabal
@@ -1,5 +1,5 @@
 name: monadlist
-version: 0.0.1
+version: 0.0.2
 cabal-version: -any
 build-type: Simple
 license: BSD3
diff --git a/src/Control/Monad/ListM.hs b/src/Control/Monad/ListM.hs
--- a/src/Control/Monad/ListM.hs
+++ b/src/Control/Monad/ListM.hs
@@ -16,6 +16,7 @@
   mapMP
 , filterMP
 , intersperseM
+, intercalateM
 , foldM1
 , joinMap
 , joinMapM
@@ -220,7 +221,10 @@
 breakM p = spanM $ notM <=< p
 
 elemM :: (Eq a, Monad m) => a -> [a] -> m Bool
-elemM x = liftM isJust . elemIndexM x
+elemM x xs = do
+  idx <- elemIndexM x xs
+  let _ = idx :: Maybe Int
+  return $ isJust idx
 
 notElemM :: (Eq a, Monad m) => a -> [a] -> m Bool
 notElemM x = notM <=< elemM x
@@ -336,8 +340,42 @@
 sortM = sortByM compareM
 
 sortByM :: (Monad m) => (a -> a -> m Ordering) -> [a] -> m [a]
-sortByM _ [] = return []
-sortByM cmp (x:xs) = sortByM cmp xs >>= insertByM cmp x
+sortByM cmp = mergeAll <=< sequences
+  where
+    sequences (a:b:xs) = do
+      ord <- cmp a b
+      case ord of
+        GT -> descending b [a] xs
+        _ -> ascending b (a:) xs
+    sequences xs = return [xs]
+
+    descending a as cs@(b:bs) = do
+      ord <- cmp a b
+      case ord of
+        GT -> descending b (a:as) bs
+        _ -> liftM ((a:as) :) $ sequences cs
+    descending a as bs = liftM ((a:as) :) $ sequences bs
+
+    ascending a as cs@(b:bs) = do
+      ord <- cmp a b
+      case ord of
+        GT -> liftM (as [a] :) $ sequences cs
+        _ -> ascending b (\ys -> as (a:ys)) bs
+    ascending a as bs = liftM (as [a] :) $ sequences bs
+
+    mergeAll [x] = return x
+    mergeAll xs = mergeAll =<< (mergePairs xs)
+
+    mergePairs (a:b:xs) = liftM2 (:) (merge a b) $ mergePairs xs
+    mergePairs xs = return xs
+
+    merge as@(a:as') bs@(b:bs') = do
+      ord <- cmp a b
+      case ord of
+        GT -> liftM (b :) $ merge as  bs'
+        _ -> liftM (a :) $ merge as' bs
+    merge [] bs = return bs
+    merge as [] = return as
 
 insertM :: (Ord a, Monad m) => a -> [a] -> m [a]
 insertM = insertByM compareM