diff --git a/ix.cabal b/ix.cabal
--- a/ix.cabal
+++ b/ix.cabal
@@ -1,5 +1,5 @@
 name:                ix
-version:             0.1.0.0
+version:             0.1.1.0
 synopsis:            Indexed monads
 -- description:
 license:             BSD3
@@ -10,13 +10,16 @@
 -- category:            
 build-type:          Simple
 extra-source-files:  README.md
-cabal-version:       >=1.10
+cabal-version:       >=2.0
 
 library
-  hs-source-dirs:      .
-  exposed-modules:     
+  hs-source-dirs:      src
+  exposed-modules:     Control.Categorical.Monad.Indexed
+  other-modules:       Prelude
   build-depends:       base >= 4.7 && < 5
                      , base-unicode-symbols
+                     , category ^>= 0.2.5
+                     , transformers ^>= 0.5
                      , util
   default-language:    Haskell2010
   default-extensions:  UnicodeSyntax
@@ -28,6 +31,7 @@
                      , ConstraintKinds
                      , FlexibleContexts
                      , FlexibleInstances
+                     , MultiParamTypeClasses
                      , MonadComprehensions
                      , StandaloneDeriving
                      , DeriveFunctor, DeriveFoldable, DeriveTraversable
diff --git a/src/Control/Categorical/Monad/Indexed.hs b/src/Control/Categorical/Monad/Indexed.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Categorical/Monad/Indexed.hs
@@ -0,0 +1,50 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE ExistentialQuantification #-}
+{-# LANGUAGE QuantifiedConstraints #-}
+{-# LANGUAGE TypeOperators #-}
+module Control.Categorical.Monad.Indexed (Monad (..), (<=<), (>=>), Comonad (..), (=<=), (=>=)) where
+
+import Data.Function (flip)
+
+import Control.Categorical.Functor
+import Control.Category.Dual
+
+infixr 1 >=>, <=<, =>=, =<=
+
+class (∀ i j . Endofunctor s (m i j)) => Monad s m where
+    unit :: a `s` m k k a
+
+    join :: m i j (m j k a) `s` m i k a
+    join = bind id
+
+    bind :: a `s` m j k b -> m i j a `s` m i k b
+    bind f = join . map f
+
+(<=<) :: Monad s m => b `s` m j k c -> a `s` m i j b -> a `s` m i k c
+f <=< g = bind f . bind g . unit
+
+(>=>) :: Monad s m => a `s` m i j b -> b `s` m j k c -> a `s` m i k c
+(>=>) = flip (<=<)
+
+instance Comonad s f => Monad (Dual s) f where
+    unit = Dual counit
+    join = Dual cut
+
+instance (Category s, Comonad (NT s) f) => Monad (NT (Dual s)) f where
+    unit = NT (Dual (nt counit))
+    join = NT (Dual (nt cut))
+
+class (∀ i j . Endofunctor s (ɯ i j)) => Comonad s ɯ where
+    counit :: ɯ k k a `s` a
+
+    cut :: ɯ i k a `s` ɯ i j (ɯ j k a)
+    cut = cobind id
+
+    cobind :: ɯ j k a `s` b -> ɯ i k a `s` ɯ i j b
+    cobind f = map f . cut
+
+(=<=) :: Comonad s ɯ => ɯ i j b `s` c -> ɯ j k a `s` b -> ɯ i k a `s` c
+f =<= g = counit . cobind f . cobind g
+
+(=>=) :: Comonad s ɯ => ɯ j k a `s` b -> ɯ i j b `s` c -> ɯ i k a `s` c
+(=>=) = flip (=<=)
diff --git a/src/Prelude.hs b/src/Prelude.hs
new file mode 100644
--- /dev/null
+++ b/src/Prelude.hs
@@ -0,0 +1,9 @@
+module Prelude (module Control.Category,
+                module Data.Either,
+                Semigroup (..), Monoid (..)) where
+
+--import Algebra (Group)
+import Control.Category
+import Data.Either
+import Data.Monoid (Monoid (..))
+import Data.Semigroup (Semigroup (..))