diff --git a/geojson.cabal b/geojson.cabal
--- a/geojson.cabal
+++ b/geojson.cabal
@@ -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
diff --git a/src/Data/Geospatial/Internal/BasicTypes.hs b/src/Data/Geospatial/Internal/BasicTypes.hs
--- a/src/Data/Geospatial/Internal/BasicTypes.hs
+++ b/src/Data/Geospatial/Internal/BasicTypes.hs
@@ -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
diff --git a/src/Data/Geospatial/Internal/GeoFeatureCollection.hs b/src/Data/Geospatial/Internal/GeoFeatureCollection.hs
--- a/src/Data/Geospatial/Internal/GeoFeatureCollection.hs
+++ b/src/Data/Geospatial/Internal/GeoFeatureCollection.hs
@@ -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
diff --git a/src/Data/Geospatial/Internal/Geometry.hs b/src/Data/Geospatial/Internal/Geometry.hs
--- a/src/Data/Geospatial/Internal/Geometry.hs
+++ b/src/Data/Geospatial/Internal/Geometry.hs
@@ -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
 
diff --git a/src/Data/Geospatial/Internal/Geometry/GeoMultiLine.hs b/src/Data/Geospatial/Internal/Geometry/GeoMultiLine.hs
--- a/src/Data/Geospatial/Internal/Geometry/GeoMultiLine.hs
+++ b/src/Data/Geospatial/Internal/Geometry/GeoMultiLine.hs
@@ -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
 
diff --git a/src/Data/Geospatial/Internal/Geometry/GeoMultiPoint.hs b/src/Data/Geospatial/Internal/Geometry/GeoMultiPoint.hs
--- a/src/Data/Geospatial/Internal/Geometry/GeoMultiPoint.hs
+++ b/src/Data/Geospatial/Internal/Geometry/GeoMultiPoint.hs
@@ -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
 
diff --git a/src/Data/Geospatial/Internal/Geometry/GeoMultiPolygon.hs b/src/Data/Geospatial/Internal/Geometry/GeoMultiPolygon.hs
--- a/src/Data/Geospatial/Internal/Geometry/GeoMultiPolygon.hs
+++ b/src/Data/Geospatial/Internal/Geometry/GeoMultiPolygon.hs
@@ -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
 
diff --git a/src/Data/Geospatial/Internal/Geometry/GeoPolygon.hs b/src/Data/Geospatial/Internal/Geometry/GeoPolygon.hs
--- a/src/Data/Geospatial/Internal/Geometry/GeoPolygon.hs
+++ b/src/Data/Geospatial/Internal/Geometry/GeoPolygon.hs
@@ -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
 
diff --git a/src/Data/LineString.hs b/src/Data/LineString.hs
--- a/src/Data/LineString.hs
+++ b/src/Data/LineString.hs
@@ -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 #-}
diff --git a/src/Data/LinearRing.hs b/src/Data/LinearRing.hs
--- a/src/Data/LinearRing.hs
+++ b/src/Data/LinearRing.hs
@@ -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
diff --git a/test/Arbitrary.hs b/test/Arbitrary.hs
--- a/test/Arbitrary.hs
+++ b/test/Arbitrary.hs
@@ -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
diff --git a/test/Data/LineStringTests.hs b/test/Data/LineStringTests.hs
--- a/test/Data/LineStringTests.hs
+++ b/test/Data/LineStringTests.hs
@@ -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)
diff --git a/test/Data/LinearRingTests.hs b/test/Data/LinearRingTests.hs
--- a/test/Data/LinearRingTests.hs
+++ b/test/Data/LinearRingTests.hs
@@ -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
diff --git a/test/Fixture.hs b/test/Fixture.hs
--- a/test/Fixture.hs
+++ b/test/Fixture.hs
@@ -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