diff --git a/List.cabal b/List.cabal
--- a/List.cabal
+++ b/List.cabal
@@ -1,5 +1,5 @@
 Name:                List
-Version:             0.4.2
+Version:             0.4.3
 Category:            Control
 Synopsis:            List monad transformer and class
 Description:
diff --git a/src/Data/List/Class.hs b/src/Data/List/Class.hs
--- a/src/Data/List/Class.hs
+++ b/src/Data/List/Class.hs
@@ -10,16 +10,17 @@
     filter,
     -- | Standard list operations
     repeat,
-    takeWhile, genericTake, scanl, scanl1,
+    take, takeWhile, genericTake, scanl, scanl1,
     transpose, zip, zipWith,
     concat, concatMap,
     tail,
     enumFrom, enumFromTo,
+    catMaybes, mapMaybe,
     -- | Non standard List operations
     foldrL, foldlL, foldl1L, toList, lengthL, lastL,
     merge2On, mergeOn,
     -- | Operations useful for monadic lists
-    execute, joinM, mapL, filterL, iterateM, takeWhileM, repeatM,
+    execute, joinM, mapL, filterL, iterateM, takeWhileM, repeatM, splitAtM,
     -- | Operations for non-monadic lists
     sortOn,
     -- | Convert between List types
@@ -36,7 +37,7 @@
 import Data.Ord (comparing)
 import Prelude hiding (
     concat, concatMap, enumFrom, enumFromTo, filter, repeat, scanl, scanl1,
-    tail, takeWhile, zip, zipWith)
+    tail, take, takeWhile, zip, zipWith)
 
 data ListItem l a =
     Nil |
@@ -143,6 +144,9 @@
     where
         onCons x = cons x . genericTake (count - 1)
 
+take :: List l => Int -> l a -> l a
+take = genericTake
+
 -- | Execute the monadic actions in a 'List'
 execute :: List l => l a -> ItemM l ()
 execute = foldlL const ()
@@ -300,6 +304,19 @@
             . iterateM step
             . step $ start
 
+-- | Monadic variant of splitAt.
+-- Consumes x items from the list and return them with the remaining monadic list.
+splitAtM :: List l => Int -> l a -> ItemM l ([a], l a)
+splitAtM at list
+    | at <= 0 = return ([], list)
+    | otherwise = do
+        item <- runList list
+        case item of
+            Nil -> return ([], mzero)
+            Cons x xs -> do
+                (pre, post) <- splitAtM (at-1) xs
+                return (x:pre, post)
+
 -- | listStateJoin can transform a
 -- @ListT (StateT s m) a@ to a @StateT s m (ListT m a)@.
 --
@@ -326,6 +343,16 @@
 -- For @List l => (a -> l b) -> l a -> l b@ use '=<<' (monadic bind)
 concatMap :: List l => (a -> [b]) -> l a -> l b
 concatMap f = concat . liftM f
+
+catMaybes :: List l => l (Maybe a) -> l a
+catMaybes =
+    concatMap f
+    where
+        f Nothing = mzero
+        f (Just x) = return x
+
+mapMaybe :: List l => (a -> Maybe b) -> l a -> l b
+mapMaybe f = catMaybes . liftM f
 
 enumFrom :: (List l, Enum a) => a -> l a
 enumFrom x = cons x (enumFrom (succ x))