diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.3.1.0 [2020-01-29]
+- Added "native" classes as exports for `Records` and `Variants` (e.g., `ToNative`, `FromNative`)
+- Added more example hs files.
+
 ## 0.3.0.0 [2019-05-28]
 - Added `HasField` and `AsConstructor` instances (from generic-lens) for `Rec` and `Var` respectively.
 - Added record-overwrite function `.//`.
diff --git a/Data/Row/Records.hs b/Data/Row/Records.hs
--- a/Data/Row/Records.hs
+++ b/Data/Row/Records.hs
@@ -4,7 +4,7 @@
 --
 -- This module implements extensible records using closed type famillies.
 --
--- See Examples.hs for examples.
+-- See Examples.lhs for examples.
 --
 -- Lists of (label,type) pairs are kept sorted thereby ensuring
 -- that { x = 0, y = 0 } and { y = 0, x = 0 } have the same type.
@@ -43,6 +43,7 @@
   -- * Native Conversion
   -- $native
   , toNative, toNativeExact, fromNative
+  , ToNative, ToNativeExact, FromNative
   -- * Dynamic Conversion
   , toDynamicMap, fromDynamicMap
   -- * Row operations
@@ -573,84 +574,90 @@
 
 -- | Conversion helper to bring a record back into a Haskell type. Note that the
 -- native Haskell type must be an instance of 'Generic'.
-class ToNative a ρ where
+class ToNativeG a ρ where
   toNative' :: Rec ρ -> a x
 
-instance ToNative cs ρ => ToNative (G.D1 m cs) ρ where
+instance ToNativeG cs ρ => ToNativeG (G.D1 m cs) ρ where
   toNative' xs = G.M1 $ toNative' xs
 
-instance ToNative cs ρ => ToNative (G.C1 m cs) ρ where
+instance ToNativeG cs ρ => ToNativeG (G.C1 m cs) ρ where
   toNative' xs = G.M1 $ toNative' xs
 
-instance ToNative G.U1 ρ where
+instance ToNativeG G.U1 ρ where
   toNative' _ = G.U1
 
 instance (KnownSymbol name, ρ .! name ≈ t)
-    => ToNative (G.S1 ('G.MetaSel ('Just name) p s l) (G.Rec0 t)) ρ where
+    => ToNativeG (G.S1 ('G.MetaSel ('Just name) p s l) (G.Rec0 t)) ρ where
   toNative' r = G.M1 $ G.K1 $ r .! (Label @name)
 
-instance (ToNative l ρ, ToNative r ρ)
-    => ToNative (l G.:*: r) ρ where
+instance (ToNativeG l ρ, ToNativeG r ρ)
+    => ToNativeG (l G.:*: r) ρ where
   toNative' r = toNative' r G.:*: toNative' r
 
+type ToNative t ρ = (G.Generic t, ToNativeG (G.Rep t) ρ)
+
 -- | Convert a record to a native Haskell type.
-toNative :: forall t ρ. (G.Generic t, ToNative (G.Rep t) ρ) => Rec ρ -> t
+toNative :: ToNative t ρ => Rec ρ -> t
 toNative = G.to . toNative'
 
 
 -- | Conversion helper to bring a record back into a Haskell type. Note that the
 -- native Haskell type must be an instance of 'Generic'.
-class ToNativeExact a ρ where
+class ToNativeExactG a ρ where
   toNativeExact' :: Rec ρ -> a x
 
-instance ToNativeExact cs ρ => ToNativeExact (G.D1 m cs) ρ where
+instance ToNativeExactG cs ρ => ToNativeExactG (G.D1 m cs) ρ where
   toNativeExact' xs = G.M1 $ toNativeExact' xs
 
-instance ToNativeExact cs ρ => ToNativeExact (G.C1 m cs) ρ where
+instance ToNativeExactG cs ρ => ToNativeExactG (G.C1 m cs) ρ where
   toNativeExact' xs = G.M1 $ toNativeExact' xs
 
-instance ToNativeExact G.U1 Empty where
+instance ToNativeExactG G.U1 Empty where
   toNativeExact' _ = G.U1
 
 instance (KnownSymbol name, ρ ≈ name .== t)
-    => ToNativeExact (G.S1 ('G.MetaSel ('Just name) p s l) (G.Rec0 t)) ρ where
+    => ToNativeExactG (G.S1 ('G.MetaSel ('Just name) p s l) (G.Rec0 t)) ρ where
   toNativeExact' r = G.M1 $ G.K1 $ r .! (Label @name)
 
-instance (ToNativeExact l ρ₁, ToNativeExact r ρ₂, ρ ≈ ρ₁ .+ ρ₂, Disjoint ρ₁ ρ₂)
-    => ToNativeExact (l G.:*: r) ρ where
+instance (ToNativeExactG l ρ₁, ToNativeExactG r ρ₂, ρ ≈ ρ₁ .+ ρ₂, Disjoint ρ₁ ρ₂)
+    => ToNativeExactG (l G.:*: r) ρ where
   toNativeExact' r = toNativeExact' r1 G.:*: toNativeExact' r2
     where
       (r1 :: Rec ρ₁) :+ (r2 :: Rec ρ₂) = r
 
+type ToNativeExact t ρ = (G.Generic t, ToNativeExactG (G.Rep t) ρ)
+
 -- | Convert a record to an exactly matching native Haskell type.
-toNativeExact :: forall t ρ. (G.Generic t, ToNativeExact (G.Rep t) ρ) => Rec ρ -> t
+toNativeExact :: ToNativeExact t ρ => Rec ρ -> t
 toNativeExact = G.to . toNativeExact'
 
 
 -- | Conversion helper to turn a Haskell record into a row-types extensible
 -- record. Note that the native Haskell type must be an instance of 'Generic'.
-class FromNative a ρ where
+class FromNativeG a ρ where
   fromNative' :: a x -> Rec ρ
 
-instance FromNative cs ρ => FromNative (G.D1 m cs) ρ where
+instance FromNativeG cs ρ => FromNativeG (G.D1 m cs) ρ where
   fromNative' (G.M1 xs) = fromNative' xs
 
-instance FromNative cs ρ => FromNative (G.C1 m cs) ρ where
+instance FromNativeG cs ρ => FromNativeG (G.C1 m cs) ρ where
   fromNative' (G.M1 xs) = fromNative' xs
 
-instance FromNative G.U1 Empty where
+instance FromNativeG G.U1 Empty where
   fromNative' G.U1 = empty
 
 instance (KnownSymbol name, ρ ≈ name .== t)
-    => FromNative (G.S1 ('G.MetaSel ('Just name) p s l) (G.Rec0 t)) ρ where
+    => FromNativeG (G.S1 ('G.MetaSel ('Just name) p s l) (G.Rec0 t)) ρ where
   fromNative' (G.M1 (G.K1 x)) =  (Label @name) .== x
 
-instance (FromNative l ρ₁, FromNative r ρ₂, ρ ≈ ρ₁ .+ ρ₂)
-    => FromNative (l G.:*: r) ρ where
+instance (FromNativeG l ρ₁, FromNativeG r ρ₂, ρ ≈ ρ₁ .+ ρ₂)
+    => FromNativeG (l G.:*: r) ρ where
   fromNative' (x G.:*: y) = fromNative' @l @ρ₁ x .+ fromNative' @r @ρ₂ y
 
+type FromNative t ρ = (G.Generic t, FromNativeG (G.Rep t) ρ)
+
 -- | Convert a Haskell record to a row-types Rec.
-fromNative :: forall t ρ. (G.Generic t, FromNative (G.Rep t) ρ) => t -> Rec ρ
+fromNative :: FromNative t ρ => t -> Rec ρ
 fromNative = fromNative' . G.from
 
 
diff --git a/Data/Row/Variants.hs b/Data/Row/Variants.hs
--- a/Data/Row/Variants.hs
+++ b/Data/Row/Variants.hs
@@ -28,6 +28,7 @@
   -- * Native Conversion
   -- $native
   , toNative, fromNative, fromNativeExact
+  , ToNative, FromNative, FromNativeExact
   -- * Row operations
   -- ** Map
   , Map, map, map', transform, transform'
@@ -425,83 +426,89 @@
 
 -- | Conversion helper to bring a variant back into a Haskell type. Note that the
 -- native Haskell type must be an instance of 'Generic'.
-class ToNative a ρ where
+class ToNativeG a ρ where
   toNative' :: Var ρ -> a x
 
-instance ToNative cs ρ => ToNative (G.D1 m cs) ρ where
+instance ToNativeG cs ρ => ToNativeG (G.D1 m cs) ρ where
   toNative' = G.M1 . toNative'
 
-instance ToNative G.V1 Empty where
+instance ToNativeG G.V1 Empty where
   toNative' = impossible
 
 instance (KnownSymbol name, ρ ≈ name .== t)
-    => ToNative (G.C1 ('G.MetaCons name fixity sels)
+    => ToNativeG (G.C1 ('G.MetaCons name fixity sels)
                 (G.S1 m (G.Rec0 t))) ρ where
   toNative' = G.M1 . G.M1 . G.K1 . snd . unSingleton
 
-instance ( ToNative l ρ₁, ToNative r ρ₂, ρ₂ ≈ ρ .\\ ρ₁, ρ ≈ ρ₁ .+ ρ₂
+instance ( ToNativeG l ρ₁, ToNativeG r ρ₂, ρ₂ ≈ ρ .\\ ρ₁, ρ ≈ ρ₁ .+ ρ₂
          , AllUniqueLabels ρ₁, Forall ρ₂ Unconstrained1)
-    => ToNative (l G.:+: r) ρ where
+    => ToNativeG (l G.:+: r) ρ where
   toNative' v = case multiTrial @ρ₁ @ρ v of
     Left  v' -> G.L1 $ toNative' @_ @ρ₁ v'
     Right v' -> G.R1 $ toNative' @_ @ρ₂ v'
 
+type ToNative t ρ = (G.Generic t, ToNativeG (G.Rep t) ρ)
+
 -- | Convert a variant to a native Haskell type.
-toNative :: forall t ρ. (G.Generic t, ToNative (G.Rep t) ρ) => Var ρ -> t
+toNative :: ToNative t ρ => Var ρ -> t
 toNative = G.to . toNative'
 
 -- | Conversion helper to turn a Haskell variant into a row-types extensible
 -- variant. Note that the native Haskell type must be an instance of 'Generic'.
-class FromNative a ρ where
+class FromNativeG a ρ where
   fromNative' :: a x -> Var ρ
 
-instance FromNative cs ρ => FromNative (G.D1 m cs) ρ where
+instance FromNativeG cs ρ => FromNativeG (G.D1 m cs) ρ where
   fromNative' (G.M1 v) = fromNative' v
 
-instance FromNative G.V1 ρ where
+instance FromNativeG G.V1 ρ where
   fromNative' = \ case
 
 instance (KnownSymbol name, ρ .! name ≈ t, AllUniqueLabels ρ)
-    => FromNative (G.C1 ('G.MetaCons name fixity sels)
+    => FromNativeG (G.C1 ('G.MetaCons name fixity sels)
                   (G.S1 m (G.Rec0 t))) ρ where
   fromNative' (G.M1 (G.M1 (G.K1 x))) = IsJust (Label @name) x
 
-instance (FromNative l ρ, FromNative r ρ)
-    => FromNative (l G.:+: r) ρ where
+instance (FromNativeG l ρ, FromNativeG r ρ)
+    => FromNativeG (l G.:+: r) ρ where
   -- Ideally, we would use 'diversify' here instead of 'unsafeCoerce', but it
   -- makes the constraints really hairy.
   fromNative' (G.L1 x) = unsafeCoerce $ fromNative' @l @ρ x
   fromNative' (G.R1 y) = unsafeCoerce $ fromNative' @r @ρ y
 
+type FromNative t ρ = (G.Generic t, FromNativeG (G.Rep t) ρ)
+
 -- | Convert a Haskell record to a row-types Var.
-fromNative :: forall t ρ. (G.Generic t, FromNative (G.Rep t) ρ) => t -> Var ρ
+fromNative :: FromNative t ρ => t -> Var ρ
 fromNative = fromNative' . G.from
 
 -- | Conversion helper to turn a Haskell variant into a row-types extensible
 -- variant. Note that the native Haskell type must be an instance of 'Generic'.
-class FromNativeExact a ρ where
+class FromNativeExactG a ρ where
   fromNativeExact' :: a x -> Var ρ
 
-instance FromNativeExact cs ρ => FromNativeExact (G.D1 m cs) ρ where
+instance FromNativeExactG cs ρ => FromNativeExactG (G.D1 m cs) ρ where
   fromNativeExact' (G.M1 v) = fromNativeExact' v
 
-instance FromNativeExact G.V1 Empty where
+instance FromNativeExactG G.V1 Empty where
   fromNativeExact' = \ case
 
 instance (KnownSymbol name, ρ ≈ name .== t)
-    => FromNativeExact (G.C1 ('G.MetaCons name fixity sels)
+    => FromNativeExactG (G.C1 ('G.MetaCons name fixity sels)
                        (G.S1 m (G.Rec0 t))) ρ where
   fromNativeExact' (G.M1 (G.M1 (G.K1 x))) = IsJust (Label @name) x
 
-instance (FromNativeExact l ρ₁, FromNativeExact r ρ₂, ρ ≈ ρ₁ .+ ρ₂)
-    => FromNativeExact (l G.:+: r) ρ where
+instance (FromNativeExactG l ρ₁, FromNativeExactG r ρ₂, ρ ≈ ρ₁ .+ ρ₂)
+    => FromNativeExactG (l G.:+: r) ρ where
   -- Ideally, we would use 'diversify' here instead of 'unsafeCoerce', but it
   -- makes the constraints really hairy.
   fromNativeExact' (G.L1 x) = unsafeCoerce $ fromNativeExact' @l @ρ₁ x
   fromNativeExact' (G.R1 y) = unsafeCoerce $ fromNativeExact' @r @ρ₂ y
 
+type FromNativeExact t ρ = (G.Generic t, FromNativeExactG (G.Rep t) ρ)
+
 -- | Convert a Haskell record to a row-types Var.
-fromNativeExact :: forall t ρ. (G.Generic t, FromNativeExact (G.Rep t) ρ) => t -> Var ρ
+fromNativeExact :: FromNativeExact t ρ => t -> Var ρ
 fromNativeExact = fromNativeExact' . G.from
 
 
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -7,16 +7,15 @@
 Row-types is a library of open records and variants for Haskell using closed
 type families and type literals (among other things...).
 See [examples/Examples.lhs](https://raw.githubusercontent.com/target/row-types/master/examples/Examples.lhs)
-for an overview of how this library can be used.
-
-Available on [Hackage](https://hackage.haskell.org/package/row-types)
+for a literate Haskell file that functions as an overview of how this library can be used,
+and check out [the website](https://target.github.io/row-types/) for further examples.
 
+Available on [Hackage](https://hackage.haskell.org/package/row-types).
 
 This work is a branch from CTRex [1,2] with other inspiration from data-diverse [3].
 My thanks to the authors and contributors of those libraries!
 
-[1] https://wiki.haskell.org/CTRex
 
-[2] https://hackage.haskell.org/package/CTRex/docs/Data-OpenRecords.html
-
+[1] https://wiki.haskell.org/CTRex \
+[2] https://hackage.haskell.org/package/CTRex/docs/Data-OpenRecords.html \
 [3] https://hackage.haskell.org/package/data-diverse
diff --git a/row-types.cabal b/row-types.cabal
--- a/row-types.cabal
+++ b/row-types.cabal
@@ -1,5 +1,5 @@
 Name:                row-types
-Version:             0.3.0.0
+Version:             0.3.1.0
 License:             MIT
 License-file:        LICENSE
 Author:              Daniel Winograd-Cort, Matthew Farkas-Dyck