diff --git a/ConstraintKinds.cabal b/ConstraintKinds.cabal
--- a/ConstraintKinds.cabal
+++ b/ConstraintKinds.cabal
@@ -1,5 +1,5 @@
 Name:                ConstraintKinds
-Version:             0.0.2.0
+Version:             1.1.0.0
 Synopsis:            Repackages standard type classes with the ConstraintKinds extension
 Description:         This module provides more flexible versions of common type classes that use the ConstraintKinds extension.  This allows us to make types that require constraints instances of the popular classes.  For example, we reimplement Functor and Foldable using the ContraintKinds style.  This allows us to manipulate lists and unboxed vectors using the same functions.
                      .
@@ -30,6 +30,7 @@
         Control.ConstraintKinds.Filterable
         Control.ConstraintKinds.Foldable
         Control.ConstraintKinds.Functor
-        -- Control.ConstraintKinds.Monad
+        Control.ConstraintKinds.Monad
         Control.ConstraintKinds.Partitionable
+        Control.ConstraintKinds.Pointed
         Control.ConstraintKinds.Traversable
diff --git a/src/Control/ConstraintKinds.hs b/src/Control/ConstraintKinds.hs
--- a/src/Control/ConstraintKinds.hs
+++ b/src/Control/ConstraintKinds.hs
@@ -1,10 +1,14 @@
 module Control.ConstraintKinds
-    ( module Control.ConstraintKinds.Applicative
+    ( 
+    -- * Modules
+
+      module Control.ConstraintKinds.Applicative
     , module Control.ConstraintKinds.Filterable
     , module Control.ConstraintKinds.Foldable
     , module Control.ConstraintKinds.Functor
+    , module Control.ConstraintKinds.Monad
     , module Control.ConstraintKinds.Partitionable
---     , module Control.ConstraintKinds.Monad
+    , module Control.ConstraintKinds.Pointed
     , module Control.ConstraintKinds.Traversable
     )
     where
@@ -13,6 +17,8 @@
 import Control.ConstraintKinds.Filterable
 import Control.ConstraintKinds.Foldable
 import Control.ConstraintKinds.Functor
--- import Control.ConstraintKinds.Monad
+import Control.ConstraintKinds.Monad
 import Control.ConstraintKinds.Partitionable
+import Control.ConstraintKinds.Pointed
 import Control.ConstraintKinds.Traversable
+
diff --git a/src/Control/ConstraintKinds/Applicative.hs b/src/Control/ConstraintKinds/Applicative.hs
--- a/src/Control/ConstraintKinds/Applicative.hs
+++ b/src/Control/ConstraintKinds/Applicative.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE ConstraintKinds #-}
 {-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
 
 module Control.ConstraintKinds.Applicative
     where
@@ -15,16 +16,15 @@
 import qualified Data.Vector.Generic as G
 
 import Control.ConstraintKinds.Functor
+import Control.ConstraintKinds.Pointed
 import Prelude hiding (Functor, fmap, foldl, foldr)
 
 -------------------------------------------------------------------------------
 -- class Applicative
 
-class Functor f => Applicative f where
+class Pointed f => Applicative f where
     type ApplicativeConstraint f x :: Constraint
-    type ApplicativeConstraint f x = ()
-
-    pure :: (ApplicativeConstraint f a) => a -> f a
+    type ApplicativeConstraint f x = PointedConstraint f x
 
     (<*>) :: (ApplicativeConstraint f a, ApplicativeConstraint f b) => f (a -> b) -> f a -> f b
 
@@ -37,7 +37,7 @@
 -- | Lift a function to actions.
 -- This function may be used as a value for `fmap` in a `Functor` instance.
 -- liftA :: (ApplicativeConstraint f a, ApplicativeConstraint f (a -> b), ApplicativeConstraint f b, Applicative f) => (a -> b) -> f a -> f b
-liftA f a = pure f <*> a
+liftA f a = point f <*> a
 
 -- | Lift a binary function to actions.
 -- liftA2 :: (FunctorConstraint f a, FunctorConstraint f (b -> c), Applicative f) => (a -> b -> c) -> f a -> f b -> f c
@@ -51,21 +51,12 @@
 -- Instances
 
 instance Applicative [] where
-    pure = M.return
     (<*>) = M.ap
     
 instance Applicative V.Vector where
-    {-# INLINE pure #-}
-    pure = V.singleton
-
     {-# INLINE (<*>) #-}
     (<*>) = M.ap
   
-instance Applicative VU.Vector where
-    type ApplicativeConstraint VU.Vector x = VU.Unbox x
-
-    {-# INLINE pure #-}
-    pure = VU.singleton
-
-    {-# INLINE (<*>) #-}
-    (<*>) = undefined -- M.ap
+-- instance Applicative VU.Vector where
+--     {-# INLINE (<*>) #-}
+--     (<*>) = undefined -- M.ap
diff --git a/src/Control/ConstraintKinds/Functor.hs b/src/Control/ConstraintKinds/Functor.hs
--- a/src/Control/ConstraintKinds/Functor.hs
+++ b/src/Control/ConstraintKinds/Functor.hs
@@ -5,6 +5,7 @@
     where
 
 import GHC.Prim
+import Text.ParserCombinators.ReadPrec
 
 import qualified Data.Foldable as F
 import qualified Data.List as L
@@ -31,9 +32,12 @@
 -- Instances
 
 instance Functor [] where
-    type FunctorConstraint [] x = ()
     {-# INLINE fmap #-}
     fmap = P.map
+
+instance Functor ReadPrec where
+    {-# INLINE fmap #-}
+    fmap = P.fmap
 
 instance Functor V.Vector where
     {-# INLINE fmap #-}
diff --git a/src/Control/ConstraintKinds/Monad.hs b/src/Control/ConstraintKinds/Monad.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/ConstraintKinds/Monad.hs
@@ -0,0 +1,80 @@
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+module Control.ConstraintKinds.Monad
+    where
+
+import GHC.Prim
+import qualified Control.Monad as Monad
+import Prelude hiding (Functor, fmap, Monad, (>>=), (>>), return)
+import qualified Prelude as Prelude
+import Text.ParserCombinators.ReadPrec
+
+import qualified Data.Foldable as F
+import qualified Data.List as L
+import qualified Data.Traversable as T
+import qualified Data.Vector as V
+import qualified Data.Vector.Unboxed as VU
+import qualified Data.Vector.Generic as VG
+
+import Control.ConstraintKinds.Functor
+import Control.ConstraintKinds.Pointed
+import Control.ConstraintKinds.Applicative
+
+ifThenElse :: Bool -> a -> a -> a
+ifThenElse True  x _ = x
+ifThenElse False _ y = y
+
+-------------------------------------------------------------------------------
+-- class Monad
+
+class (Functor m) => Monad m where
+
+    fail :: String -> m a
+    fail = error
+
+    return :: 
+        ( FunctorConstraint m a
+        ) => a -> m a
+
+    join :: 
+        ( FunctorConstraint m a
+        , FunctorConstraint m (m a)
+        ) => m (m a) -> m a
+    join m = m >>= id
+
+    (>>=) :: 
+        ( FunctorConstraint m a
+        , FunctorConstraint m b
+        , FunctorConstraint m (m b)
+        ) => m a -> (a -> m b) -> m b
+    a >>= b = join $ fmap b a
+
+    (>>) :: 
+        ( FunctorConstraint m a
+        , FunctorConstraint m b
+        , FunctorConstraint m (m b)
+        ) => m a -> m b -> m b
+    m >> k = m >>= \_ -> k
+    
+-------------------------------------------------------------------------------
+-- instances
+
+instance Control.ConstraintKinds.Monad.Monad [] where
+    return = Monad.return
+    (>>=)  = (Monad.>>=)
+    (>>)   = (Monad.>>)
+
+instance Monad ReadPrec where
+    return = Monad.return
+    (>>=)  = (Monad.>>=)
+    (>>)   = (Monad.>>)
+
+instance Monad V.Vector where
+    return = Monad.return
+    (>>=) = flip V.concatMap
+  
+instance Monad VU.Vector where
+    return = VU.singleton
+    (>>=) = flip VU.concatMap
diff --git a/src/Control/ConstraintKinds/Pointed.hs b/src/Control/ConstraintKinds/Pointed.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/ConstraintKinds/Pointed.hs
@@ -0,0 +1,43 @@
+{-# LANGUAGE ConstraintKinds #-}
+{-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
+
+module Control.ConstraintKinds.Pointed
+    where
+
+import GHC.Prim
+
+import qualified Data.Foldable as F
+import qualified Data.List as L
+import qualified Data.Traversable as T
+import qualified Data.Vector as V
+import qualified Data.Vector.Unboxed as VU
+import qualified Data.Vector.Generic as G
+import qualified Prelude as P
+
+import Control.ConstraintKinds.Functor
+
+-------------------------------------------------------------------------------
+-- class Functor
+
+class (Functor f) => Pointed f where
+    type PointedConstraint f x :: Constraint
+    type PointedConstraint f x = FunctorConstraint f x
+    
+    point :: (PointedConstraint f a) => a -> f a
+
+-------------------------------------------------------------------------------
+-- Instances
+
+instance Pointed [] where
+    {-# INLINE point #-}
+    point x = [x]
+
+instance Pointed V.Vector where
+    {-# INLINE point #-}
+    point = V.singleton
+
+instance Pointed VU.Vector where
+    type PointedConstraint VU.Vector x = VU.Unbox x
+    {-# INLINE point #-}
+    point = VU.singleton