diff --git a/monoid-transformer.cabal b/monoid-transformer.cabal
--- a/monoid-transformer.cabal
+++ b/monoid-transformer.cabal
@@ -1,5 +1,5 @@
 Name:             monoid-transformer
-Version:          0.0.2
+Version:          0.0.3
 License:          BSD3
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>
@@ -14,6 +14,7 @@
   There is no Writer transformer.
   It's vice versa: The Writer monad transforms a monoid to a monad.
 Tested-With:       GHC==6.8.2
+Tested-With:       GHC==7.8.2
 Cabal-Version:     >=1.6
 Build-Type:        Simple
 
@@ -24,7 +25,7 @@
 Source-Repository this
   type:     darcs
   location: http://code.haskell.org/~thielema/monoid/
-  tag:      0.0.2
+  tag:      0.0.3
 
 
 Library
@@ -33,6 +34,9 @@
   GHC-Options:      -Wall
   Hs-Source-Dirs:   src
   Exposed-Modules:
+    Data.Monoid.Applicative
+    Data.Monoid.Monad
     Data.Monoid.Reader
     Data.Monoid.State
+    Data.Monoid.MonadicEndo
     Data.Monoid.Transformer
diff --git a/src/Data/Monoid/Applicative.hs b/src/Data/Monoid/Applicative.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Monoid/Applicative.hs
@@ -0,0 +1,20 @@
+module Data.Monoid.Applicative where
+
+import qualified Data.Monoid.Transformer as MonoidTrans
+
+import Control.Applicative (Applicative, pure, liftA2, )
+import Data.Monoid (Monoid, mempty, mappend, )
+
+{- |
+Sequence applicative functors and combine their functorial results with 'mappend'.
+-}
+newtype T f a = Cons {run :: f a}
+
+
+instance (Applicative f, Monoid a) => Monoid (T f a) where
+   mempty = Cons $ pure mempty
+   mappend (Cons x) (Cons y) =
+      Cons $ liftA2 mappend x y
+
+instance (Applicative f) => MonoidTrans.C (T f) where
+   lift = Cons . pure
diff --git a/src/Data/Monoid/Monad.hs b/src/Data/Monoid/Monad.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Monoid/Monad.hs
@@ -0,0 +1,22 @@
+module Data.Monoid.Monad where
+
+import qualified Data.Monoid.Transformer as MonoidTrans
+
+import Control.Monad (liftM2, )
+import Data.Monoid (Monoid, mempty, mappend, )
+
+{- |
+Sequence actions and combine their monadic results with 'mappend'.
+
+This type could be omitted, if 'Monad' would be a sub-class of 'Applicative'.
+-}
+newtype T m a = Cons {run :: m a}
+
+
+instance (Monad m, Monoid a) => Monoid (T m a) where
+   mempty = Cons $ return mempty
+   mappend (Cons x) (Cons y) =
+      Cons $ liftM2 mappend x y
+
+instance (Monad m) => MonoidTrans.C (T m) where
+   lift = Cons . return
diff --git a/src/Data/Monoid/MonadicEndo.hs b/src/Data/Monoid/MonadicEndo.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Monoid/MonadicEndo.hs
@@ -0,0 +1,18 @@
+module Data.Monoid.MonadicEndo where
+
+import Data.Monoid (Monoid, mempty, mappend, )
+
+{- |
+Like Data.Monoid.Endo but with monadic result.
+'mempty' is 'return' and 'mappend' is '<=<'.
+
+Useful e.g. for handling options with GetOpt.
+-}
+newtype T m a = Cons {run :: a -> m a}
+
+
+instance Monad m => Monoid (T m a) where
+   mempty = Cons return
+   mappend (Cons x) (Cons y) =
+      Cons $ (x =<<) . y
+--      Cons $ x <=< y
diff --git a/src/Data/Monoid/Reader.hs b/src/Data/Monoid/Reader.hs
--- a/src/Data/Monoid/Reader.hs
+++ b/src/Data/Monoid/Reader.hs
@@ -2,8 +2,15 @@
 
 import qualified Data.Monoid.Transformer as MonoidTrans
 import Data.Monoid (Monoid, mempty, mappend, )
+import Data.Functor (Functor, fmap, )
+import Data.Function (const, ($), (.), )
 
+import Prelude ()
 
+
+{- |
+Could also be written as @Monoid.Applicative (Monad.Trans.Reader r) a@.
+-}
 newtype T r a = Cons {run :: r -> a}
 
 pure :: a -> T r a
diff --git a/src/Data/Monoid/State.hs b/src/Data/Monoid/State.hs
--- a/src/Data/Monoid/State.hs
+++ b/src/Data/Monoid/State.hs
@@ -2,7 +2,12 @@
 
 import qualified Data.Monoid.Transformer as MonoidTrans
 import Data.Monoid (Monoid, mempty, mappend, )
+import Data.Functor (Functor, fmap, )
+import Data.Function (const, ($), (.), )
+import Data.Tuple (fst, snd, )
 
+import Prelude ()
+
 {- |
 This resembles the pure State monad.
 However, State in transformers is a StateT
@@ -11,6 +16,8 @@
 I hope I have the more natural parameter order for 'evaluate'
 in contrast to @mtl@ and @transformers@.
 However, it is different from the parameter order of 'run'.
+
+Could also be written as @Monoid.Applicative (Monad.Trans.State s) a@.
 -}
 newtype T s a = Cons {run :: s -> (a,s)}