diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,5 +1,9 @@
 # Changelog for polysemy-extra
 
+## v0.1.1.0
+
+* Add `reinterpretUnder`, `reinterpretUnder2` and `reinterpret2Under`.
+
 ## v0.1.0.0
 
 * Add several `Input`, `Output` and `KVStore` functions that I use..
diff --git a/polysemy-extra.cabal b/polysemy-extra.cabal
--- a/polysemy-extra.cabal
+++ b/polysemy-extra.cabal
@@ -5,8 +5,8 @@
 -- see: https://github.com/sol/hpack
 
 name:           polysemy-extra
-version:        0.1.0.0
-synopsis:       Run a KVStore as a filesystem in polysemy.
+version:        0.1.1.0
+synopsis:       Extra Input and Output functions for polysemy..
 category:       Polysemy
 author:         Daniel Firth
 maintainer:     dan.firth@homotopic.tech
@@ -32,6 +32,6 @@
   build-depends:
       base >=4.7 && <5
     , containers
-    , polysemy
+    , polysemy >=1.4.0.0
     , polysemy-zoo
   default-language: Haskell2010
diff --git a/src/Polysemy/Extra.hs b/src/Polysemy/Extra.hs
--- a/src/Polysemy/Extra.hs
+++ b/src/Polysemy/Extra.hs
@@ -1,19 +1,21 @@
 {-# LANGUAGE BlockArguments #-}
 {-# LANGUAGE DataKinds      #-}
-{-# LANGUAGE ExplicitForAll #-}
 {-# LANGUAGE GADTs          #-}
 {-# LANGUAGE LambdaCase     #-}
+{-# LANGUAGE RankNTypes     #-}
 {-# LANGUAGE PolyKinds      #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE TypeOperators  #-}
 module Polysemy.Extra where
 
+import Control.Arrow
 import Data.Map as Map
 import Polysemy
 import Polysemy.KVStore
 import Polysemy.Input
 import Polysemy.Output
+import Polysemy.Membership
 
 -- | Run a KVStore in terms of another KVStore by way of pure key and value
 -- transformations.
@@ -37,10 +39,10 @@
                        -> Sem (KVStore k v ': r) a
                        -> Sem r a
 runKVStoreAsKVStoreSem f g h = interpret \case
-  LookupKV k   -> f k >>= lookupKV @k' @v' >>= sequence . fmap h
+  LookupKV k   -> f k >>= lookupKV @k' @v' >>= mapM h
   UpdateKV k x -> do
     z  <- f k
-    z' <- sequence . fmap g $ x
+    z' <- mapM g x
     updateKV @k' @v' z z'
 
 -- | Run an `Output (Map k v)` as a `KVStore` by writing the values to
@@ -51,7 +53,7 @@
 runOutputMapAsKVStore = interpret \case
   Output xs -> mapM_ (uncurry writeKV) (Map.toList xs)
 
--- | Map an Output forwards 
+-- | Map an Output forwards
 mapOutput :: Members '[ Output o' ] r
           => (o -> o')
           -> Sem (Output o ': r) a
@@ -84,3 +86,40 @@
                   -> Sem r a
 contramapInputSem f = interpret \case
   Input -> f =<< input @i'
+
+-- | Reinterpret the second effect in the stack into a single effect.
+reinterpretUnder :: forall e1 e2 e3 r a.
+                    (forall m x. Sem (e2 ': m) x -> Sem (e3 ': m) x)
+                 -> Sem (e1 ': e2 ': r) a
+                 -> Sem (e1 ': e3 ': r) a
+reinterpretUnder f = raise2Under @e1 @e1 @e2
+                 >>> subsumeUsing @e1 (There Here)
+                 >>> f
+                 >>> raise2Under @e3 @e3 @e1
+                 >>> subsumeUsing @e3 (There Here)
+
+-- | Reinterpret the third effect in the stack into a single effect.
+reinterpretUnder2 :: forall e1 e2 e3 e4 r a.
+                     (forall m x. Sem (e3 ': m) x -> Sem (e4 ': m) x)
+                  -> Sem (e1 ': e2 ': e3 ': r) a
+                  -> Sem (e1 ': e2 ': e4 ': r) a
+reinterpretUnder2 f = raise3Under @e1 @e1 @e2 @e3
+                  >>> subsumeUsing @e1 (There $ There Here)
+                  >>> raise3Under @e2 @e2 @e3 @e1
+                  >>> subsumeUsing @e2 (There $ There Here)
+                  >>> f
+                  >>> raise3Under @e4 @e4 @e1 @e2
+                  >>> subsumeUsing @e4 (There $ There Here)
+
+-- | Reinterpret the second effect in the stack in terms of two effects.
+reinterpret2Under :: forall e1 e2 e3 e4 r a.
+                     (forall m x. Sem (e2 ': m) x -> Sem (e3 ': e4 ': m) x)
+                  -> Sem (e1 ': e2 ': r) a
+                  -> Sem (e1 ': e3 ': e4 ': r) a
+reinterpret2Under f = raise2Under @e1 @e1 @e2
+                  >>> subsumeUsing @e1 (There Here)
+                  >>> f
+                  >>> raise3Under @e3 @e3 @e4 @e1
+                  >>> subsumeUsing @e3 (There $ There Here)
+                  >>> raise3Under @e4 @e4 @e1 @e3
+                  >>> subsumeUsing @e4 (There $ There Here)