packages feed

coordinate 0.0.1 → 0.0.2

raw patch · 8 files changed

+171/−67 lines, 8 files

Files

coordinate.cabal view
@@ -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ɐɥ>
src/Data/GPS/Coordinate/Coordinate.hs view
@@ -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
src/Data/GPS/Coordinate/DegreesLatitude.hs view
@@ -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+
src/Data/GPS/Coordinate/DegreesLongitude.hs view
@@ -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
src/Data/GPS/Coordinate/Latitude.hs view
@@ -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)
src/Data/GPS/Coordinate/Longitude.hs view
@@ -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)
src/Data/GPS/Coordinate/Minutes.hs view
@@ -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
src/Data/GPS/Coordinate/Seconds.hs view
@@ -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