diff --git a/chorale.cabal b/chorale.cabal
--- a/chorale.cabal
+++ b/chorale.cabal
@@ -1,5 +1,5 @@
 name:           chorale
-version:        0.1.1
+version:        0.1.2
 homepage:       https://github.com/mocnik-science/chorale
 bug-reports:    https://github.com/mocnik-science/chorale/issues
 synopsis:       A module containing basic functions that the prelude does not offer
diff --git a/src/Chorale/Common.hs b/src/Chorale/Common.hs
--- a/src/Chorale/Common.hs
+++ b/src/Chorale/Common.hs
@@ -17,12 +17,20 @@
     (.*),
     (.**),
     (.***),
+    curryM2,
+    curryMM2,
     curry3,
     uncurry3,
+    curryM3,
+    curryMM3,
     curry4,
     uncurry4,
+    curryM4,
+    curryMM4,
     curry5,
     uncurry5,
+    curryM5,
+    curryMM5,
     -- * Tuples
     -- ** Generating Tuples
     appendFst,
@@ -94,6 +102,9 @@
     mapSnd,
     -- * Monads and Tuples
     sequence2,
+    sequence3,
+    sequence4,
+    sequence5,
     (<<),
     -- * Ordering
     compareUsing,
@@ -144,6 +155,7 @@
     fromRight,
     Either3(..)) where
 
+import Control.Monad
 import Data.List
 import qualified Data.Map as Map
 import Data.Maybe
@@ -168,6 +180,14 @@
 (.***) :: (e -> f) -> (a -> b -> c -> d -> e) -> a -> b -> c -> d -> f
 (.***) = (.) . (.**)
 
+-- | 'curry' for two monadic arguments
+curryM2 :: (Functor m, Monad m) => (a -> b -> x) -> (m a, m b) -> m x
+curryM2 f t = uncurry f <$> sequence2 t
+
+-- | 'curry' for two monadic arguments with monadic function
+curryMM2 :: (Functor m, Monad m) => (a -> b -> m x) -> (m a, m b) -> m x
+curryMM2 = join .* curryM2
+
 -- | 'curry' for three arguments
 {-# INLINE curry3 #-}
 curry3 :: ((a, b, c) -> d) -> a -> b -> c -> d
@@ -178,6 +198,14 @@
 uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d
 uncurry3 f (a, b, c) = f a b c
 
+-- | 'curry' for three monadic arguments
+curryM3 :: (Functor m, Monad m) => (a -> b -> c -> x) -> (m a, m b, m c) -> m x
+curryM3 f t = uncurry3 f <$> sequence3 t
+
+-- | 'curry' for three monadic arguments with monadic function
+curryMM3 :: (Functor m, Monad m) => (a -> b -> c -> m x) -> (m a, m b, m c) -> m x
+curryMM3 = join .* curryM3
+
 -- | 'curry' for four arguments
 {-# INLINE curry4 #-}
 curry4 :: ((a, b, c, d) -> e) -> a -> b -> c -> d -> e
@@ -188,6 +216,14 @@
 uncurry4 :: (a -> b -> c -> d -> e) -> (a, b, c, d) -> e
 uncurry4 f (a, b, c, d) = f a b c d
 
+-- | 'curry' for four monadic arguments
+curryM4 :: (Functor m, Monad m) => (a -> b -> c -> d -> x) -> (m a, m b, m c, m d) -> m x
+curryM4 f t = uncurry4 f <$> sequence4 t
+
+-- | 'curry' for four monadic arguments with monadic function
+curryMM4 :: (Functor m, Monad m) => (a -> b -> c -> d -> m x) -> (m a, m b, m c, m d) -> m x
+curryMM4 = join .* curryM4
+
 -- | 'curry' for five arguments
 {-# INLINE curry5 #-}
 curry5 :: ((a, b, c, d, e) -> f) -> a -> b -> c -> d -> e -> f
@@ -198,6 +234,14 @@
 uncurry5 :: (a -> b -> c -> d -> e -> f) -> (a, b, c, d, e) -> f
 uncurry5 f (a, b, c, d, e) = f a b c d e
 
+-- | 'curry' for five monadic arguments
+curryM5 :: (Functor m, Monad m) => (a -> b -> c -> d -> e -> x) -> (m a, m b, m c, m d, m e) -> m x
+curryM5 f t = uncurry5 f <$> sequence5 t
+
+-- | 'curry' for five monadic arguments with monadic function
+curryMM5 :: (Functor m, Monad m) => (a -> b -> c -> d -> e -> m x) -> (m a, m b, m c, m d, m e) -> m x
+curryMM5 = join .* curryM5
+
 -- --== TUPLES
 -- --== GENERATING TUPLES
 
@@ -470,8 +514,38 @@
 -- --== MONADS AND TUPLES
 
 -- | like 'sequence' but for a 2-tuple
-sequence2 :: (Functor m, Monad m) => (m a, m a) -> m (a, a)
-sequence2 = fmap (fromJust . listToTuple2) . sequence . tupleToList2
+sequence2 :: (Functor m, Monad m) => (m a, m b) -> m (a, b)
+sequence2 (a, b) = do
+    a' <- a
+    b' <- b
+    return (a', b')
+
+-- | like 'sequence' but for a 3-tuple
+sequence3 :: (Functor m, Monad m) => (m a, m b, m c) -> m (a, b, c)
+sequence3 (a, b, c) = do
+    a' <- a
+    b' <- b
+    c' <- c
+    return (a', b', c')
+
+-- | like 'sequence' but for a 4-tuple
+sequence4 :: (Functor m, Monad m) => (m a, m b, m c, m d) -> m (a, b, c, d)
+sequence4 (a, b, c, d) = do
+    a' <- a
+    b' <- b
+    c' <- c
+    d' <- d
+    return (a', b', c', d')
+
+-- | like 'sequence' but for a 5-tuple
+sequence5 :: (Functor m, Monad m) => (m a, m b, m c, m d, m e) -> m (a, b, c, d, e)
+sequence5 (a, b, c, d, e) = do
+    a' <- a
+    b' <- b
+    c' <- c
+    d' <- d
+    e' <- e
+    return (a', b', c', d', e')
 
 -- | like '>>' but with reversed argument
 (<<) :: (Monad m) => m b -> m a -> m b