diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,5 @@
-Copyright (c) 2015, Emil Axelsson, Heinrich Apfelmus
+Copyright (c) 2016 Emil Axelsson
+Copyright (c) 2015 Emil Axelsson, Heinrich Apfelmus
 
 All rights reserved.
 
diff --git a/operational-alacarte.cabal b/operational-alacarte.cabal
--- a/operational-alacarte.cabal
+++ b/operational-alacarte.cabal
@@ -1,5 +1,5 @@
 name:                operational-alacarte
-version:             0.2
+version:             0.3
 synopsis:            A version of Operational suitable for extensible EDSLs
 description:         A version of Operational \[1\] suitable for EDSLs
                      extensible via data types à la carte.
@@ -23,8 +23,8 @@
 license-file:        LICENSE
 author:              Emil Axelsson
 maintainer:          emax@chalmers.se
-copyright:           Copyright (c) 2015 Emil Axelsson, Heinrich Apfelmus
-                     Copyright (c) 2016 Emil Axelsson
+copyright:           Copyright (c) 2016 Emil Axelsson
+                     Copyright (c) 2015 Emil Axelsson, Heinrich Apfelmus
 homepage:            https://github.com/emilaxelsson/operational-alacarte
 bug-reports:         https://github.com/emilaxelsson/operational-alacarte/issues
 category:            Language
@@ -46,6 +46,7 @@
     DataKinds
     DeriveDataTypeable
     DeriveFunctor
+    FlexibleContexts
     FlexibleInstances
     GADTs
     MultiParamTypeClasses
diff --git a/src/Control/Monad/Operational/Higher.hs b/src/Control/Monad/Operational/Higher.hs
--- a/src/Control/Monad/Operational/Higher.hs
+++ b/src/Control/Monad/Operational/Higher.hs
@@ -454,35 +454,28 @@
 --
 -- @e1@ and @e2@ typically represent expressions; hence the name
 -- \"reexpressible\".
-class HBifunctor i => Reexpressible i instr
+class HBifunctor i => Reexpressible i instr env
   where
     -- | Rewrite an instruction changing its \"expression\" sub-structure
-    reexpressInstr :: Monad m
-        => (forall b . exp1 b -> ProgramT instr '(exp2,fs) m (exp2 b))
-             -- ^ Conversion of the \"expression\" sub-structure
-        -> i '(ProgramT instr '(exp2,fs) m, '(exp1, fs)) a
-        -> ProgramT instr '(exp2,fs) m a
-    reexpressInstr reexp
-        = flip runReaderT ()
-        . reexpressInstrEnv (lift . reexp)
-        . hbimap lift id
-
-    -- | Rewrite an instruction changing its \"expression\" sub-structure
     --
     -- As an example of how to define this function, take the following
     -- instruction that just puts a tag on a sub-program:
     --
-    -- > data Tag fs a
-    -- >   where
-    -- >     Tag :: String -> prog () -> Tag (Param2 prog exp) ()
+    -- @
+    -- data Tag fs a
+    --   where
+    --     Tag :: `String` -> prog () -> Tag (`Param2` prog exp) ()
+    -- @
     --
     -- To define `reexpressInstrEnv` we have to use a combination of `ReaderT`
     -- and `runReaderT`:
     --
-    -- > instance (Tag :<: instr) => Reexpressible Tag instr
-    -- >   where
-    -- >     reexpressInstrEnv reexp (Tag tag prog) = ReaderT $ \env ->
-    -- >         singleInj $ Tag tag (flip runReaderT env prog)
+    -- @
+    -- instance (Tag `:<:` instr) => `Reexpressible` Tag instr
+    --   where
+    --     `reexpressInstrEnv` reexp (Tag tag prog) = `ReaderT` `$` \env ->
+    --         `singleInj` `$` Tag tag (`flip` `runReaderT` env prog)
+    -- @
     reexpressInstrEnv :: Monad m
         => ( forall b .
                exp1 b -> ReaderT env (ProgramT instr '(exp2,fs) m) (exp2 b)
@@ -495,11 +488,20 @@
       -- which `reexpressInstrEnv` can be defined (among common monads). E.g.
       -- the above trick with `runReaderT` doesn't work for `StateT`.
 
-instance (Reexpressible i1 instr, Reexpressible i2 instr) =>
-    Reexpressible (i1 :+: i2) instr
+-- | Rewrite an instruction changing its \"expression\" sub-structure
+reexpressInstr :: (Reexpressible i instr (), Monad m)
+    => (forall b . exp1 b -> ProgramT instr '(exp2,fs) m (exp2 b))
+         -- ^ Conversion of the \"expression\" sub-structure
+    -> i '(ProgramT instr '(exp2,fs) m, '(exp1, fs)) a
+    -> ProgramT instr '(exp2,fs) m a
+reexpressInstr reexp
+    = flip runReaderT ()
+    . reexpressInstrEnv (lift . reexp)
+    . hbimap lift id
+
+instance (Reexpressible i1 instr env, Reexpressible i2 instr env) =>
+    Reexpressible (i1 :+: i2) instr env
   where
-    reexpressInstr    reexp (Inl i) = reexpressInstr    reexp i
-    reexpressInstr    reexp (Inr i) = reexpressInstr    reexp i
     reexpressInstrEnv reexp (Inl i) = reexpressInstrEnv reexp i
     reexpressInstrEnv reexp (Inr i) = reexpressInstrEnv reexp i
 
@@ -509,7 +511,7 @@
 -- Conversion of expressions is done in the target monad, so pure expressions
 -- are allowed to expand to monadic code. This can be used e.g. to \"compile\"
 -- complex expressions into simple expressions with supporting monadic code.
-reexpress :: (Reexpressible instr1 instr2, Monad m)
+reexpress :: (Reexpressible instr1 instr2 (), Monad m)
     => (forall b . exp1 b -> ProgramT instr2 '(exp2,fs) m (exp2 b))
          -- ^ Conversion of expressions
     -> ProgramT instr1 '(exp1,fs) m a -> ProgramT instr2 '(exp2,fs) m a
@@ -521,7 +523,7 @@
 -- Conversion of expressions is done in the target monad, so pure expressions
 -- are allowed to expand to monadic code. This can be used e.g. to \"compile\"
 -- complex expressions into simple expressions with supporting monadic code.
-reexpressEnv :: (Reexpressible instr1 instr2, Monad m)
+reexpressEnv :: (Reexpressible instr1 instr2 env, Monad m)
     => ( forall b .
             exp1 b -> ReaderT env (ProgramT instr2 '(exp2,fs) m) (exp2 b)
        )