geojson 2.0.0 → 3.0.0

raw patch · 14 files changed

+237/−257 lines, 14 filesdep +containersPVP ok

version bump matches the API change (PVP)

Dependencies added: containers

API changes (from Hackage documentation)

Files

• geojson.cabal +4/−2
• src/Data/Geospatial/Internal/BasicTypes.hs +11/−46
• src/Data/Geospatial/Internal/GeoFeatureCollection.hs +2/−2
• src/Data/Geospatial/Internal/Geometry.hs +2/−2
• src/Data/Geospatial/Internal/Geometry/GeoMultiLine.hs +6/−6
• src/Data/Geospatial/Internal/Geometry/GeoMultiPoint.hs +6/−6
• src/Data/Geospatial/Internal/Geometry/GeoMultiPolygon.hs +6/−6
• src/Data/Geospatial/Internal/Geometry/GeoPolygon.hs +3/−3
• src/Data/LineString.hs +62/−56
• src/Data/LinearRing.hs +78/−62
• test/Arbitrary.hs +2/−10
• test/Data/LineStringTests.hs +16/−16
• test/Data/LinearRingTests.hs +20/−20
• test/Fixture.hs +19/−20

@@ -1,5 +1,5 @@ name:                  geojson-version:                2.0.0+version:                3.0.0 license:                BSD3 license-file:           LICENCE author:                 Dom De Re@@ -27,12 +27,13 @@ source-repository       this     type:               git     location:           https://github.com/indicatrix/hs-geojson.git-    tag:                2.0.0+    tag:                3.0.0  library     hs-source-dirs:     src     build-depends:      base < 5 &&     >= 4                     ,   aeson           >= 0.8+                    ,   containers      >= 0.5.10.1                     ,   deepseq         >= 1.4                     ,   lens            >= 4.11                     ,   semigroups      >= 0.16@@ -67,6 +68,7 @@     build-depends:      base < 5 &&     >= 4                     ,   aeson           >= 0.8                     ,   bytestring      >= 0.10+                    ,   containers      >= 0.5.10.1                     ,   geojson                     ,   tasty                     ,   tasty-hspec

@@ -38,14 +38,14 @@     ) where  import           Control.DeepSeq-import           Control.Lens.TH      (makeClassy)-import qualified Data.Aeson           as Aeson-import qualified Data.Aeson.Types     as AesonTypes-import qualified Data.Maybe           as DataMaybe-import qualified Data.Scientific      as Scientific-import qualified Data.Text            as Text-import qualified Data.Vector.Storable as VectorStorable-import           Foreign.Storable+import           Control.Lens.TH  (makeClassy)+import qualified Data.Aeson       as Aeson+import qualified Data.Aeson.Types as AesonTypes+import qualified Data.Foldable    as Foldable+import qualified Data.Maybe       as DataMaybe+import qualified Data.Scientific  as Scientific+import qualified Data.Sequence    as Sequence+import qualified Data.Text        as Text import           GHC.Generics  type Latitude = Double@@ -115,41 +115,6 @@     x <- Aeson.parseJSON o     DataMaybe.maybe (fail "Illegal coordinates") pure (_toGeoPoint x) -sizeOfDouble :: Int-sizeOfDouble = sizeOf (undefined :: Double)-{-# INLINE sizeOfDouble #-}--alignmentOfDouble :: Int-alignmentOfDouble = alignment (undefined :: Double)-{-# INLINE alignmentOfDouble #-}--instance VectorStorable.Storable PointXY where-  sizeOf _ = 2 * sizeOfDouble-  alignment _ = alignmentOfDouble-  {-# INLINE peek #-}-  peek p = PointXY <$> peekByteOff p 0 <*> peekByteOff p (1 * sizeOfDouble)-  {-# INLINE poke #-}-  poke p (PointXY x y) = pokeByteOff p 0 x  *> pokeByteOff p (1 * sizeOfDouble) y--instance VectorStorable.Storable GeoPositionWithoutCRS where-  sizeOf _ = 5 * sizeOfDouble-  alignment _ = alignmentOfDouble-  {-# INLINE peek #-}-  peek p = do-      t <- peekByteOff p 0-      case (t :: Double) of-        0 -> pure GeoEmpty-        1 -> fmap GeoPointXY $ PointXY <$> peekByteOff p (1 * sizeOfDouble) <*> peekByteOff p (2 * sizeOfDouble)-        2 -> fmap GeoPointXYZ $ PointXYZ  <$> peekByteOff p (1 * sizeOfDouble) <*> peekByteOff p (2 * sizeOfDouble) <*> peekByteOff p (3 * sizeOfDouble)-        _ -> fmap GeoPointXYZM $ PointXYZM <$> peekByteOff p (1 * sizeOfDouble) <*> peekByteOff p (2 * sizeOfDouble) <*> peekByteOff p (3 * sizeOfDouble) <*> peekByteOff p (4 * sizeOfDouble)-  {-# INLINE poke #-}-  poke p val =-    case val of-      GeoEmpty                           -> pokeByteOff p 0 (0 :: Double) *> pokeByteOff p (1 * sizeOfDouble) (0 :: Double)-      (GeoPointXY   (PointXY x y))       -> pokeByteOff p 0 (1 :: Double) *> pokeByteOff p (1 * sizeOfDouble) x  *> pokeByteOff p (2 * sizeOfDouble) y-      (GeoPointXYZ  (PointXYZ x y z))    -> pokeByteOff p 0 (2 :: Double) *> pokeByteOff p (1 * sizeOfDouble) x  *> pokeByteOff p (2 * sizeOfDouble) y *> pokeByteOff p (3 * sizeOfDouble) z-      (GeoPointXYZM (PointXYZM x y z m)) -> pokeByteOff p 0 (3 :: Double) *> pokeByteOff p (1 * sizeOfDouble) x  *> pokeByteOff p (2 * sizeOfDouble) y *> pokeByteOff p (3 * sizeOfDouble) z *> pokeByteOff p (4 * sizeOfDouble) m- type Name = Text.Text type Code = Int type Href = Text.Text@@ -184,12 +149,12 @@ -- e.g for WGS84: minLongitude, minLatitude, maxLongitude, maxLatitude -- The spec mentions that it can be part of a geometry object too but doesnt give an example, -- This implementation will ignore bboxes on Geometry objects, they can be added if required.-newtype BoundingBoxWithoutCRS = BoundingBoxWithoutCRS { unBoundingBoxWithoutCrs :: VectorStorable.Vector Double } deriving (Eq, Show, Generic, NFData)+newtype BoundingBoxWithoutCRS = BoundingBoxWithoutCRS { unBoundingBoxWithoutCrs :: Sequence.Seq Double } deriving (Eq, Show, Generic, NFData)  instance Aeson.FromJSON BoundingBoxWithoutCRS where     parseJSON obj = do         doubles <- Aeson.parseJSON obj :: AesonTypes.Parser [Double]-        pure . BoundingBoxWithoutCRS $ VectorStorable.fromList doubles+        pure . BoundingBoxWithoutCRS $ Sequence.fromList doubles  instance Aeson.ToJSON BoundingBoxWithoutCRS where-    toJSON = Aeson.toJSON . VectorStorable.toList . unBoundingBoxWithoutCrs+    toJSON = Aeson.toJSON . Foldable.toList . unBoundingBoxWithoutCrs

@@ -32,15 +32,15 @@                                                           (.:), (.:?), (.=)) import           Data.List                               ((++)) import           Data.Maybe                              (Maybe (..))+import qualified Data.Sequence                           as Sequence import           Data.Text                               (Text)-import qualified Data.Vector                             as Vector import           Prelude                                 (Eq (..), Show, ($))  -- | See Section 2.3 /Feature Collection Objects/ of the GeoJSON spec -- data GeoFeatureCollection a = GeoFeatureCollection     {   _boundingbox :: Maybe BoundingBoxWithoutCRS-    ,   _geofeatures :: Vector.Vector (GeoFeature a)+    ,   _geofeatures :: Sequence.Seq (GeoFeature a)     } deriving (Show, Eq)  makeLenses ''GeoFeatureCollection

@@ -56,8 +56,8 @@                                                                     object,                                                                     (.:), (.=)) import           Data.Aeson.Types                                  (Parser)+import qualified Data.Sequence                                     as Sequence import           Data.Text                                         (Text)-import qualified Data.Vector                                       as Vector import           GHC.Generics                                      (Generic)  @@ -70,7 +70,7 @@     |   MultiPolygon GeoMultiPolygon     |   Line GeoLine     |   MultiLine GeoMultiLine-    |   Collection (Vector.Vector GeospatialGeometry) deriving (Show, Eq, Generic, NFData)+    |   Collection (Sequence.Seq GeospatialGeometry) deriving (Show, Eq, Generic, NFData)  makePrisms ''GeospatialGeometry 

@@ -29,22 +29,22 @@ import           Data.Aeson                                (FromJSON (..),                                                             ToJSON (..),                                                             Value (..))-import qualified Data.Vector                               as Vector+import qualified Data.Sequence                             as Sequence import           GHC.Generics                              (Generic)  -newtype GeoMultiLine    = GeoMultiLine { _unGeoMultiLine :: Vector.Vector (LineString GeoPositionWithoutCRS) } deriving (Show, Eq, Generic, NFData)+newtype GeoMultiLine    = GeoMultiLine { _unGeoMultiLine :: Sequence.Seq(LineString GeoPositionWithoutCRS) } deriving (Show, Eq, Generic, NFData)  makeLenses ''GeoMultiLine   -- | Split GeoMultiLine coordinates into multiple GeoLines-splitGeoMultiLine:: GeoMultiLine -> Vector.Vector GeoLine-splitGeoMultiLine = Vector.map GeoLine . _unGeoMultiLine+splitGeoMultiLine:: GeoMultiLine -> Sequence.Seq GeoLine+splitGeoMultiLine = fmap GeoLine . _unGeoMultiLine  -- | Merge multiple GeoLines into one GeoMultiLine-mergeGeoLines :: Vector.Vector GeoLine -> GeoMultiLine-mergeGeoLines = GeoMultiLine . Vector.map _unGeoLine+mergeGeoLines :: Sequence.Seq GeoLine -> GeoMultiLine+mergeGeoLines = GeoMultiLine . fmap _unGeoLine  -- instances 

@@ -26,20 +26,20 @@ import           Control.Lens                               (makeLenses) import           Control.Monad                              (mzero) import qualified Data.Aeson                                 as Aeson-import qualified Data.Vector                                as Vector+import qualified Data.Sequence                              as Sequence import           GHC.Generics                               (Generic) -newtype GeoMultiPoint = GeoMultiPoint { _unGeoMultiPoint :: Vector.Vector GeoPositionWithoutCRS } deriving (Show, Eq, Generic, NFData)+newtype GeoMultiPoint = GeoMultiPoint { _unGeoMultiPoint :: Sequence.Seq GeoPositionWithoutCRS } deriving (Show, Eq, Generic, NFData)  makeLenses ''GeoMultiPoint  -- | Split GeoMultiPoint coordinates into multiple GeoPoints-splitGeoMultiPoint:: GeoMultiPoint -> Vector.Vector GeoPoint-splitGeoMultiPoint = Vector.map GeoPoint . _unGeoMultiPoint+splitGeoMultiPoint:: GeoMultiPoint -> Sequence.Seq GeoPoint+splitGeoMultiPoint = fmap GeoPoint . _unGeoMultiPoint  -- | Merge multiple GeoPoints into one GeoMultiPoint-mergeGeoPoints :: Vector.Vector GeoPoint -> GeoMultiPoint-mergeGeoPoints = GeoMultiPoint . Vector.map _unGeoPoint+mergeGeoPoints :: Sequence.Seq GeoPoint -> GeoMultiPoint+mergeGeoPoints = GeoMultiPoint . fmap _unGeoPoint  -- instances 

@@ -27,18 +27,18 @@ import           Control.Lens                                 (makeLenses) import           Control.Monad                                (mzero) import qualified Data.Aeson                                   as Aeson-import qualified Data.Vector                                  as Vector+import qualified Data.Sequence                                as Sequence import           GHC.Generics                                 (Generic) -newtype GeoMultiPolygon = GeoMultiPolygon { _unGeoMultiPolygon :: Vector.Vector (Vector.Vector (LinearRing.LinearRing GeoPositionWithoutCRS)) } deriving (Show, Eq, Generic, NFData)+newtype GeoMultiPolygon = GeoMultiPolygon { _unGeoMultiPolygon :: Sequence.Seq (Sequence.Seq (LinearRing.LinearRing GeoPositionWithoutCRS)) } deriving (Show, Eq, Generic, NFData)  -- | Split GeoMultiPolygon coordinates into multiple GeoPolygons-splitGeoMultiPolygon :: GeoMultiPolygon -> Vector.Vector GeoPolygon-splitGeoMultiPolygon = Vector.map GeoPolygon . _unGeoMultiPolygon+splitGeoMultiPolygon :: GeoMultiPolygon -> Sequence.Seq GeoPolygon+splitGeoMultiPolygon = fmap GeoPolygon . _unGeoMultiPolygon  -- | Merge multiple GeoPolygons into one GeoMultiPolygon-mergeGeoPolygons :: Vector.Vector GeoPolygon -> GeoMultiPolygon-mergeGeoPolygons = GeoMultiPolygon . Vector.map GeoPolygon._unGeoPolygon+mergeGeoPolygons :: Sequence.Seq GeoPolygon -> GeoMultiPolygon+mergeGeoPolygons = GeoMultiPolygon . fmap GeoPolygon._unGeoPolygon  makeLenses ''GeoMultiPolygon 

@@ -23,12 +23,12 @@ import           Data.Geospatial.Internal.BasicTypes import           Data.Geospatial.Internal.Geometry.Aeson import qualified Data.LinearRing                         as LinearRing-import qualified Data.Vector                             as Vector+import qualified Data.Sequence                           as Sequence import           GHC.Generics                            (Generic) -newtype GeoPolygon = GeoPolygon { _unGeoPolygon :: Vector.Vector (LinearRing.LinearRing GeoPositionWithoutCRS) } deriving (Show, Eq, Generic, NFData)+newtype GeoPolygon = GeoPolygon { _unGeoPolygon :: Sequence.Seq (LinearRing.LinearRing GeoPositionWithoutCRS) } deriving (Show, Eq, Generic, NFData) --- Vector.Vector (LinearRing.LinearRing DoubleArray)+-- Sequence.Seq (LinearRing.LinearRing DoubleArray)  makeLenses ''GeoPolygon 

@@ -24,32 +24,30 @@     ,   fromVector     ,   fromLineString     ,   fromList-    ,   Data.LineString.map-    ,   Data.LineString.foldr-    ,   Data.LineString.foldMap     ,   makeLineString     ,   lineStringHead     ,   lineStringLast     ,   lineStringLength     ) where -import           Prelude              hiding (foldr)+import           Prelude             hiding (foldr) -import           Control.Applicative  (Applicative (..))+import           Control.Applicative (Applicative (..)) import           Control.DeepSeq-import           Control.Lens         (( # ), (^?))-import           Control.Monad        (mzero)-import           Data.Aeson           (FromJSON (..), ToJSON (..), Value)-import           Data.Aeson.Types     (Parser, typeMismatch)-import           Data.Maybe           (fromMaybe)-import qualified Data.Validation      as Validation-import qualified Data.Vector.Storable as VectorStorable-import           GHC.Generics         (Generic)+import           Control.Lens        (( # ), (^?))+import           Control.Monad       (mzero)+import           Data.Aeson          (FromJSON (..), ToJSON (..), Value)+import           Data.Aeson.Types    (Parser, typeMismatch)+import qualified Data.Foldable       as Foldable+import           Data.Maybe          (fromMaybe)+import qualified Data.Sequence       as Sequence+import qualified Data.Validation     as Validation+import           GHC.Generics        (Generic)  -- | -- a LineString has at least 2 elements ---data LineString a = LineString a a (VectorStorable.Vector a) deriving (Eq, Generic, NFData)+data LineString a = LineString a a (Sequence.Seq a) deriving (Eq, Generic, NFData)  -- | -- When converting a List to a LineString, here is a list of things that can go wrong:@@ -84,82 +82,88 @@ -- | -- returns the last element in the string ---lineStringLast :: (VectorStorable.Storable a) => LineString a -> a+lineStringLast :: LineString a -> a lineStringLast (LineString _ x xs) = fromMaybe x (safeLast xs)  -- | -- returns the number of elements in the list, including the replicated element at the end of the list. ---lineStringLength :: (VectorStorable.Storable a) => LineString a -> Int-lineStringLength (LineString _ _ xs) = 2 + VectorStorable.length xs+lineStringLength :: LineString a -> Int+lineStringLength (LineString _ _ xs) = 2 + Sequence.length xs  -- | -- This function converts it into a list and appends the given element to the end. ---fromLineString :: (VectorStorable.Storable a) => LineString a -> [a]-fromLineString (LineString x y zs) = x : y : VectorStorable.toList zs+fromLineString :: LineString a -> [a]+fromLineString (LineString x y zs) = x : y : Foldable.toList zs  -- | -- creates a LineString out of a list of elements, -- if there are enough elements (needs at least 2) elements ---fromList :: (Validation.Validate v, VectorStorable.Storable a) => [a] -> v ListToLineStringError (LineString a)+fromList :: (Validation.Validate v) => [a] -> v ListToLineStringError (LineString a) fromList []       = Validation._Failure # ListEmpty fromList [_]      = Validation._Failure # SingletonList-fromList (x:y:zs) = Validation._Success # LineString x y (VectorStorable.fromList zs)+fromList (x:y:zs) = Validation._Success # LineString x y (Sequence.fromList zs) {-# INLINE fromList #-}  -- | -- create a vector from a LineString by combining values. -- LineString 1 2 [3,4] (,) --> Vector [(1,2),(2,3),(3,4)] ---combineToVector :: (VectorStorable.Storable a, VectorStorable.Storable b) => (a -> a -> b) -> LineString a -> VectorStorable.Vector b-combineToVector combine (LineString a b rest) = VectorStorable.cons (combine a b) combineRest+combineToVector :: (a -> a -> b) -> LineString a -> Sequence.Seq b+combineToVector combine (LineString a b rest) = combine a b Sequence.<| combineRest     where         combineRest =-          if VectorStorable.null rest+          if Sequence.null rest             then-              VectorStorable.empty+              Sequence.empty             else-              (VectorStorable.zipWith combine <*> VectorStorable.tail) (VectorStorable.cons b rest)+              (Sequence.zipWith combine <*> sequenceTail) (b Sequence.<| rest) {-# INLINE combineToVector #-} +sequenceTail :: Sequence.Seq a -> Sequence.Seq a+sequenceTail (_ Sequence.:<| tailS) = tailS+sequenceTail _                      = Sequence.empty+ -- | -- create a vector from a LineString. -- LineString 1 2 [3,4] --> Vector [1,2,3,4] ---toVector :: (VectorStorable.Storable a) => LineString a -> VectorStorable.Vector a-toVector (LineString a b rest) = VectorStorable.cons a (VectorStorable.cons b rest)+toVector :: LineString a -> Sequence.Seq a+toVector (LineString a b rest) = a Sequence.<| ( b  Sequence.<| rest) {-# INLINE toVector #-}  -- | -- creates a LineString out of a vector of elements, -- if there are enough elements (needs at least 2) elements ---fromVector :: (Validation.Validate v, VectorStorable.Storable a) => VectorStorable.Vector a -> v VectorToLineStringError (LineString a)-fromVector v =-  if VectorStorable.null v then-    Validation._Failure # VectorEmpty+fromVector :: (Validation.Validate v) => Sequence.Seq a -> v VectorToLineStringError (LineString a)+fromVector v@(headS Sequence.:<| tailS) =+  if Sequence.null v then+    Validation._Failure # SingletonVector   else-    fromVector' (VectorStorable.head v) (VectorStorable.tail v)+    fromVector' headS tailS+fromVector _ = Validation._Failure # VectorEmpty {-# INLINE fromVector #-} -fromVector' :: (Validation.Validate v, VectorStorable.Storable a) => a -> VectorStorable.Vector a -> v VectorToLineStringError (LineString a)-fromVector' first v =-  if VectorStorable.null v then+fromVector' :: (Validation.Validate v) => a -> Sequence.Seq a -> v VectorToLineStringError (LineString a)+fromVector' first v@(headS Sequence.:<| tailS) =+  if Sequence.null v then     Validation._Failure # SingletonVector   else-    Validation._Success # LineString first (VectorStorable.head v) (VectorStorable.tail v)+    Validation._Success # LineString first headS tailS+fromVector' _ _ = Validation._Failure # SingletonVector {-# INLINE fromVector' #-}  -- | -- Creates a LineString -- @makeLineString x y zs@ creates a `LineString` homomorphic to the list @[x, y] ++ zs@ ---makeLineString :: (VectorStorable.Storable a) =>+makeLineString ::        a                        -- ^ The first element     -> a                        -- ^ The second element-    -> VectorStorable.Vector a  -- ^ The rest of the optional elements+    -> Sequence.Seq a  -- ^ The rest of the optional elements     -> LineString a makeLineString = LineString @@ -173,29 +177,27 @@   show VectorEmpty     = "Vector Empty"   show SingletonVector = "Singleton Vector" -instance (Show a, VectorStorable.Storable a) => Show (LineString a) where+instance (Show a) => Show (LineString a) where     show  = show . fromLineString -map :: (VectorStorable.Storable a, VectorStorable.Storable b) => (a -> b) -> LineString a -> LineString b-map f (LineString x y zs) = LineString (f x) (f y) (VectorStorable.map f zs)-{-# INLINE map #-}+instance Functor LineString where+    fmap f (LineString x y zs) = LineString (f x) (f y) (fmap f zs) --- | This will run through the entire ring, closing the--- loop by also passing the initial element in again at the end.+-- | This will run through the line string. ---foldr :: (VectorStorable.Storable a) => (a -> b -> b) -> b -> LineString a -> b-foldr f u (LineString x y zs) = f x (f y (VectorStorable.foldr f u zs))-{-# INLINE foldr #-}+instance Foldable LineString where+    --  foldr :: (a -> b -> b) -> b -> LineString a -> b+    foldr f u (LineString x y zs) = f x (f y (Foldable.foldr f u zs)) -foldMap :: (Monoid m, VectorStorable.Storable a) => (a -> m) -> LineString a -> m-foldMap f = foldr (mappend . f) mempty-{-# INLINE foldMap #-}+instance Traversable LineString where+    --  sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)+    sequenceA (LineString fx fy fzs) = LineString <$> fx <*> fy <*> sequenceA fzs -instance (ToJSON a, VectorStorable.Storable a) => ToJSON (LineString a) where+instance (ToJSON a) => ToJSON (LineString a) where --  toJSON :: a -> Value     toJSON = toJSON . fromLineString -instance (FromJSON a, Show a, VectorStorable.Storable a) => FromJSON (LineString a) where+instance (FromJSON a, Show a) => FromJSON (LineString a) where --  parseJSON :: Value -> Parser a     parseJSON v = do         xs <- parseJSON v@@ -204,12 +206,16 @@  -- helpers -fromListValidated :: (VectorStorable.Storable a) => [a] -> Validation.Validation ListToLineStringError (LineString a)+fromListValidated :: [a] -> Validation.Validation ListToLineStringError (LineString a) fromListValidated = fromList  parseError :: Value -> Maybe ListToLineStringError -> Parser b parseError v = maybe mzero (\e -> typeMismatch (show e) v) -safeLast :: (VectorStorable.Storable a) => VectorStorable.Vector a -> Maybe a-safeLast x = if VectorStorable.null x then Nothing else Just $ VectorStorable.last x+-- safeLast :: (VectorStorable.Storable a) => Sequence.Seq a -> Maybe a+-- safeLast x = if Sequence.null x then Nothing else Just $ Sequence.last x+safeLast :: Sequence.Seq a -> Maybe a+safeLast x = case Sequence.viewr x of+                Sequence.EmptyR ->  Nothing+                _ Sequence.:> b -> Just b {-# INLINE safeLast #-}

@@ -28,36 +28,34 @@     ,   fromList     ,   fromListWithEqCheck     ,   makeLinearRing-    ,   Data.LinearRing.map-    ,   Data.LinearRing.foldr-    ,   Data.LinearRing.foldMap     ,   ringHead     ,   ringLength     ) where  #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 800-import           Prelude              hiding (foldr)+import           Prelude             hiding (foldr) #else import           Prelude #endif -import           Control.Applicative  (Applicative (..))+import           Control.Applicative (Applicative (..)) import           Control.DeepSeq-import           Control.Lens         (( # ), (^?))-import           Control.Monad        (mzero)-import           Data.Aeson           (FromJSON (..), ToJSON (..), Value)-import           Data.Aeson.Types     (Parser, typeMismatch)-import           Data.Functor         ((<$>))-import           Data.List            (intercalate)-import           Data.List.NonEmpty   as NL (NonEmpty, toList)-import qualified Data.Validation      as Validation-import qualified Data.Vector.Storable as VectorStorable-import           GHC.Generics         (Generic)+import           Control.Lens        (( # ), (^?))+import           Control.Monad       (mzero)+import           Data.Aeson          (FromJSON (..), ToJSON (..), Value)+import           Data.Aeson.Types    (Parser, typeMismatch)+import qualified Data.Foldable       as Foldable+import           Data.Functor        ((<$>))+import           Data.List           (intercalate)+import           Data.List.NonEmpty  as NL (NonEmpty, toList)+import qualified Data.Sequence       as Sequence+import qualified Data.Validation     as Validation+import           GHC.Generics        (Generic)  -- | -- a LinearRing has at least 3 (distinct) elements ---data LinearRing a = LinearRing a a a (VectorStorable.Vector a) deriving (Eq, Show, Generic, NFData)+data LinearRing a = LinearRing a a a (Sequence.Seq a) deriving (Eq, Show, Generic, NFData)  -- | -- When converting a List to a LinearRing there are some things that can go wrong@@ -93,14 +91,14 @@ -- | -- returns the number of elements in the list, including the replicated element at the end of the list. ---ringLength :: (VectorStorable.Storable a) => LinearRing a -> Int-ringLength (LinearRing _ _ _ xs) = 4 + VectorStorable.length xs+ringLength :: LinearRing a -> Int+ringLength (LinearRing _ _ _ xs) = 4 + Sequence.length xs  -- | -- This function converts it into a list and appends the given element to the end. ---fromLinearRing :: (VectorStorable.Storable a) => LinearRing a -> [a]-fromLinearRing (LinearRing x y z ws) = x : y : z : VectorStorable.foldr (:) [x] ws+fromLinearRing :: LinearRing a -> [a]+fromLinearRing (LinearRing x y z ws) = x : y : z : Foldable.foldr (:) [x] ws  -- | -- creates a LinearRing out of a list of elements,@@ -119,7 +117,7 @@ -- -- Unfortunately it doesn't check that the last element is the same as the first at the moment... ---fromList :: (Eq a, Show a, VectorStorable.Storable a, Validation.Validate v, Functor (v (NonEmpty (ListToLinearRingError a)))) => [a] -> v (NonEmpty (ListToLinearRingError a)) (LinearRing a)+fromList :: (Eq a, Show a, Validation.Validate v, Functor (v (NonEmpty (ListToLinearRingError a)))) => [a] -> v (NonEmpty (ListToLinearRingError a)) (LinearRing a) fromList (x:y:z:ws@(_:_)) = Validation._Success # LinearRing x y z (fromListDropLast ws) fromList xs               = Validation._Failure # pure (ListTooShort (length xs)) {-# INLINE fromList #-}@@ -128,30 +126,34 @@ -- The expensive version of fromList that checks whether the head and last elements -- are equal. ---fromListWithEqCheck :: (Eq a, Show a, VectorStorable.Storable a, Validation.Validate v, Applicative (v (NonEmpty (ListToLinearRingError a)))) => [a] -> v (NonEmpty (ListToLinearRingError a)) (LinearRing a)+fromListWithEqCheck :: (Eq a, Show a, Validation.Validate v, Applicative (v (NonEmpty (ListToLinearRingError a)))) => [a] -> v (NonEmpty (ListToLinearRingError a)) (LinearRing a) fromListWithEqCheck xs = checkHeadAndLastEq xs *> fromList xs  -- | -- create a vector from a LinearRing by combining values. -- LinearRing 1 2 3 [4,1] (,) --> Vector [(1,2),(2,3),(3,4),(4,1)] ---combineToVector :: (VectorStorable.Storable a, VectorStorable.Storable b) => (a -> a -> b) -> LinearRing a -> VectorStorable.Vector b-combineToVector combine (LinearRing a b c rest) = VectorStorable.cons (combine a b) (VectorStorable.cons (combine b c) combineRest)+combineToVector :: (a -> a -> b) -> LinearRing a -> Sequence.Seq b+combineToVector combine (LinearRing a b c rest) = combine a b Sequence.:<| (combine b c Sequence.:<| combineRest)     where         combineRest =-          if VectorStorable.null rest+          if Sequence.null rest             then-              VectorStorable.empty+              Sequence.empty             else-              (VectorStorable.zipWith combine <*> VectorStorable.tail) (VectorStorable.cons c rest)+                (Sequence.zipWith combine <*> sequenceTail) (c Sequence.<| rest) {-# INLINE combineToVector #-} +sequenceTail :: Sequence.Seq a -> Sequence.Seq a+sequenceTail (_ Sequence.:<| tailS) = tailS+sequenceTail _                      = Sequence.empty+ -- | -- create a vector from a LinearRing. -- LinearRing 1 2 3 [4,1] --> Vector [1,2,3,4,1)] ---toVector :: (VectorStorable.Storable a) => LinearRing a -> VectorStorable.Vector a-toVector (LinearRing a b c rest) = VectorStorable.cons a (VectorStorable.cons b (VectorStorable.cons c rest))+toVector :: LinearRing a -> Sequence.Seq a+toVector (LinearRing a b c rest) = a Sequence.:<| (b Sequence.:<| (c Sequence.:<| rest)) {-# INLINE toVector #-}  -- |@@ -161,15 +163,21 @@ -- fromVector (x:y:z:ws@(_:_)) = _Success # LinearRing x y z (fromListDropLast ws) -- fromList xs               = _Failure # return (ListTooShort (length xs)) -fromVector :: (Eq a, Show a, VectorStorable.Storable a, Validation.Validate v, Functor (v (NonEmpty (ListToLinearRingError a)))) => VectorStorable.Vector a -> v (NonEmpty (VectorToLinearRingError a)) (LinearRing a)-fromVector v =-  if VectorStorable.length v >= 3 then-    if VectorStorable.head v == VectorStorable.last v then-        Validation._Success # LinearRing (VectorStorable.unsafeIndex v 0) (VectorStorable.unsafeIndex v 1) (VectorStorable.unsafeIndex v 2) (VectorStorable.drop 3 v)-    else-        Validation._Failure # pure (FirstNotEqualToLast (VectorStorable.head v) (VectorStorable.last v))-  else-    Validation._Failure # pure (VectorTooShort (VectorStorable.length v))+fromVector :: (Eq a, Show a, Validation.Validate v, Functor (v (NonEmpty (ListToLinearRingError a)))) => Sequence.Seq a -> v (NonEmpty (VectorToLinearRingError a)) (LinearRing a)+fromVector as =+    case as of+        (first Sequence.:<| (second Sequence.:<| (third Sequence.:<| rest@(_ Sequence.:|> lastS)))) ->+            if first == lastS then+                Validation._Success # LinearRing first second third rest+            else+                Validation._Failure # pure (FirstNotEqualToLast first lastS)+        (first Sequence.:<| (second Sequence.:<| (third Sequence.:<| _))) ->+            if first == third then+                Validation._Success # LinearRing first second third Sequence.empty+            else+                Validation._Failure # pure (FirstNotEqualToLast first third)+        v -> Validation._Failure # pure (VectorTooShort (Sequence.length v))+        _ -> Validation._Failure # pure (VectorTooShort 0) {-# INLINE fromVector #-}  -- |@@ -180,44 +188,47 @@ -- -- Repeating the first element is just redundant. ---makeLinearRing :: (Eq a, Show a, VectorStorable.Storable a) =>+makeLinearRing :: (Eq a, Show a) =>        a                        -- ^ The first element     -> a                        -- ^ The second element     -> a                        -- ^ The third element-    -> VectorStorable.Vector a  -- ^ The rest of the optional elements (WITHOUT the first element repeated at the end)+    -> Sequence.Seq a  -- ^ The rest of the optional elements (WITHOUT the first element repeated at the end)     -> LinearRing a makeLinearRing = LinearRing  -- instances -instance (Show a, VectorStorable.Storable a) => Show (ListToLinearRingError a) where+instance (Show a) => Show (ListToLinearRingError a) where     show (ListTooShort n) = "List too short: (length = " ++ show n ++ ")"     show (HeadNotEqualToLast h l) = "head (" ++ show h ++ ") /= last(" ++ show l ++ ")" -instance (Show a, VectorStorable.Storable a) => Show (VectorToLinearRingError a) where+instance (Show a) => Show (VectorToLinearRingError a) where     show (VectorTooShort n) = "Vector too short: (length = " ++ show n ++ ")"     show (FirstNotEqualToLast h l) = "head (" ++ show h ++ ") /= last(" ++ show l ++ ")" -map :: (VectorStorable.Storable a, VectorStorable.Storable b) => (a -> b) -> LinearRing a -> LinearRing b-map f (LinearRing x y z ws) = LinearRing (f x) (f y) (f z) (VectorStorable.map f ws)-{-# INLINE map #-}+instance Functor LinearRing where+    fmap f (LinearRing x y z ws) = LinearRing (f x) (f y) (f z) (fmap f ws) --- | This will run through the entire ring, closing the+-- | This instance of Foldable will run through the entire ring, closing the -- loop by also passing the initial element in again at the end. ---foldr :: VectorStorable.Storable a => (a -> b -> b) -> b -> LinearRing a -> b-foldr f u (LinearRing x y z ws) = f x (f y (f z (VectorStorable.foldr f (f x u) ws)))-{-# INLINE foldr #-}+instance Foldable LinearRing where+    --  foldr :: (a -> b -> b) -> b -> LinearRing a -> b+    foldr f u (LinearRing x y z ws) = f x (f y (f z (Foldable.foldr f (f x u) ws))) -foldMap :: (Monoid m, VectorStorable.Storable a) => (a -> m) -> LinearRing a -> m-foldMap f = foldr (mappend . f) mempty-{-# INLINE foldMap #-}+-- |+-- When traversing this Structure, the Applicative context+-- of the last element will be appended to the end to close the loop+--+instance Traversable LinearRing where+    --  sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)+    sequenceA (LinearRing fx fy fz fws) = (LinearRing <$> fx <*> fy <*> fz <*> sequenceA fws) <* fx -instance (ToJSON a, VectorStorable.Storable a) => ToJSON (LinearRing a) where+instance (ToJSON a) => ToJSON (LinearRing a) where --  toJSON :: a -> Value     toJSON = toJSON . fromLinearRing -instance (Eq a, FromJSON a, Show a, VectorStorable.Storable a) => FromJSON (LinearRing a) where+instance (Eq a, FromJSON a, Show a) => FromJSON (LinearRing a) where --  parseJSON :: Value -> Parser a     parseJSON v = do         xs <- parseJSON v@@ -226,16 +237,16 @@  -- helpers -fromListAcc :: (Eq a, Show a, VectorStorable.Storable a) => [a] -> Validation.Validation (NonEmpty (ListToLinearRingError a)) (LinearRing a)+fromListAcc :: (Eq a, Show a) => [a] -> Validation.Validation (NonEmpty (ListToLinearRingError a)) (LinearRing a) fromListAcc = fromList -showErrors :: (Show a, VectorStorable.Storable a) => NonEmpty (ListToLinearRingError a) -> String+showErrors :: (Show a) => NonEmpty (ListToLinearRingError a) -> String showErrors = intercalate ", " . NL.toList . fmap show -parseError :: (Show a, VectorStorable.Storable a) => Value -> Maybe (NonEmpty (ListToLinearRingError a)) -> Parser b+parseError :: (Show a) => Value -> Maybe (NonEmpty (ListToLinearRingError a)) -> Parser b parseError v = maybe mzero (\e -> typeMismatch (showErrors e) v) -checkHeadAndLastEq :: (Eq a, VectorStorable.Storable a, Validation.Validate v, Functor (v (NonEmpty (ListToLinearRingError a))))+checkHeadAndLastEq :: (Eq a, Validation.Validate v, Functor (v (NonEmpty (ListToLinearRingError a))))     => [a]     -> v (NonEmpty (ListToLinearRingError a)) () checkHeadAndLastEq = maybe (Validation._Failure # pure (ListTooShort 0)) (\(h, l) -> if h == l then Validation._Success # () else Validation._Failure # pure (HeadNotEqualToLast h l)) . mhl@@ -252,7 +263,12 @@ safeLast [x]    = Just x safeLast (_:xs) = safeLast xs -fromListDropLast :: (Eq a, VectorStorable.Storable a) => [a] -> VectorStorable.Vector a-fromListDropLast []  = VectorStorable.empty-fromListDropLast [_] = VectorStorable.empty-fromListDropLast x   = VectorStorable.unsafeInit $ VectorStorable.fromList x+fromListDropLast :: (Eq a) => [a] -> Sequence.Seq a+fromListDropLast []  = Sequence.empty+fromListDropLast [_] = Sequence.empty+fromListDropLast x   = sequenceHead $ Sequence.fromList x++-- All but the last+sequenceHead :: Sequence.Seq a -> Sequence.Seq a+sequenceHead (headS Sequence.:|> _) = headS+sequenceHead _                      = Sequence.empty

@@ -2,8 +2,6 @@  module Arbitrary where -import qualified Data.Vector           as Vector-import qualified Data.Vector.Storable  as VectorStorable import           Test.Tasty.QuickCheck (Arbitrary, arbitrary)  -- Local@@ -11,14 +9,8 @@ import           Data.LineString       (LineString, makeLineString)  -instance (Arbitrary a, Eq a, Show a, VectorStorable.Storable a) => Arbitrary (LinearRing a) where+instance (Arbitrary a, Eq a, Show a) => Arbitrary (LinearRing a) where   arbitrary = makeLinearRing <$> arbitrary <*> arbitrary <*> arbitrary <*> arbitrary -instance (Arbitrary a, Eq a, Show a, VectorStorable.Storable a) => Arbitrary (LineString a) where+instance (Arbitrary a, Eq a, Show a) => Arbitrary (LineString a) where   arbitrary = makeLineString <$> arbitrary <*> arbitrary <*> arbitrary--instance (Arbitrary a, VectorStorable.Storable a) => Arbitrary (VectorStorable.Vector a) where-  arbitrary = fmap VectorStorable.fromList arbitrary--instance (Arbitrary a) => Arbitrary (Vector.Vector a) where-  arbitrary = fmap Vector.fromList arbitrary

@@ -1,7 +1,7 @@ module Data.LineStringTests where +import qualified Data.Sequence                       as Sequence import           Data.Validation                     (Validation (..))-import qualified Data.Vector.Storable                as VectorStorable import           Test.Tasty import           Test.Tasty.Hspec                    (Spec, context, describe,                                                       it, shouldBe, testSpec)@@ -52,7 +52,7 @@ -- > (\xs -> (lineStringHead xs) == (foldr (\a -> const a) 0 xs)) (xs :: LineString Int) -- testFoldable :: LineString.LineString Int -> Property-testFoldable xs = property $ (LineString.foldr (:) [] xs == LineString.fromLineString xs) && (LineString.lineStringHead xs == LineString.foldr const 0 xs)+testFoldable xs = property $ (foldr (:) [] xs == LineString.fromLineString xs) && (LineString.lineStringHead xs == foldr const 0 xs)  -- Spec @@ -75,9 +75,9 @@ testFromList =   describe "fromList" $ do     it "creates a LineString out of a list of elements" $ do-      LineString.fromList ([0, 1] :: [Int])             `shouldBe` Success (LineString.makeLineString 0 1 VectorStorable.empty)-      LineString.fromList ([0, 1, 2] :: [Int])          `shouldBe` Success (LineString.makeLineString 0 1 (VectorStorable.fromList [2]))-      LineString.fromList ([0, 1, 2, 4, 5, 0] :: [Int]) `shouldBe` Success (LineString.makeLineString 0 1 (VectorStorable.fromList [2, 4, 5, 0]))+      LineString.fromList ([0, 1] :: [Int])             `shouldBe` Success (LineString.makeLineString 0 1 Sequence.empty)+      LineString.fromList ([0, 1, 2] :: [Int])          `shouldBe` Success (LineString.makeLineString 0 1 (Sequence.fromList [2]))+      LineString.fromList ([0, 1, 2, 4, 5, 0] :: [Int]) `shouldBe` Success (LineString.makeLineString 0 1 (Sequence.fromList [2, 4, 5, 0]))     context "when provided with invalid input" $       it "fails" $ do         LineString.fromList ([] :: [Int])  `shouldBe` Failure LineString.ListEmpty@@ -87,29 +87,29 @@ testFromVector =   describe "fromVector" $ do     it "creates a LineString out of a Vector of elements" $ do-      LineString.fromVector (VectorStorable.fromList [0, 1] :: (VectorStorable.Vector Int))             `shouldBe` Success (LineString.makeLineString 0 1 VectorStorable.empty)-      LineString.fromVector (VectorStorable.fromList [0, 1, 2] :: (VectorStorable.Vector Int))          `shouldBe` Success (LineString.makeLineString 0 1 (VectorStorable.fromList [2]))-      LineString.fromVector (VectorStorable.fromList [0, 1, 2, 4, 5, 0] :: (VectorStorable.Vector Int)) `shouldBe` Success (LineString.makeLineString 0 1 (VectorStorable.fromList [2, 4, 5, 0]))+      LineString.fromVector (Sequence.fromList [0, 1] :: (Sequence.Seq Int))             `shouldBe` Success (LineString.makeLineString 0 1 Sequence.empty)+      LineString.fromVector (Sequence.fromList [0, 1, 2] :: (Sequence.Seq Int))          `shouldBe` Success (LineString.makeLineString 0 1 (Sequence.fromList [2]))+      LineString.fromVector (Sequence.fromList [0, 1, 2, 4, 5, 0] :: (Sequence.Seq Int)) `shouldBe` Success (LineString.makeLineString 0 1 (Sequence.fromList [2, 4, 5, 0]))     context "when provided with invalid input" $       it "fails" $ do-        LineString.fromVector (VectorStorable.fromList [] :: (VectorStorable.Vector Int))  `shouldBe` Failure LineString.VectorEmpty-        LineString.fromVector (VectorStorable.fromList [0] :: (VectorStorable.Vector Int)) `shouldBe` Failure LineString.SingletonVector+        LineString.fromVector (Sequence.fromList [] :: (Sequence.Seq Int))  `shouldBe` Failure LineString.VectorEmpty+        LineString.fromVector (Sequence.fromList [0] :: (Sequence.Seq Int)) `shouldBe` Failure LineString.SingletonVector  testCombineToVector :: Spec testCombineToVector =   describe "combineToVector" $     it "combine a LineString using PointXY" $ do-      LineString.combineToVector BasicTypes.PointXY (LineString.makeLineString 0 1 VectorStorable.empty)                   `shouldBe` VectorStorable.fromList [BasicTypes.PointXY 0 1]-      LineString.combineToVector BasicTypes.PointXY (LineString.makeLineString 0 1 (VectorStorable.fromList [2]))          `shouldBe` VectorStorable.fromList [BasicTypes.PointXY 0 1, BasicTypes.PointXY 1 2]-      LineString.combineToVector BasicTypes.PointXY (LineString.makeLineString 0 1 (VectorStorable.fromList [2, 4, 5, 0])) `shouldBe` VectorStorable.fromList [BasicTypes.PointXY 0 1, BasicTypes.PointXY 1 2, BasicTypes.PointXY 2 4, BasicTypes.PointXY 4 5, BasicTypes.PointXY 5 0]+      LineString.combineToVector BasicTypes.PointXY (LineString.makeLineString 0 1 Sequence.empty)                   `shouldBe` Sequence.fromList [BasicTypes.PointXY 0 1]+      LineString.combineToVector BasicTypes.PointXY (LineString.makeLineString 0 1 (Sequence.fromList [2]))          `shouldBe` Sequence.fromList [BasicTypes.PointXY 0 1, BasicTypes.PointXY 1 2]+      LineString.combineToVector BasicTypes.PointXY (LineString.makeLineString 0 1 (Sequence.fromList [2, 4, 5, 0])) `shouldBe` Sequence.fromList [BasicTypes.PointXY 0 1, BasicTypes.PointXY 1 2, BasicTypes.PointXY 2 4, BasicTypes.PointXY 4 5, BasicTypes.PointXY 5 0]  testToVector :: Spec testToVector =   describe "toVector" $     it "from a LineString to a vector" $ do-      LineString.toVector (LineString.makeLineString 0 1 VectorStorable.empty)                   `shouldBe` VectorStorable.fromList ([0, 1] :: [Int])-      LineString.toVector (LineString.makeLineString 0 1 (VectorStorable.fromList [2]))          `shouldBe` VectorStorable.fromList ([0, 1, 2] :: [Int])-      LineString.toVector (LineString.makeLineString 0 1 (VectorStorable.fromList [2, 4, 5, 0])) `shouldBe` VectorStorable.fromList ([0, 1, 2, 4, 5, 0] :: [Int])+      LineString.toVector (LineString.makeLineString 0 1 Sequence.empty)                   `shouldBe` Sequence.fromList ([0, 1] :: [Int])+      LineString.toVector (LineString.makeLineString 0 1 (Sequence.fromList [2]))          `shouldBe` Sequence.fromList ([0, 1, 2] :: [Int])+      LineString.toVector (LineString.makeLineString 0 1 (Sequence.fromList [2, 4, 5, 0])) `shouldBe` Sequence.fromList ([0, 1, 2, 4, 5, 0] :: [Int])  -- TODO -- (\xs -> safeLast (fromLineString xs) == Just (lineStringHead xs)) (xs :: LineString Int)

@@ -1,8 +1,8 @@ module Data.LinearRingTests where  import qualified Data.List.NonEmpty                  as ListNonEmpty+import qualified Data.Sequence                       as Sequence import qualified Data.Validation                     as Validation-import qualified Data.Vector.Storable                as VectorStorable import           Test.Tasty import           Test.Tasty.Hspec                    (Spec, context, describe,                                                       it, shouldBe, testSpec)@@ -54,7 +54,7 @@ -- > (\xs -> (ringHead xs) == (foldr (\a -> const a) 0 xs)) (xs :: LinearRing Int) -- testFoldable :: LinearRing.LinearRing Int -> Property-testFoldable xs = property $ (LinearRing.foldr (:) [] xs == LinearRing.fromLinearRing xs) && (LinearRing.ringHead xs == LinearRing.foldr const 0 xs)+testFoldable xs = property $ (foldr (:) [] xs == LinearRing.fromLinearRing xs) && (LinearRing.ringHead xs == foldr const 0 xs)  -- Spec @@ -86,10 +86,10 @@ testFromList =   describe "fromList" $ do     it "creates a LinearRing out of a list of elements" $ do-      LinearRing.fromList ([0, 1, 2, 3] :: [Int])       `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 VectorStorable.empty)-      LinearRing.fromList ([0, 1, 2, 4, 0] :: [Int])    `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (VectorStorable.fromList [4]))-      LinearRing.fromList ([0, 1, 2, 4, 5, 0] :: [Int]) `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (VectorStorable.fromList [4,5]))-      LinearRing.fromList ([0, 1, 2, 4, 5, 6] :: [Int]) `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (VectorStorable.fromList [4,5]))+      LinearRing.fromList ([0, 1, 2, 3] :: [Int])       `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 Sequence.empty)+      LinearRing.fromList ([0, 1, 2, 4, 0] :: [Int])    `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (Sequence.fromList [4]))+      LinearRing.fromList ([0, 1, 2, 4, 5, 0] :: [Int]) `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (Sequence.fromList [4,5]))+      LinearRing.fromList ([0, 1, 2, 4, 5, 6] :: [Int]) `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (Sequence.fromList [4,5]))     context "when provided with invalid input" $       it "fails" $ do         LinearRing.fromList []        `shouldBe` Validation.Failure (LinearRing.ListTooShort 0 ListNonEmpty.:| [] :: ListNonEmpty.NonEmpty (LinearRing.ListToLinearRingError Int))@@ -101,32 +101,32 @@ testFromVector =   describe "fromVector" $ do     it "creates a LinearRing out of a vector of elements" $ do-      LinearRing.fromVector (VectorStorable.fromList ([0, 1, 0] :: [Int]))         `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 0 VectorStorable.empty)-      LinearRing.fromVector (VectorStorable.fromList ([0, 1, 2, 0] :: [Int]))      `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (VectorStorable.fromList [0]))-      LinearRing.fromVector (VectorStorable.fromList ([0, 1, 2, 4, 0] :: [Int]))   `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (VectorStorable.fromList [4, 0]))-      LinearRing.fromVector (VectorStorable.fromList ([0, 1, 2, 4, 5, 0]:: [Int])) `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (VectorStorable.fromList [4, 5, 0]))+      LinearRing.fromVector (Sequence.fromList ([0, 1, 0] :: [Int]))         `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 0 Sequence.empty)+      LinearRing.fromVector (Sequence.fromList ([0, 1, 2, 0] :: [Int]))      `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (Sequence.fromList [0]))+      LinearRing.fromVector (Sequence.fromList ([0, 1, 2, 4, 0] :: [Int]))   `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (Sequence.fromList [4, 0]))+      LinearRing.fromVector (Sequence.fromList ([0, 1, 2, 4, 5, 0]:: [Int])) `shouldBe` Validation.Success (LinearRing.makeLinearRing 0 1 2 (Sequence.fromList [4, 5, 0]))     context "when provided with invalid input" $       it "fails" $ do-        LinearRing.fromVector (VectorStorable.fromList [])        `shouldBe` Validation.Failure (LinearRing.VectorTooShort 0 ListNonEmpty.:| [] :: ListNonEmpty.NonEmpty (LinearRing.VectorToLinearRingError Int))-        LinearRing.fromVector (VectorStorable.fromList [0])       `shouldBe` Validation.Failure (LinearRing.VectorTooShort 1 ListNonEmpty.:| [] :: ListNonEmpty.NonEmpty (LinearRing.VectorToLinearRingError Int))-        LinearRing.fromVector (VectorStorable.fromList [0, 1])    `shouldBe` Validation.Failure (LinearRing.VectorTooShort 2 ListNonEmpty.:| [] :: ListNonEmpty.NonEmpty (LinearRing.VectorToLinearRingError Int))-        LinearRing.fromVector (VectorStorable.fromList [0, 1, 2]) `shouldBe` Validation.Failure (LinearRing.FirstNotEqualToLast 0 2 ListNonEmpty.:| [] :: ListNonEmpty.NonEmpty (LinearRing.VectorToLinearRingError Int))+        LinearRing.fromVector (Sequence.fromList [])        `shouldBe` Validation.Failure (LinearRing.VectorTooShort 0 ListNonEmpty.:| [] :: ListNonEmpty.NonEmpty (LinearRing.VectorToLinearRingError Int))+        LinearRing.fromVector (Sequence.fromList [0])       `shouldBe` Validation.Failure (LinearRing.VectorTooShort 1 ListNonEmpty.:| [] :: ListNonEmpty.NonEmpty (LinearRing.VectorToLinearRingError Int))+        LinearRing.fromVector (Sequence.fromList [0, 1])    `shouldBe` Validation.Failure (LinearRing.VectorTooShort 2 ListNonEmpty.:| [] :: ListNonEmpty.NonEmpty (LinearRing.VectorToLinearRingError Int))+        LinearRing.fromVector (Sequence.fromList [0, 1, 2]) `shouldBe` Validation.Failure (LinearRing.FirstNotEqualToLast 0 2 ListNonEmpty.:| [] :: ListNonEmpty.NonEmpty (LinearRing.VectorToLinearRingError Int))  testCombineToVector :: Spec testCombineToVector =   describe "combineToVector" $     it "combine a LinearRing using tuples" $ do-      LinearRing.combineToVector BasicTypes.PointXY (LinearRing.makeLinearRing 0 1 2 VectorStorable.empty)             `shouldBe` VectorStorable.fromList [BasicTypes.PointXY 0 1, BasicTypes.PointXY 1 2]-      LinearRing.combineToVector BasicTypes.PointXY (LinearRing.makeLinearRing 0 1 2 (VectorStorable.fromList [4]))    `shouldBe` VectorStorable.fromList [BasicTypes.PointXY 0 1, BasicTypes.PointXY 1 2, BasicTypes.PointXY 2 4]-      LinearRing.combineToVector BasicTypes.PointXY (LinearRing.makeLinearRing 0 1 2 (VectorStorable.fromList [4,5]))  `shouldBe` VectorStorable.fromList [BasicTypes.PointXY 0 1, BasicTypes.PointXY 1 2, BasicTypes.PointXY 2 4, BasicTypes.PointXY 4 5]+      LinearRing.combineToVector BasicTypes.PointXY (LinearRing.makeLinearRing 0 1 2 Sequence.empty)             `shouldBe` Sequence.fromList [BasicTypes.PointXY 0 1, BasicTypes.PointXY 1 2]+      LinearRing.combineToVector BasicTypes.PointXY (LinearRing.makeLinearRing 0 1 2 (Sequence.fromList [4]))    `shouldBe` Sequence.fromList [BasicTypes.PointXY 0 1, BasicTypes.PointXY 1 2, BasicTypes.PointXY 2 4]+      LinearRing.combineToVector BasicTypes.PointXY (LinearRing.makeLinearRing 0 1 2 (Sequence.fromList [4,5]))  `shouldBe` Sequence.fromList [BasicTypes.PointXY 0 1, BasicTypes.PointXY 1 2, BasicTypes.PointXY 2 4, BasicTypes.PointXY 4 5]  testToVector :: Spec testToVector =   describe "toVector" $     it "from a LinearRing to a vector" $ do-      LinearRing.toVector (LinearRing.makeLinearRing 0 1 0 VectorStorable.empty)             `shouldBe` VectorStorable.fromList ([0, 1, 0] :: [Int])-      LinearRing.toVector (LinearRing.makeLinearRing 0 1 2 (VectorStorable.fromList [0]))    `shouldBe` VectorStorable.fromList ([0, 1, 2, 0] :: [Int])-      LinearRing.toVector (LinearRing.makeLinearRing 0 1 2 (VectorStorable.fromList [4,0]))  `shouldBe` VectorStorable.fromList ([0, 1, 2, 4, 0] :: [Int])+      LinearRing.toVector (LinearRing.makeLinearRing 0 1 0 Sequence.empty)             `shouldBe` Sequence.fromList ([0, 1, 0] :: [Int])+      LinearRing.toVector (LinearRing.makeLinearRing 0 1 2 (Sequence.fromList [0]))    `shouldBe` Sequence.fromList ([0, 1, 2, 0] :: [Int])+      LinearRing.toVector (LinearRing.makeLinearRing 0 1 2 (Sequence.fromList [4,0]))  `shouldBe` Sequence.fromList ([0, 1, 2, 4, 0] :: [Int])   -- TODO

@@ -20,8 +20,7 @@ import           Data.Geospatial.Internal.Geometry.GeoPolygon      (GeoPolygon (..)) import qualified Data.LinearRing                                   as LinearRing import qualified Data.LineString                                   as LineString-import qualified Data.Vector                                       as Vector-import qualified Data.Vector.Storable                              as VectorStorable+import qualified Data.Sequence                                     as Sequence  -- CRS Data @@ -44,21 +43,21 @@ testNamedCRS = NamedCRS "urn:ogc:def:crs:OGC:1.3:CRS84"  mkBoundingBox :: [Double] -> BasicTypes.BoundingBoxWithoutCRS-mkBoundingBox x = BasicTypes.BoundingBoxWithoutCRS $ VectorStorable.fromList x+mkBoundingBox x = BasicTypes.BoundingBoxWithoutCRS $ Sequence.fromList x  -- Bounding Box Data  mkGeoPoint :: Double -> Double -> BasicTypes.GeoPositionWithoutCRS mkGeoPoint x y = BasicTypes.GeoPointXY $ BasicTypes.PointXY x y -lshapedPolyVertices :: Vector.Vector (LinearRing.LinearRing BasicTypes.GeoPositionWithoutCRS)-lshapedPolyVertices =  Vector.fromList [LinearRing.makeLinearRing (mkGeoPoint 120.0 (-15.0)) (mkGeoPoint 127.0 (-15.0)) (mkGeoPoint 127.0 (-25.0)) (VectorStorable.fromList [mkGeoPoint 124.0 (-25.0), mkGeoPoint 124.0 (-18.0), mkGeoPoint 120.0 (-18.0)])]+lshapedPolyVertices :: Sequence.Seq (LinearRing.LinearRing BasicTypes.GeoPositionWithoutCRS)+lshapedPolyVertices =  Sequence.fromList [LinearRing.makeLinearRing (mkGeoPoint 120.0 (-15.0)) (mkGeoPoint 127.0 (-15.0)) (mkGeoPoint 127.0 (-25.0)) (Sequence.fromList [mkGeoPoint 124.0 (-25.0), mkGeoPoint 124.0 (-18.0), mkGeoPoint 120.0 (-18.0)])]  lshapedPolyLineVertices :: LineString.LineString BasicTypes.GeoPositionWithoutCRS-lshapedPolyLineVertices = LineString.makeLineString (mkGeoPoint 120.0 (-15.0)) (mkGeoPoint 127.0 (-15.0)) (VectorStorable.fromList [mkGeoPoint 127.0 (-25.0), mkGeoPoint 124.0 (-25.0), mkGeoPoint 124.0 (-18.0), mkGeoPoint 120.0 (-18.0)])+lshapedPolyLineVertices = LineString.makeLineString (mkGeoPoint 120.0 (-15.0)) (mkGeoPoint 127.0 (-15.0)) (Sequence.fromList [mkGeoPoint 127.0 (-25.0), mkGeoPoint 124.0 (-25.0), mkGeoPoint 124.0 (-18.0), mkGeoPoint 120.0 (-18.0)]) -emptyVertices :: Vector.Vector (LinearRing.LinearRing BasicTypes.GeoPositionWithoutCRS)-emptyVertices = Vector.empty+emptyVertices :: Sequence.Seq (LinearRing.LinearRing BasicTypes.GeoPositionWithoutCRS)+emptyVertices = Sequence.empty  emptyLineVertices :: [BasicTypes.GeoPositionWithoutCRS] emptyLineVertices = []@@ -131,7 +130,7 @@ emptyMultiPolyJSON = "{\"type\":\"MultiPolygon\",\"coordinates\":[]}"  emptyMultiGeoPoly :: GeoMultiPolygon-emptyMultiGeoPoly = GeoMultiPolygon Vector.empty+emptyMultiGeoPoly = GeoMultiPolygon Sequence.empty  emptyMultiPoly :: GeospatialGeometry emptyMultiPoly = MultiPolygon emptyMultiGeoPoly@@ -140,7 +139,7 @@ singlePolyMultiPolyJSON = "{\"type\":\"MultiPolygon\",\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]]]}"  singlePolyGeoMultiPoly :: GeoMultiPolygon-singlePolyGeoMultiPoly = mergeGeoPolygons (Vector.fromList [lShapedGeoPoly])+singlePolyGeoMultiPoly = mergeGeoPolygons (Sequence.fromList [lShapedGeoPoly])  singlePolyMultiPoly :: GeospatialGeometry singlePolyMultiPoly = MultiPolygon singlePolyGeoMultiPoly@@ -149,7 +148,7 @@ multiPolyJSON = "{\"type\":\"MultiPolygon\",\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],[]]}"  geoMultiPoly :: GeoMultiPolygon-geoMultiPoly = mergeGeoPolygons (Vector.fromList [lShapedGeoPoly, emptyGeoPoly])+geoMultiPoly = mergeGeoPolygons (Sequence.fromList [lShapedGeoPoly, emptyGeoPoly])  multiPoly :: GeospatialGeometry multiPoly = MultiPolygon geoMultiPoly@@ -169,7 +168,7 @@ emptyMultiLineJSON = "{\"type\":\"MultiLineString\",\"coordinates\":[]}"  emptyMultiGeoLine :: GeoMultiLine-emptyMultiGeoLine = GeoMultiLine Vector.empty+emptyMultiGeoLine = GeoMultiLine Sequence.empty  emptyMultiLine :: GeospatialGeometry emptyMultiLine = MultiLine emptyMultiGeoLine@@ -178,7 +177,7 @@ singleLineMultiLineJSON = "{\"type\":\"MultiLineString\",\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]]}"  singleLineGeoMultiLine :: GeoMultiLine-singleLineGeoMultiLine = mergeGeoLines (Vector.fromList [lShapedGeoLine])+singleLineGeoMultiLine = mergeGeoLines (Sequence.fromList [lShapedGeoLine])  singleLineMultiLine :: GeospatialGeometry singleLineMultiLine = MultiLine singleLineGeoMultiLine@@ -187,7 +186,7 @@ multiLineJSON = "{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"}"  geoMultiLine :: GeoMultiLine-geoMultiLine = mergeGeoLines (Vector.fromList [lShapedGeoLine, lShapedGeoLine])+geoMultiLine = mergeGeoLines (Sequence.fromList [lShapedGeoLine, lShapedGeoLine])  multiLine :: GeospatialGeometry multiLine = MultiLine geoMultiLine@@ -197,13 +196,13 @@ emptyCollectionJSON = "{\"type\":\"GeometryCollection\",\"geometries\":[]}"  emptyCollection :: GeospatialGeometry-emptyCollection = Collection Vector.empty+emptyCollection = Collection Sequence.empty  bigassCollectionJSON :: BS.ByteString bigassCollectionJSON = "{\"geometries\":[{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[],\"type\":\"MultiLineString\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],\"type\":\"LineString\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],[]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"},{\"coordinates\":[],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"}],\"type\":\"GeometryCollection\"}"  bigassCollection :: GeospatialGeometry-bigassCollection = Collection $ Vector.fromList [singleLineMultiLine, emptyMultiLine, multiLine, lShapedLine, multiPoly, singlePolyMultiPoly, lShapedPoly, emptyMultiPoly, lShapedPoly]+bigassCollection = Collection $ Sequence.fromList [singleLineMultiLine, emptyMultiLine, multiLine, lShapedLine, multiPoly, singlePolyMultiPoly, lShapedPoly, emptyMultiPoly, lShapedPoly]  -- Properties Data @@ -250,8 +249,8 @@  -- FeatureCollection Data -features :: Vector.Vector (GeoFeature Aeson.Value)-features = Vector.fromList [featureWithNoBBox, featureWithNoGeometry, featureWithNoBBox, featureWithNoId, featureWithNoProperties, bigFeature]+features :: Sequence.Seq (GeoFeature Aeson.Value)+features = Sequence.fromList [featureWithNoBBox, featureWithNoGeometry, featureWithNoBBox, featureWithNoId, featureWithNoProperties, bigFeature]  bigAssFeatureCollectionJSON :: BS.ByteString bigAssFeatureCollectionJSON = "{\"bbox\":[-32,147.5,-29.5,151],\"features\":[{\"geometry\":{\"geometries\":[{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[],\"type\":\"MultiLineString\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],\"type\":\"LineString\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],[]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"},{\"coordinates\":[],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"}],\"type\":\"GeometryCollection\"},\"id\":\"GW001\",\"type\":\"Feature\",\"properties\":{\"depth\":5,\"comment\":\"Bore run over by dump truck\"}},{\"bbox\":[-32,147.5,-29.5,151],\"geometry\":null,\"id\":\"GW001\",\"type\":\"Feature\",\"properties\":{\"depth\":5,\"comment\":\"Bore run over by dump truck\"}},{\"geometry\":{\"geometries\":[{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[],\"type\":\"MultiLineString\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],\"type\":\"LineString\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],[]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"},{\"coordinates\":[],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"}],\"type\":\"GeometryCollection\"},\"id\":\"GW001\",\"type\":\"Feature\",\"properties\":{\"depth\":5,\"comment\":\"Bore run over by dump truck\"}},{\"bbox\":[-32,147.5,-29.5,151],\"geometry\":{\"geometries\":[{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[],\"type\":\"MultiLineString\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],\"type\":\"LineString\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],[]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"},{\"coordinates\":[],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"}],\"type\":\"GeometryCollection\"},\"type\":\"Feature\",\"properties\":{\"depth\":5,\"comment\":\"Bore run over by dump truck\"}},{\"bbox\":[-32,147.5,-29.5,151],\"geometry\":{\"geometries\":[{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[],\"type\":\"MultiLineString\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],\"type\":\"LineString\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],[]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"},{\"coordinates\":[],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"}],\"type\":\"GeometryCollection\"},\"id\":\"GW001\",\"type\":\"Feature\",\"properties\":null},{\"bbox\":[-32,147.5,-29.5,151],\"geometry\":{\"geometries\":[{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[],\"type\":\"MultiLineString\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]]],\"type\":\"MultiLineString\"},{\"coordinates\":[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18]],\"type\":\"LineString\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],[]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]]],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"},{\"coordinates\":[],\"type\":\"MultiPolygon\"},{\"coordinates\":[[[120,-15],[127,-15],[127,-25],[124,-25],[124,-18],[120,-18],[120,-15]]],\"type\":\"Polygon\"}],\"type\":\"GeometryCollection\"},\"id\":\"GW001\",\"type\":\"Feature\",\"properties\":{\"depth\":5,\"comment\":\"Bore run over by dump truck\"}}],\"type\":\"FeatureCollection\"}"@@ -269,10 +268,10 @@ emptyFeatureCollectionJSON = "{\"type\":\"FeatureCollection\",\"features\":[]}"  emptyFeatureCollection :: GeoFeatureCollection Aeson.Value-emptyFeatureCollection = GeoFeatureCollection Nothing Vector.empty+emptyFeatureCollection = GeoFeatureCollection Nothing Sequence.empty  emptyFeatureCollectionWithBBoxJSON :: BS.ByteString emptyFeatureCollectionWithBBoxJSON = "{\"type\":\"FeatureCollection\",\"features\":[],\"bbox\":[-32,147.5,-29.5,151]}"  emptyFeatureCollectionWithBBox :: GeoFeatureCollection Aeson.Value-emptyFeatureCollectionWithBBox = GeoFeatureCollection bbox Vector.empty+emptyFeatureCollectionWithBBox = GeoFeatureCollection bbox Sequence.empty