diff --git a/generic-lens.cabal b/generic-lens.cabal
--- a/generic-lens.cabal
+++ b/generic-lens.cabal
@@ -1,6 +1,6 @@
 name:                generic-lens
 
-version:             0.1.0.0
+version:             0.2.0.0
 
 synopsis:            Generic data-structure operations exposed as lenses.
 
diff --git a/src/Data/Generics/Internal/Lens.hs b/src/Data/Generics/Internal/Lens.hs
--- a/src/Data/Generics/Internal/Lens.hs
+++ b/src/Data/Generics/Internal/Lens.hs
@@ -16,7 +16,7 @@
 module Data.Generics.Internal.Lens where
 
 import Control.Applicative  ( Const (..) )
-import GHC.Generics         ( (:*:) (..), Generic (..), M1 (..), Rep )
+import GHC.Generics         ( (:*:) (..), Generic (..), M1 (..), Rep, (:+:) (..) )
 
 -- | Identity functor
 newtype Identity a
@@ -34,6 +34,7 @@
 -- | Getting
 (^.) :: s -> ((a -> Const a a) -> s -> Const a s) -> a
 s ^. l = getConst (l Const s)
+infixl 8 ^.
 
 -- | Setting
 set :: ((a -> Identity b) -> s -> Identity t) -> b -> s -> t
@@ -49,6 +50,10 @@
 second :: Lens' ((a :*: b) x) (b x)
 second f (a :*: b)
   = fmap (a :*:) (f b)
+
+combine :: Lens' (s x) a -> Lens' (t x) a -> Lens' ((:+:) s t x) a
+combine sa _ f (L1 s) = fmap (\a -> L1 (set sa a s)) (f (s ^. sa))
+combine _ ta f (R1 t) = fmap (\a -> R1 (set ta a t)) (f (t ^. ta))
 
 -- | A type and its generic representation are isomorphic
 repIso :: Generic a => Lens' a (Rep a x)
diff --git a/src/Data/Generics/Record.hs b/src/Data/Generics/Record.hs
--- a/src/Data/Generics/Record.hs
+++ b/src/Data/Generics/Record.hs
@@ -18,7 +18,7 @@
   (
     -- * Subtype relationship
     Subtype  (..)
-  , subtype
+  , super
 
     -- * Magic lens
   , HasField (..)
diff --git a/src/Data/Generics/Record/HasField.hs b/src/Data/Generics/Record/HasField.hs
--- a/src/Data/Generics/Record/HasField.hs
+++ b/src/Data/Generics/Record/HasField.hs
@@ -118,6 +118,9 @@
 instance (GHasFieldProd field s s' a (Contains field s)) => GHasField field (s :*: s') a where
   glabel = prodLabel @field @_ @_ @_ @(Contains field s)
 
+instance (GHasField field s a, GHasField field s' a) => GHasField field (s :+: s') a where
+  glabel = combine (glabel @field @s) (glabel @field @s')
+
 instance GHasField field (S1 ('MetaSel ('Just field) p f b) (Rec0 a)) a where
   glabel = lensM . glabel @field
 
diff --git a/src/Data/Generics/Record/Internal/Contains.hs b/src/Data/Generics/Record/Internal/Contains.hs
--- a/src/Data/Generics/Record/Internal/Contains.hs
+++ b/src/Data/Generics/Record/Internal/Contains.hs
@@ -1,11 +1,9 @@
 {-# LANGUAGE AllowAmbiguousTypes #-}
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE FlexibleInstances #-}
-{-# LANGUAGE FunctionalDependencies #-}
 {-# LANGUAGE PolyKinds #-}
 {-# LANGUAGE Rank2Types #-}
 {-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE UndecidableInstances #-}
@@ -38,6 +36,8 @@
     = 'Just t
   Contains field (f :*: g)
     = Contains field f <|> Contains field g
+  Contains field (f :+: g)
+    = Contains field f <&> Contains field g
   Contains field (S1 _ _)
     = 'Nothing
   Contains field (C1 m f)
@@ -56,4 +56,8 @@
 type family (a :: Maybe k) <|> (b :: Maybe k) :: Maybe k where
   'Just x <|> _  = 'Just x
   _ <|> b = b
+
+type family (a :: Maybe k) <&> (b :: Maybe k) :: Maybe k where
+  'Just x <&> 'Just x  = 'Just x
+  _ <&> _ = 'Nothing
 
diff --git a/src/Data/Generics/Record/Subtype.hs b/src/Data/Generics/Record/Subtype.hs
--- a/src/Data/Generics/Record/Subtype.hs
+++ b/src/Data/Generics/Record/Subtype.hs
@@ -49,7 +49,7 @@
 -----------------------------------------------------------------------------
 module Data.Generics.Record.Subtype
   ( Subtype (..)
-  , subtype
+  , super
   ) where
 
 import Data.Generics.Record.HasField
@@ -86,13 +86,13 @@
 -- | Structural subtype lens. Given a subtype relationship @sub :< sup@,
 --   we can focus on the @sub@ structure of @sup@.
 --
--- >>> human ^. subtype @Animal
+-- >>> human ^. super @Animal
 -- Animal {name = "Tunyasz", age = 50}
 --
--- >>> set (subtype @Animal) (Animal "dog" 10) human
+-- >>> set (super @Animal) (Animal "dog" 10) human
 -- Human {name = "dog", age = 10, address = "London"}
-subtype :: forall sup sub. Subtype sub sup => Lens' sub sup
-subtype f sub = fmap (flip smash sub) (f (upcast sub))
+super :: forall sup sub. Subtype sub sup => Lens' sub sup
+super f sub = fmap (flip smash sub) (f (upcast sub))
 
 --------------------------------------------------------------------------------
 -- * Generic upcasting