diff --git a/coordinate.cabal b/coordinate.cabal
--- a/coordinate.cabal
+++ b/coordinate.cabal
@@ -1,5 +1,5 @@
 name:               coordinate
-version:            0.0.1
+version:            0.0.2
 license:            BSD3
 license-File:       etc/LICENCE
 author:             Tony Morris <ʇǝu˙sıɹɹoɯʇ@ןןǝʞsɐɥ>
diff --git a/src/Data/GPS/Coordinate/Coordinate.hs b/src/Data/GPS/Coordinate/Coordinate.hs
--- a/src/Data/GPS/Coordinate/Coordinate.hs
+++ b/src/Data/GPS/Coordinate/Coordinate.hs
@@ -1,14 +1,15 @@
 module Data.GPS.Coordinate.Coordinate(
   Coordinate
-, coordinate
-, coordinate'
-, coordinateLat
-, coordinateLon
-, coordinateLatlon
+, HasCoordinate(..)
+, coordinateLatLon
+, coordinateLonLat
+, coordinateDMSLatLon
+, coordinateLatDMSLon
+, coordinateDMSLatDMSLon
 ) where
 
-import Prelude(Eq, Show, (.))
-import Control.Lens(Iso', iso, mapping, swapped, withIso)
+import Prelude(Eq, Show, id, (.))
+import Control.Lens(Iso', Lens', iso, lens, mapping, swapped, withIso)
 import Data.GPS.Coordinate.Latitude
 import Data.GPS.Coordinate.Longitude
 import Data.GPS.Coordinate.DegreesLatitude
@@ -22,28 +23,52 @@
     Longitude
   deriving (Eq, Show)
 
-coordinate ::
+coordinateLatLon ::
   Iso' (Latitude, Longitude) Coordinate
-coordinate =
+coordinateLatLon =
   iso (\(lat, lon) -> Coordinate lat lon) (\(Coordinate lat lon) -> (lat, lon))
 
-coordinate' ::
+coordinateLonLat ::
   Iso' (Longitude, Latitude) Coordinate
-coordinate' =
-  swapped . coordinate
+coordinateLonLat =
+  swapped . coordinateLatLon
 
-coordinateLat ::
+coordinateDMSLatLon ::
   Iso' ((DegreesLatitude, Minutes, Seconds), Longitude) Coordinate
-coordinateLat =
-  swapped . mapping latitude . coordinate'
+coordinateDMSLatLon =
+  swapped . mapping dmsLatitude . coordinateLonLat
 
-coordinateLon ::
+coordinateLatDMSLon ::
   Iso' (Latitude, (DegreesLongitude, Minutes, Seconds)) Coordinate
-coordinateLon =
-  mapping longitude . coordinate
+coordinateLatDMSLon =
+  mapping dmsLongitude . coordinateLatLon
 
-coordinateLatlon ::
+coordinateDMSLatDMSLon ::
   Iso' ((DegreesLatitude, Minutes, Seconds), (DegreesLongitude, Minutes, Seconds)) Coordinate
-coordinateLatlon =
-  iso (\((td, tm, ts), (nd, nm, ns)) -> Coordinate (withIso latitude (\k _ -> k (td, tm, ts))) (withIso longitude (\k _ -> k (nd, nm, ns))))
-      (\(Coordinate lat lon) -> (withIso latitude (\_ k -> k lat), withIso longitude (\_ k -> k lon)))
+coordinateDMSLatDMSLon =
+  iso (\((td, tm, ts), (nd, nm, ns)) -> Coordinate (withIso dmsLatitude (\k _ -> k (td, tm, ts))) (withIso dmsLongitude (\k _ -> k (nd, nm, ns))))
+      (\(Coordinate lat lon) -> (withIso dmsLatitude (\_ k -> k lat), withIso dmsLongitude (\_ k -> k lon)))
+
+class HasCoordinate t where
+  coordinate ::
+    Lens' t Coordinate
+
+instance HasCoordinate Coordinate where
+  coordinate =
+    id
+
+instance HasLatitude Coordinate where
+  latitude =
+    lens (\(Coordinate lat _) -> lat) (\(Coordinate _ lon) lat -> Coordinate lat lon)
+
+instance HasLongitude Coordinate where
+  longitude =
+    lens (\(Coordinate _ lon) -> lon) (\(Coordinate lat _) lon -> Coordinate lat lon)
+
+instance HasDegreesLatitude Coordinate where
+  degreesLatitude =
+    latitude . degreesLatitude
+
+instance HasDegreesLongitude Coordinate where
+  degreesLongitude =
+    longitude . degreesLongitude
diff --git a/src/Data/GPS/Coordinate/DegreesLatitude.hs b/src/Data/GPS/Coordinate/DegreesLatitude.hs
--- a/src/Data/GPS/Coordinate/DegreesLatitude.hs
+++ b/src/Data/GPS/Coordinate/DegreesLatitude.hs
@@ -1,21 +1,31 @@
 module Data.GPS.Coordinate.DegreesLatitude(
   DegreesLatitude
-, degreesLatitude
+, HasDegreesLatitude(..)
+, nDegreesLatitude
 ) where
 
-import Prelude(Int, Bool(..), Eq, Show, Ord(..), (&&))
+import Prelude(Int, Bool(..), Eq, Show, Ord(..), id, (&&))
 import Data.Maybe(Maybe(..))
-import Control.Lens(Prism', prism')
+import Control.Lens(Prism', Lens', prism')
 
 newtype DegreesLatitude =
   DegreesLatitude Int
   deriving (Eq, Show)
 
-degreesLatitude ::
+nDegreesLatitude ::
   Prism' Int DegreesLatitude
-degreesLatitude =
+nDegreesLatitude =
   prism'
     (\(DegreesLatitude i) -> i)
     (\i -> case i >= -90 && i <= 90 of
              True -> Just (DegreesLatitude i)
              False -> Nothing)
+
+class HasDegreesLatitude t where
+  degreesLatitude ::
+    Lens' t DegreesLatitude
+
+instance HasDegreesLatitude DegreesLatitude where
+  degreesLatitude =
+    id
+
diff --git a/src/Data/GPS/Coordinate/DegreesLongitude.hs b/src/Data/GPS/Coordinate/DegreesLongitude.hs
--- a/src/Data/GPS/Coordinate/DegreesLongitude.hs
+++ b/src/Data/GPS/Coordinate/DegreesLongitude.hs
@@ -1,21 +1,30 @@
 module Data.GPS.Coordinate.DegreesLongitude(
   DegreesLongitude
-, degreesLongitude
+, HasDegreesLongitude(..)
+, nDegreesLongitude
 ) where
 
-import Prelude(Int, Bool(..), Eq, Show, Ord(..), (&&))
+import Prelude(Int, Bool(..), Eq, Show, Ord(..), id, (&&))
 import Data.Maybe(Maybe(..))
-import Control.Lens(Prism', prism')
+import Control.Lens(Prism', Lens', prism')
 
 newtype DegreesLongitude =
   DegreesLongitude Int
   deriving (Eq, Show)
 
-degreesLongitude ::
+nDegreesLongitude ::
   Prism' Int DegreesLongitude
-degreesLongitude =
+nDegreesLongitude  =
   prism'
     (\(DegreesLongitude i) -> i)
     (\i -> case i >= -180 && i <= 180 of
              True -> Just (DegreesLongitude i)
              False -> Nothing)
+
+class HasDegreesLongitude t where
+  degreesLongitude ::
+    Lens' t DegreesLongitude
+
+instance HasDegreesLongitude DegreesLongitude where
+  degreesLongitude =
+    id
diff --git a/src/Data/GPS/Coordinate/Latitude.hs b/src/Data/GPS/Coordinate/Latitude.hs
--- a/src/Data/GPS/Coordinate/Latitude.hs
+++ b/src/Data/GPS/Coordinate/Latitude.hs
@@ -1,11 +1,12 @@
 module Data.GPS.Coordinate.Latitude(
   Latitude
-, latitude
-, latitudeF
+, HasLatitude(..)
+, dmsLatitude
+, fracLatitude
 ) where
 
-import Prelude(Double, Eq, Show, Ord(..), Num(..), Bool(..), Monad(..), (&&), properFraction, fromIntegral)
-import Control.Lens(Iso', Prism', iso, prism', (#), (^?))
+import Prelude(Double, Eq, Show, Ord(..), Num(..), Bool(..), Monad(..), id, (&&), properFraction, fromIntegral)
+import Control.Lens(Iso', Prism', Lens', iso, prism', lens, (#), (^?))
 import Data.GPS.Coordinate.DegreesLatitude
 import Data.GPS.Coordinate.Minutes
 import Data.GPS.Coordinate.Seconds
@@ -17,19 +18,39 @@
     Seconds
   deriving (Eq, Show)
 
-latitude ::
+dmsLatitude ::
   Iso' (DegreesLatitude, Minutes, Seconds) Latitude
-latitude =
+dmsLatitude =
   iso (\(d, m, s) -> Latitude d m s) (\(Latitude d m s) -> (d, m, s))
 
-latitudeF ::
+fracLatitude ::
   Prism' Double Latitude
-latitudeF =
+fracLatitude =
   prism' (\(Latitude d m s) ->
-    fromIntegral (degreesLatitude # d) + seconds # s + fromIntegral (minutes # m * 60))
+    fromIntegral (nDegreesLatitude # d) + nSeconds # s + fromIntegral (nMinutes # m * 60))
     (\x -> let (d, z) = properFraction x
                (m, s) = properFraction ((z :: Double) * 60)
-           in do d' <- d ^? degreesLatitude
-                 m' <- m ^? minutes
-                 s' <- s ^? seconds
+           in do d' <- d ^? nDegreesLatitude
+                 m' <- m ^? nMinutes
+                 s' <- s ^? nSeconds
                  return (Latitude d' m' s'))
+
+class HasLatitude t where
+  latitude ::
+    Lens' t Latitude
+
+instance HasLatitude Latitude where
+  latitude =
+    id
+
+instance HasDegreesLatitude Latitude where
+  degreesLatitude =
+    lens (\(Latitude d _ _) -> d) (\(Latitude _ m s) d -> Latitude d m s)
+
+instance HasMinutes Latitude where
+  minutes =
+    lens (\(Latitude _ m _) -> m) (\(Latitude d _ s) m -> Latitude d m s)
+
+instance HasSeconds Latitude where
+  seconds =
+    lens (\(Latitude _ _ s) -> s) (\(Latitude d m _) s -> Latitude d m s)
diff --git a/src/Data/GPS/Coordinate/Longitude.hs b/src/Data/GPS/Coordinate/Longitude.hs
--- a/src/Data/GPS/Coordinate/Longitude.hs
+++ b/src/Data/GPS/Coordinate/Longitude.hs
@@ -1,11 +1,12 @@
 module Data.GPS.Coordinate.Longitude(
   Longitude
-, longitude
-, longitudeF
+, HasLongitude(..)
+, dmsLongitude
+, fracLongitude
 ) where
 
-import Prelude(Double, Eq, Show, Ord(..), Num(..), Bool(..), Monad(..), (&&), properFraction, fromIntegral)
-import Control.Lens(Iso', Prism', iso, prism', (#), (^?))
+import Prelude(Double, Eq, Show, Ord(..), Num(..), Bool(..), Monad(..), id, (&&), properFraction, fromIntegral)
+import Control.Lens(Iso', Prism', Lens', iso, prism', lens, (#), (^?))
 import Data.GPS.Coordinate.DegreesLongitude
 import Data.GPS.Coordinate.Minutes
 import Data.GPS.Coordinate.Seconds
@@ -17,19 +18,39 @@
     Seconds
   deriving (Eq, Show)
 
-longitude ::
+dmsLongitude ::
   Iso' (DegreesLongitude, Minutes, Seconds) Longitude
-longitude =
+dmsLongitude =
   iso (\(d, m, s) -> Longitude d m s) (\(Longitude d m s) -> (d, m, s))
 
-longitudeF ::
+fracLongitude ::
   Prism' Double Longitude
-longitudeF =
+fracLongitude =
   prism' (\(Longitude d m s) ->
-    fromIntegral (degreesLongitude # d) + seconds # s + fromIntegral (minutes # m * 60))
+    fromIntegral (nDegreesLongitude  # d) + nSeconds # s + fromIntegral (nMinutes # m * 60))
     (\x -> let (d, z) = properFraction x
                (m, s) = properFraction ((z :: Double) * 60)
-           in do d' <- d ^? degreesLongitude
-                 m' <- m ^? minutes
-                 s' <- s ^? seconds
+           in do d' <- d ^? nDegreesLongitude
+                 m' <- m ^? nMinutes
+                 s' <- s ^? nSeconds
                  return (Longitude d' m' s'))
+
+class HasLongitude t where
+  longitude ::
+    Lens' t Longitude
+
+instance HasLongitude Longitude where
+  longitude =
+    id
+
+instance HasDegreesLongitude Longitude where
+  degreesLongitude =
+    lens (\(Longitude d _ _) -> d) (\(Longitude _ m s) d -> Longitude d m s)
+
+instance HasMinutes Longitude where
+  minutes =
+    lens (\(Longitude _ m _) -> m) (\(Longitude d _ s) m -> Longitude d m s)
+
+instance HasSeconds Longitude where
+  seconds =
+    lens (\(Longitude _ _ s) -> s) (\(Longitude d m _) s -> Longitude d m s)
diff --git a/src/Data/GPS/Coordinate/Minutes.hs b/src/Data/GPS/Coordinate/Minutes.hs
--- a/src/Data/GPS/Coordinate/Minutes.hs
+++ b/src/Data/GPS/Coordinate/Minutes.hs
@@ -1,21 +1,30 @@
 module Data.GPS.Coordinate.Minutes(
   Minutes
-, minutes
+, HasMinutes(..)
+, nMinutes
 ) where
 
-import Prelude(Int, Bool(..), Eq, Show, Ord(..), (&&))
+import Prelude(Functor, Int, Bool(..), Eq, Show, Ord(..), (&&), id)
 import Data.Maybe(Maybe(..))
-import Control.Lens(Prism', prism')
+import Control.Lens(Prism', Lens', prism')
 
 newtype Minutes =
   Minutes Int
   deriving (Eq, Show)
 
-minutes ::
+nMinutes ::
   Prism' Int Minutes
-minutes =
+nMinutes =
   prism'
     (\(Minutes i) -> i)
     (\i -> case i >= 0 && i < 60 of
              True -> Just (Minutes i)
              False -> Nothing)
+
+class HasMinutes t where
+  minutes ::
+    Lens' t Minutes
+
+instance HasMinutes Minutes where
+  minutes =
+    id
diff --git a/src/Data/GPS/Coordinate/Seconds.hs b/src/Data/GPS/Coordinate/Seconds.hs
--- a/src/Data/GPS/Coordinate/Seconds.hs
+++ b/src/Data/GPS/Coordinate/Seconds.hs
@@ -1,21 +1,30 @@
 module Data.GPS.Coordinate.Seconds(
   Seconds
-, seconds
+, HasSeconds(..)
+, nSeconds
 ) where
 
-import Prelude(Double, Bool(..), Eq, Show, Ord(..), (&&))
+import Prelude(Double, Bool(..), Eq, Show, Ord(..), id, (&&))
 import Data.Maybe(Maybe(..))
-import Control.Lens(Prism', prism')
+import Control.Lens(Prism', Lens', prism')
 
 newtype Seconds =
   Seconds Double
   deriving (Eq, Show)
 
-seconds ::
+nSeconds ::
   Prism' Double Seconds
-seconds =
+nSeconds =
   prism'
     (\(Seconds d) -> d)
     (\d -> case d >= 0 && d < 60 of
              True -> Just (Seconds d)
              False -> Nothing)
+
+class HasSeconds t where
+  seconds ::
+    Lens' t Seconds
+
+instance HasSeconds Seconds where
+  seconds =
+    id