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,6 +1,6 @@
 cabal-version:       2.4
 name:                extensible
-version:             0.8.1
+version:             0.8.2
 synopsis:            Extensible, efficient, optics-friendly data types and effects
 homepage:            https://github.com/fumieval/extensible
 bug-reports:         http://github.com/fumieval/extensible/issues
@@ -12,7 +12,7 @@
 license-file:        LICENSE
 author:              Fumiaki Kinoshita
 maintainer:          Fumiaki Kinoshita <fumiexcel@gmail.com>
-copyright:           Copyright (c) 2017-2020 Fumiaki Kinoshita
+copyright:           Copyright (c) 2017-2021 Fumiaki Kinoshita
 category:            Data, Records
 build-type:          Simple
 stability:           experimental
@@ -60,6 +60,7 @@
   default-extensions: TypeOperators
     , DeriveDataTypeable
     , DeriveGeneric
+    , DeriveLift
     , GeneralizedNewtypeDeriving
     , KindSignatures
     , ConstraintKinds
diff --git a/src/Data/Extensible/Class.hs b/src/Data/Extensible/Class.hs
--- a/src/Data/Extensible/Class.hs
+++ b/src/Data/Extensible/Class.hs
@@ -85,7 +85,7 @@
 -- | Access an element specified by the key type through a wrapper.
 itemKey :: forall k v xs h f p t. (Wrapper h, Extensible f p t, Lookup xs k v, ExtensibleConstr t xs h (k ':> v))
   => Optic' p f (t xs h) (Repr h (k ':> v))
-itemKey = pieceAssoc . _WrapperAs (Proxy @ (k ':> v))
+itemKey = pieceAssoc . _WrapperAs (Proxy @(k ':> v))
 {-# INLINE itemKey #-}
 
 proxyKey :: proxy k -> Proxy (k ':> v)
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
@@ -48,6 +48,9 @@
 import qualified Data.Text as T
 import Data.Type.Equality
 import qualified Language.Haskell.TH.Lift as TH
+#if MIN_VERSION_template_haskell(2,17,0)
+import qualified Language.Haskell.TH.Syntax as TH
+#endif
 import Language.Haskell.TH hiding (Type)
 import GHC.TypeLits
 import Test.QuickCheck.Arbitrary
@@ -122,6 +125,9 @@
 instance WrapForall TH.Lift h xs => TH.Lift (xs :& h) where
   lift = hfoldrWithIndexFor (Proxy :: Proxy (Instance1 TH.Lift h))
     (\_ x xs -> infixE (Just $ TH.lift x) (varE '(<:)) (Just xs)) (varE 'nil)
+#if MIN_VERSION_template_haskell(2,17,0) 
+  liftTyped e = TH.Code $ TH.TExp <$> TH.lift e
+#endif
 
 newtype instance U.MVector s (xs :& h) = MV_Product (xs :& Comp (U.MVector s) h)
 newtype instance U.Vector (xs :& h) = V_Product (xs :& Comp U.Vector h)
@@ -271,6 +277,9 @@
   lift (EmbedAt i h) = views (pieceAt i)
     (\(Comp Dict) -> conE 'EmbedAt `appE` TH.lift i `appE` TH.lift h)
     (library :: xs :& Comp Dict (Instance1 TH.Lift h))
+#if MIN_VERSION_template_haskell(2,17,0)
+  liftTyped e = TH.Code $ TH.TExp <$> TH.lift e
+#endif
 
 instance WrapForall Arbitrary h xs => Arbitrary (xs :/ h) where
   arbitrary = choose (0, hcount (Proxy :: Proxy xs)) >>= henumerateFor
diff --git a/src/Data/Extensible/Field.hs b/src/Data/Extensible/Field.hs
--- a/src/Data/Extensible/Field.hs
+++ b/src/Data/Extensible/Field.hs
@@ -74,7 +74,6 @@
 import GHC.Generics (Generic)
 import GHC.TypeLits hiding (Nat)
 import Language.Haskell.TH.Lift
-import Language.Haskell.TH (appE, conE)
 import Test.QuickCheck.Arbitrary
 import Type.Membership
 
@@ -113,6 +112,7 @@
 ND_Field(Csv.ToField)
 #endif
 ND_Field(Incremental)
+ND_Field(Lift)
 
 newtype instance U.MVector s (Field h x) = MV_Field (U.MVector s (h (TargetOf x)))
 newtype instance U.Vector (Field h x) = V_Field (U.Vector (h (TargetOf x)))
@@ -160,9 +160,6 @@
   basicUnsafeCopy (MV_Field mv) (V_Field v) = G.basicUnsafeCopy mv v
 
 instance (U.Unbox (h (TargetOf x))) => U.Unbox (Field h x)
-
-instance Lift (h (TargetOf x)) => Lift (Field h x) where
-  lift = appE (conE 'Field) . lift . getField
 
 -- | Lift a function for the content.
 liftField :: (g (TargetOf kv) -> h (TargetOf kv)) -> Field g kv -> Field h kv
diff --git a/src/Data/Extensible/Label.hs b/src/Data/Extensible/Label.hs
--- a/src/Data/Extensible/Label.hs
+++ b/src/Data/Extensible/Label.hs
@@ -25,7 +25,7 @@
 
 -- | Specialised version of 'itemAssoc'. Stands for "eXtensible LaBel"
 xlb :: Proxy k -> FieldOptic k
-xlb = itemAssoc
+xlb t = itemAssoc t
 
 instance (Extensible f p e
   , Lookup xs k v
diff --git a/src/Data/Extensible/Product.hs b/src/Data/Extensible/Product.hs
--- a/src/Data/Extensible/Product.hs
+++ b/src/Data/Extensible/Product.hs
@@ -130,7 +130,7 @@
 hmapWithIndexWith :: forall c xs g h. Forall c xs
   => (forall x. c x => Membership xs x -> g x -> h x)
   -> xs :& g -> xs :& h
-hmapWithIndexWith = hmapWithIndexFor (Proxy @ c)
+hmapWithIndexWith = hmapWithIndexFor (Proxy @c)
 
 -- | Transform every element in a product, preserving the order.
 --
@@ -178,7 +178,7 @@
 
 hfoldrWithIndexWith :: forall c xs h r. (Forall c xs)
   => (forall x. c x => Membership xs x -> h x -> r -> r) -> r -> xs :& h -> r
-hfoldrWithIndexWith f r xs = henumerateFor (Proxy @ c) (Proxy @ xs) (\i -> f i (hlookup i xs)) r
+hfoldrWithIndexWith f r xs = henumerateFor (Proxy @c) (Proxy @xs) (\i -> f i (hlookup i xs)) r
 {-# INLINE hfoldrWithIndexWith #-}
 
 -- | Constrained 'hfoldlWithIndex'
@@ -214,7 +214,7 @@
 -- | Constrained 'hfoldMap'
 hfoldMapWith :: forall c xs h a. (Forall c xs, Monoid a)
   => (forall x. c x => h x -> a) -> xs :& h -> a
-hfoldMapWith f = hfoldMapWithIndexFor (Proxy @ c) (const f)
+hfoldMapWith f = hfoldMapWithIndexFor (Proxy @c) (const f)
 {-# INLINE hfoldMapWith #-}
 
 -- | Traverse all elements and combine the result sequentially.
@@ -277,7 +277,7 @@
 
 -- | Pure version of 'hgenerateFor'.
 htabulateWith :: forall c xs h. Forall c xs => (forall x. c x => Membership xs x -> h x) -> xs :& h
-htabulateWith f = hfrozen $ newFor (Proxy @ c) f
+htabulateWith f = hfrozen $ newFor (Proxy @c) f
 {-# INLINE htabulateWith #-}
 
 -- | A product filled with the specified value.
@@ -287,7 +287,7 @@
 
 -- | A product filled with the specified value.
 hrepeatWith :: forall c xs h. Forall c xs => (forall x. c x => h x) -> xs :& h
-hrepeatWith f = htabulateFor (Proxy @ c) (const f)
+hrepeatWith f = htabulateFor (Proxy @c) (const f)
 {-# INLINE hrepeatWith #-}
 
 -- | 'Applicative' version of 'htabulateFor'.
@@ -299,7 +299,7 @@
 -- | 'Applicative' version of 'htabulateFor'.
 hgenerateWith :: forall c xs f h. (Forall c xs, Applicative f)
   => (forall x. c x => Membership xs x -> f (h x)) -> f (xs :& h)
-hgenerateWith f = fmap fromHList $ hgenerateListFor (Proxy @ c) f
+hgenerateWith f = fmap fromHList $ hgenerateListFor (Proxy @c) f
 {-# INLINE hgenerateWith #-}
 
 -- | Accumulate sums on a product.
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
@@ -3,7 +3,6 @@
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE MagicHash, UnboxedTuples #-}
-{-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE UndecidableInstances #-}
 ------------------------------------------------------------------------
 -- |
@@ -63,6 +62,9 @@
 import qualified Data.StateVar as V
 import GHC.Types
 import qualified Type.Membership.HList as L
+#if __GLASGOW_HASKELL__ >= 900
+import Unsafe.Coerce
+#endif
 
 -- | Mutable type-indexed struct.
 data Struct s (h :: k -> Type) (xs :: [k]) = Struct (SmallMutableArray# s Any)