diff --git a/Control/Categorical/Functor.hs b/Control/Categorical/Functor.hs
--- a/Control/Categorical/Functor.hs
+++ b/Control/Categorical/Functor.hs
@@ -12,6 +12,12 @@
 import Data.Functor.Sum
 import Data.Proxy
 
+-- | Laws:
+--
+-- @
+-- 'map' 'id' = 'id'
+-- 'map' (f '.' g) = 'map' f '.' 'map' g
+-- @
 class (Category s, Category t) => Functor (s :: α -> α -> *) (t :: β -> β -> *) (f :: α -> β) where
     map :: s a b -> t (f a) (f b)
 
diff --git a/Control/Categorical/Monad.hs b/Control/Categorical/Monad.hs
new file mode 100644
--- /dev/null
+++ b/Control/Categorical/Monad.hs
@@ -0,0 +1,81 @@
+module Control.Categorical.Monad where
+
+import qualified Control.Monad as Base
+import Data.Function (($), flip)
+import Data.Functor.Identity
+import Data.List.NonEmpty (NonEmpty (..))
+import qualified Data.List.NonEmpty as NE
+import Data.Semigroup (Arg (..))
+
+import Control.Categorical.Functor
+
+infixr 1 >=>, <=<, =>=, =<=
+
+class Endofunctor s m => Monad s m where
+    unit :: a `s` m a
+
+    join :: m (m a) `s` m a
+    join = bind id
+
+    bind :: a `s` m b -> m a `s` m b
+    bind f = join . map f
+
+(<=<) :: Monad s m => b `s` m c -> a `s` m b -> a `s` m c
+f <=< g = bind f . bind g . unit
+
+(>=>) :: Monad s m => a `s` m b -> b `s` m c -> a `s` m c
+(>=>) = flip (<=<)
+
+newtype Kleisli s m a b = Kleisli { kleisli :: a `s` m b }
+
+instance Monad s m => Category (Kleisli s m) where
+    id = Kleisli unit
+    Kleisli f . Kleisli g = Kleisli (f <=< g)
+
+instance {-# INCOHERENT #-} Base.Monad m => Monad (->) m where
+    unit = Base.return
+    join = Base.join
+    bind = (Base.=<<)
+
+class Endofunctor s ɯ => Comonad s ɯ where
+    counit :: ɯ a `s` a
+
+    cut :: ɯ a `s` ɯ (ɯ a)
+    cut = cobind id
+
+    cobind :: ɯ a `s` b -> ɯ a `s` ɯ b
+    cobind f = map f . cut
+
+(=<=) :: Comonad s ɯ => ɯ b `s` c -> ɯ a `s` b -> ɯ a `s` c
+f =<= g = counit . cobind f . cobind g
+
+(=>=) :: Comonad s ɯ => ɯ a `s` b -> ɯ b `s` c -> ɯ a `s` c
+(=>=) = flip (=<=)
+
+newtype Cokleisli s ɯ a b = Cokleisli { cokleisli :: ɯ a `s` b }
+
+instance Comonad s ɯ => Category (Cokleisli s ɯ) where
+    id = Cokleisli counit
+    Cokleisli f . Cokleisli g = Cokleisli (f =<= g)
+
+instance Comonad (->) Identity where
+    counit = runIdentity
+    cut = map Identity
+
+instance Comonad (->) NonEmpty where
+    counit = NE.head
+    cut (x:|xs) = (x:|xs) :| go xs
+      where go [] = []
+            go (x:xs) = (x:|xs) : go xs
+
+instance Monoid m => Comonad (->) ((->) m) where
+    counit = ($ mempty)
+    cut f x y = f (x <> y)
+
+instance Comonad (->) ((,) a) where
+    counit (_, b) = b
+    cut (a, b) = (a, (a, b))
+
+instance Comonad (->) (Arg a) where
+    counit (Arg _ b) = b
+    cut (Arg a b) = Arg a (Arg a b)
diff --git a/Control/Category/Const2.hs b/Control/Category/Const2.hs
--- a/Control/Category/Const2.hs
+++ b/Control/Category/Const2.hs
@@ -3,6 +3,7 @@
 import Algebra as A
 import Control.Category.Groupoid
 
+-- | Notes: 'Const2' '()' is the indiscrete category.
 newtype Const2 a b c = Const2 a
   deriving (Semigroup, Monoid, Group)
 
diff --git a/Control/Category/Groupoid.hs b/Control/Category/Groupoid.hs
--- a/Control/Category/Groupoid.hs
+++ b/Control/Category/Groupoid.hs
@@ -1,4 +1,12 @@
 module Control.Category.Groupoid where
 
+-- | 'Category' where every morphism is iso
+--
+-- Laws:
+--
+-- @
+-- 'id' = f '.' 'invert' f
+-- 'id' = 'invert' f '.' f
+-- @
 class Category k => Groupoid k where
     invert :: k a b -> k b a
diff --git a/category.cabal b/category.cabal
--- a/category.cabal
+++ b/category.cabal
@@ -1,5 +1,5 @@
 name:                category
-version:             0.2.0.1
+version:             0.2.1.0
 synopsis:            Categorical types and classes
 -- description:         
 license:             BSD3
@@ -15,6 +15,7 @@
 
 library
   exposed-modules:     Control.Categorical.Functor
+                     , Control.Categorical.Monad
                      , Control.Category.Const2
                      , Control.Category.Dual
                      , Control.Category.Groupoid
@@ -26,13 +27,14 @@
   default-language:    Haskell2010
   default-extensions:  UnicodeSyntax
                      , LambdaCase
+                     , TypeOperators
                      , PolyKinds
                      , ConstraintKinds
                      , MultiParamTypeClasses
                      , FlexibleContexts
                      , FlexibleInstances
                      , GeneralizedNewtypeDeriving
-  ghc-options:         -Wall
+  ghc-options:         -Wall -Wno-name-shadowing
 
 source-repository head
   type: git