diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,12 @@
+0.4.10.1
+-------------------------------------------------
+* Fixed build on GHC 8.6
+
+0.4.10
+-------------------------------------------------
+* Added a `MonadResource`, `MonadThrow`, and `MonadCatch` instances for `Eff`
+* `Proxy` and `KnownSymbol` are now reexported from `Data.Extensible`
+
 0.4.9
 -------------------------------------------------
 * Generalised the `MonadIO` instance for `Eff` to `(MonadIO m, Associate "IO" m xs) => MonadIO (Eff xs)`
diff --git a/examples/eff.hs b/examples/eff.hs
new file mode 100644
--- /dev/null
+++ b/examples/eff.hs
@@ -0,0 +1,23 @@
+{-# LANGUAGE TypeApplications, OverloadedLabels, PolyKinds, DataKinds, ScopedTypeVariables, Rank2Types #-}
+import Data.Extensible
+
+import Prelude hiding (readFile)
+import Control.Exception
+import Data.ByteString (ByteString)
+
+data FileSystem r where
+  ReadFile
+    :: FilePath
+    -> FileSystem (Either SomeException ByteString)
+
+readFile
+  :: forall xs
+  . (Associate "fs" FileSystem xs
+  , Associate "fs_error" (EitherEff SomeException) xs)
+  => FilePath
+  -> Eff xs ByteString
+readFile fp = liftEff #fs (ReadFile fp)
+           >>= either (throwEff #fs_error) pure
+
+foo :: forall xs. Associate "fs" FileSystem xs => Eff xs (Either SomeException ByteString)
+foo = castEff (runEitherEff @ "fs_error" (readFile "foo") :: Eff '["fs" >: FileSystem] (Either SomeException ByteString))
diff --git a/examples/misc.hs b/examples/misc.hs
deleted file mode 100644
--- a/examples/misc.hs
+++ /dev/null
@@ -1,22 +0,0 @@
-{-# LANGUAGE FlexibleContexts, ScopedTypeVariables, TypeApplications #-}
-
-import Data.Extensible
-import Data.Functor.Identity
-import Data.Proxy
-import GHC.TypeLits
-import Data.Extensible.Internal.Rig
-import Data.Typeable
-import Data.Functor.Product
-
--- | Collect keys
-keys :: forall proxy xs. Forall (KeyIs KnownSymbol) xs => proxy xs -> [String]
-keys _ = henumerateFor (Proxy @ (KeyIs KnownSymbol)) (Proxy @ xs)
-  ((:) . symbolVal . proxyAssocKey) []
-
-values :: Forall (ValueIs Show) xs => Record xs -> [String]
-values = hfoldrWithIndexFor (Proxy @ (ValueIs Show))
-  (const $ (:) . show . view _Wrapper) []
-
-values' :: Forall (ValueIs (Product Typeable Show)) xs => Record xs -> [String]
-values' = hfoldrWithIndexFor (Proxy @ (ValueIs Show))
-  (const $ (:) . show . view _Wrapper) []
diff --git a/extensible.cabal b/extensible.cabal
--- a/extensible.cabal
+++ b/extensible.cabal
@@ -1,5 +1,5 @@
 name:                extensible
-version:             0.4.10
+version:             0.4.10.1
 synopsis:            Extensible, efficient, optics-friendly data types and effects
 homepage:            https://github.com/fumieval/extensible
 bug-reports:         http://github.com/fumieval/extensible/issues
diff --git a/src/Data/Extensible/Dictionary.hs b/src/Data/Extensible/Dictionary.hs
--- a/src/Data/Extensible/Dictionary.hs
+++ b/src/Data/Extensible/Dictionary.hs
@@ -1,8 +1,10 @@
+{-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE TypeFamilies, ScopedTypeVariables #-}
 {-# LANGUAGE UndecidableInstances, MultiParamTypeClasses #-}
 #if __GLASGOW_HASKELL__ >= 800
 {-# LANGUAGE UndecidableSuperClasses #-}
+{-# LANGUAGE TypeInType #-}
 #endif
 {-# LANGUAGE OverloadedStrings #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
@@ -20,6 +22,8 @@
 module Data.Extensible.Dictionary (library, WrapForall, Instance1, And) where
 import Control.Applicative
 import Control.DeepSeq
+import Control.Monad.Trans
+import Control.Monad.Trans.Cont
 import qualified Data.Aeson as J
 import qualified Data.Csv as Csv
 import qualified Data.ByteString.Char8 as BC
@@ -38,13 +42,17 @@
 import qualified Data.HashMap.Strict as HM
 import Data.Semigroup
 import Data.Text.Prettyprint.Doc
+import Data.Typeable
+#if __GLASGOW_HASKELL__ >= 800
+import Data.Kind
+#endif
 import qualified Data.Vector.Generic as G
 import qualified Data.Vector.Generic.Mutable as M
 import qualified Data.Vector.Unboxed as U
 import qualified Data.Vector as V
 import qualified Data.Text as T
-import Language.Haskell.TH.Lift
-import Language.Haskell.TH
+import qualified Language.Haskell.TH.Lift as TH
+import Language.Haskell.TH hiding (Type)
 import GHC.TypeLits
 import Test.QuickCheck.Arbitrary
 import Test.QuickCheck.Gen
@@ -110,16 +118,16 @@
   maxBound = hrepeatFor (Proxy :: Proxy (Instance1 Bounded h)) maxBound
 
 #if !MIN_VERSION_th_lift(0,7,9)
-instance Lift a => Lift (Identity a) where
-  lift = appE (conE 'Identity) . lift . runIdentity
+instance TH.Lift a => TH.Lift (Identity a) where
+  lift = appE (conE 'Identity) . TH.lift . runIdentity
 
-instance Lift a => Lift (Const a b) where
-  lift = appE (conE 'Const) . lift . getConst
+instance TH.Lift a => TH.Lift (Const a b) where
+  lift = appE (conE 'Const) . TH.lift . getConst
 #endif
 
-instance WrapForall Lift h xs => Lift (h :* xs) where
-  lift = hfoldrWithIndexFor (Proxy :: Proxy (Instance1 Lift h))
-    (\_ x xs -> infixE (Just $ lift x) (varE '(<:)) (Just xs)) (varE 'nil)
+instance WrapForall TH.Lift h xs => TH.Lift (h :* xs) where
+  lift = hfoldrWithIndexFor (Proxy :: Proxy (Instance1 TH.Lift h))
+    (\_ x xs -> infixE (Just $ TH.lift x) (varE '(<:)) (Just xs)) (varE 'nil)
 
 newtype instance U.MVector s (h :* xs) = MV_Product (Comp (U.MVector s) h :* xs)
 newtype instance U.Vector (h :* xs) = V_Product (Comp U.Vector h :* xs)
@@ -259,10 +267,10 @@
     (library :: Comp Dict (Instance1 Hashable h) :* xs)
   {-# INLINE hashWithSalt #-}
 
-instance WrapForall Lift h xs => Lift (h :| xs) where
+instance WrapForall TH.Lift h xs => TH.Lift (h :| xs) where
   lift (EmbedAt i h) = views (pieceAt i)
-    (\(Comp Dict) -> conE 'EmbedAt `appE` lift i `appE` lift h)
-    (library :: Comp Dict (Instance1 Lift h) :* xs)
+    (\(Comp Dict) -> conE 'EmbedAt `appE` TH.lift i `appE` TH.lift h)
+    (library :: Comp Dict (Instance1 TH.Lift h) :* xs)
 
 instance WrapForall Arbitrary h xs => Arbitrary (h :| xs) where
   arbitrary = choose (0, hcount (Proxy :: Proxy xs)) >>= henumerateFor
@@ -385,3 +393,6 @@
 
 instance (U.Unbox a) => U.Unbox (Const' a b)
 #endif
+
+proxyApp :: Proxy f -> Proxy a -> Proxy (f a)
+proxyApp _ _ = Proxy
diff --git a/src/Data/Extensible/Effect/Default.hs b/src/Data/Extensible/Effect/Default.hs
--- a/src/Data/Extensible/Effect/Default.hs
+++ b/src/Data/Extensible/Effect/Default.hs
@@ -36,14 +36,18 @@
 import Control.Monad.Reader.Class
 import Control.Monad.Skeleton
 import Control.Monad.State.Strict
+#if MIN_VERSION_resourcet(1,2,0)
 import Control.Monad.Trans.Resource
+#endif
 import Control.Monad.Writer.Class
 
 instance (MonadIO m, Associate "IO" m xs) => MonadIO (Eff xs) where
   liftIO = liftEff (Proxy :: Proxy "IO") . liftIO
 
+#if MIN_VERSION_resourcet(1,2,0)
 instance (MonadResource m, Associate "IO" m xs) => MonadResource (Eff xs) where
   liftResourceT = liftEff (Proxy :: Proxy "IO") . liftResourceT
+#endif
 
 instance (MonadThrow m, Associate "IO" m xs) => MonadThrow (Eff xs) where
   throwM = liftEff (Proxy :: Proxy "IO") . throwM
@@ -54,7 +58,7 @@
       Return a -> return a
       Instruction i t :>>= k -> case compareMembership (association :: Membership xs ("IO" ':> m)) i of
         Left _ -> boned $ Instruction i t :>>= go . k
-        Right Refl -> boned $ Instruction i (try t) :>>= go . either h k 
+        Right Refl -> boned $ Instruction i (try t) :>>= go . either h k
 
 pReader :: Proxy "Reader"
 pReader = Proxy
diff --git a/src/Data/Extensible/Struct.hs b/src/Data/Extensible/Struct.hs
--- a/src/Data/Extensible/Struct.hs
+++ b/src/Data/Extensible/Struct.hs
@@ -4,6 +4,7 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE MagicHash, UnboxedTuples #-}
 {-# LANGUAGE TypeFamilies #-}
+{-# LANGUAGE UndecidableInstances #-}
 ------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Extensible.Struct