diff --git a/src/Data/Internal/Wkb/GeometryCollection.hs b/src/Data/Internal/Wkb/GeometryCollection.hs
--- a/src/Data/Internal/Wkb/GeometryCollection.hs
+++ b/src/Data/Internal/Wkb/GeometryCollection.hs
@@ -6,7 +6,7 @@
 import qualified Control.Monad              as Monad
 import qualified Data.Binary.Get            as BinaryGet
 import qualified Data.Geospatial            as Geospatial
-import qualified Data.Vector                as Vector
+import qualified Data.Sequence              as Sequence
 
 import qualified Data.Internal.Wkb.Endian   as Endian
 import qualified Data.Internal.Wkb.Geometry as Geometry
@@ -17,7 +17,7 @@
                           -> BinaryGet.Get Geospatial.GeospatialGeometry
 geometryCollection getGeospatialGeometry endianType _ = do
   numberOfGeometries <- Endian.fourBytes endianType
-  geoSpatialGeometries <- Vector.generateM (fromIntegral numberOfGeometries) (const getGeospatialGeometry)
+  geoSpatialGeometries <- Sequence.replicateM (fromIntegral numberOfGeometries) getGeospatialGeometry
   pure $ Geospatial.Collection geoSpatialGeometries
 
 enclosedFeature :: (Endian.EndianType -> BinaryGet.Get Geometry.WkbGeometryType)
diff --git a/src/Data/Internal/Wkb/Line.hs b/src/Data/Internal/Wkb/Line.hs
--- a/src/Data/Internal/Wkb/Line.hs
+++ b/src/Data/Internal/Wkb/Line.hs
@@ -7,7 +7,7 @@
 import qualified Data.Binary.Get                      as BinaryGet
 import qualified Data.Geospatial                      as Geospatial
 import qualified Data.LineString                      as LineString
-import qualified Data.Vector                          as Vector
+import qualified Data.Sequence                        as Sequence
 
 import qualified Data.Internal.Wkb.Endian             as Endian
 import qualified Data.Internal.Wkb.Geometry           as Geometry
@@ -22,7 +22,7 @@
 multiLine :: (Endian.EndianType -> BinaryGet.Get Geometry.WkbGeometryType) -> Endian.EndianType -> Geometry.CoordinateType -> BinaryGet.Get Geospatial.GeospatialGeometry
 multiLine getWkbGeom endianType _ = do
   numberOfLines <- Endian.fourBytes endianType
-  geoLines <- Vector.generateM (fromIntegral numberOfLines) (const $ GeometryCollection.enclosedFeature getWkbGeom Geometry.LineString geoLine)
+  geoLines <- Sequence.replicateM (fromIntegral numberOfLines) (GeometryCollection.enclosedFeature getWkbGeom Geometry.LineString geoLine)
   pure $ Geospatial.MultiLine $ Geospatial.mergeGeoLines geoLines
 
 geoLine :: Endian.EndianType -> Geometry.CoordinateType -> BinaryGet.Get Geospatial.GeoLine
diff --git a/src/Data/Internal/Wkb/Point.hs b/src/Data/Internal/Wkb/Point.hs
--- a/src/Data/Internal/Wkb/Point.hs
+++ b/src/Data/Internal/Wkb/Point.hs
@@ -7,8 +7,7 @@
 
 import qualified Data.Binary.Get                      as BinaryGet
 import qualified Data.Geospatial                      as Geospatial
-import qualified Data.Vector                          as Vector
-import qualified Data.Vector.Storable                 as VectorStorable
+import qualified Data.Sequence                        as Sequence
 import qualified Data.Word                            as Word
 
 import qualified Data.Internal.Wkb.Endian             as Endian
@@ -23,7 +22,7 @@
 multiPoint :: (Endian.EndianType -> BinaryGet.Get Geometry.WkbGeometryType) -> Endian.EndianType -> Geometry.CoordinateType -> BinaryGet.Get Geospatial.GeospatialGeometry
 multiPoint getWkbGeom endianType _ = do
   numberOfPoints <- Endian.fourBytes endianType
-  geoPoints <- Vector.generateM (fromIntegral numberOfPoints) (const $ GeometryCollection.enclosedFeature getWkbGeom Geometry.Point geoPoint)
+  geoPoints <- Sequence.replicateM (fromIntegral numberOfPoints) (GeometryCollection.enclosedFeature getWkbGeom Geometry.Point geoPoint)
   pure $ Geospatial.MultiPoint $ Geospatial.mergeGeoPoints geoPoints
 
 geoPoint :: Endian.EndianType -> Geometry.CoordinateType -> BinaryGet.Get Geospatial.GeoPoint
@@ -31,9 +30,9 @@
   p <- coordPoint endianType coordType
   pure $ Geospatial.GeoPoint p
 
-coordPoints :: Endian.EndianType -> Geometry.CoordinateType -> Word.Word32 -> BinaryGet.Get (VectorStorable.Vector Geospatial.GeoPositionWithoutCRS)
+coordPoints :: Endian.EndianType -> Geometry.CoordinateType -> Word.Word32 -> BinaryGet.Get (Sequence.Seq Geospatial.GeoPositionWithoutCRS)
 coordPoints endianType coordType numberOfPoints =
-  VectorStorable.generateM (fromIntegral numberOfPoints) (const $ coordPoint endianType coordType)
+  Sequence.replicateM (fromIntegral numberOfPoints) (coordPoint endianType coordType)
 
 coordPoint :: Endian.EndianType -> Geometry.CoordinateType -> BinaryGet.Get Geospatial.GeoPositionWithoutCRS
 coordPoint endianType coordType =
diff --git a/src/Data/Internal/Wkb/Polygon.hs b/src/Data/Internal/Wkb/Polygon.hs
--- a/src/Data/Internal/Wkb/Polygon.hs
+++ b/src/Data/Internal/Wkb/Polygon.hs
@@ -7,13 +7,13 @@
 import qualified Data.Binary.Get                      as BinaryGet
 import qualified Data.Geospatial                      as Geospatial
 import qualified Data.LinearRing                      as LinearRing
-import qualified Data.Vector                          as Vector
-import qualified Data.Vector.Storable                 as VectorStorable
+import qualified Data.Sequence                        as Sequence
 
 import qualified Data.Internal.Wkb.Endian             as Endian
 import qualified Data.Internal.Wkb.Geometry           as Geometry
 import qualified Data.Internal.Wkb.GeometryCollection as GeometryCollection
 import qualified Data.Internal.Wkb.Point              as Point
+import qualified Data.SeqHelper                       as SeqHelper
 
 polygon :: Endian.EndianType -> Geometry.CoordinateType -> BinaryGet.Get Geospatial.GeospatialGeometry
 polygon endianType coordType = do
@@ -23,7 +23,7 @@
 multiPolygon :: (Endian.EndianType -> BinaryGet.Get Geometry.WkbGeometryType) -> Endian.EndianType -> Geometry.CoordinateType -> BinaryGet.Get Geospatial.GeospatialGeometry
 multiPolygon getWkbGeom endianType _ = do
   numberOfPolygons <- Endian.fourBytes endianType
-  geoPolygons <- Vector.generateM (fromIntegral numberOfPolygons) (const $ GeometryCollection.enclosedFeature getWkbGeom Geometry.Polygon getGeoPolygon)
+  geoPolygons <- Sequence.replicateM (fromIntegral numberOfPolygons) (GeometryCollection.enclosedFeature getWkbGeom Geometry.Polygon getGeoPolygon)
   pure $ Geospatial.MultiPolygon $ Geospatial.mergeGeoPolygons geoPolygons
 
 getGeoPolygon :: Endian.EndianType -> Geometry.CoordinateType -> BinaryGet.Get Geospatial.GeoPolygon
@@ -31,10 +31,10 @@
   linearRings <- getLinearRings endianType coordType
   pure $ Geospatial.GeoPolygon linearRings
 
-getLinearRings :: Endian.EndianType -> Geometry.CoordinateType -> BinaryGet.Get (Vector.Vector (LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS))
+getLinearRings :: Endian.EndianType -> Geometry.CoordinateType -> BinaryGet.Get (Sequence.Seq (LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS))
 getLinearRings endianType coordType = do
   numberOfRings <- Endian.fourBytes endianType
-  Vector.generateM (fromIntegral numberOfRings) (const $ getLinearRing endianType coordType)
+  Sequence.replicateM (fromIntegral numberOfRings) (getLinearRing endianType coordType)
 
 getLinearRing :: Endian.EndianType -> Geometry.CoordinateType -> BinaryGet.Get (LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS)
 getLinearRing endianType coordType = do
@@ -43,13 +43,13 @@
     p1 <- Point.coordPoint endianType coordType
     p2 <- Point.coordPoint endianType coordType
     p3 <- Point.coordPoint endianType coordType
-    pts <- Point.coordPoints endianType coordType (numberOfPoints - 3)
-    if VectorStorable.last pts == p1 then
-      pure $ LinearRing.makeLinearRing p1 p2 p3 (VectorStorable.init pts)
+    pts@(_ Sequence.:|> lastS) <- Point.coordPoints endianType coordType (numberOfPoints - 3)
+    if lastS == p1 then
+      pure $ LinearRing.makeLinearRing p1 p2 p3 (SeqHelper.sequenceHead pts)
     else
       Monad.fail $
         "First and last points of linear ring are different: first="
-         ++ show p1 ++ " last=" ++ show (VectorStorable.last pts)
+         ++ show p1 ++ " last=" ++ show lastS
   else
     Monad.fail $
       "Must have at least four points for a linear ring: "
diff --git a/src/Data/Internal/Wkt/Common.hs b/src/Data/Internal/Wkt/Common.hs
--- a/src/Data/Internal/Wkt/Common.hs
+++ b/src/Data/Internal/Wkt/Common.hs
@@ -6,13 +6,13 @@
 
 import           Control.Applicative ((<|>))
 import qualified Data.Scientific     as Scientific
-import qualified Data.Vector         as Vector
+import qualified Data.Sequence       as Sequence
 import qualified Text.Trifecta       as Trifecta
 
-emptySet :: Trifecta.Parser (Vector.Vector a)
+emptySet :: Trifecta.Parser (Sequence.Seq a)
 emptySet = do
   _ <- Trifecta.string "empty"
-  pure Vector.empty
+  pure Sequence.empty
 
 emptySets :: Trifecta.Parser ([a], [[a]])
 emptySets = do
diff --git a/src/Data/Internal/Wkt/GeometryCollection.hs b/src/Data/Internal/Wkt/GeometryCollection.hs
--- a/src/Data/Internal/Wkt/GeometryCollection.hs
+++ b/src/Data/Internal/Wkt/GeometryCollection.hs
@@ -5,7 +5,7 @@
 
 import           Control.Applicative       ((<|>))
 import qualified Data.Geospatial           as Geospatial
-import qualified Data.Vector               as Vector
+import qualified Data.Sequence             as Sequence
 import qualified Text.Trifecta             as Trifecta
 
 import qualified Data.Internal.Wkt.Common  as Wkt
@@ -13,27 +13,27 @@
 import qualified Data.Internal.Wkt.Point   as Point
 import qualified Data.Internal.Wkt.Polygon as Polygon
 
-geometryCollection :: Trifecta.Parser (Vector.Vector Geospatial.GeospatialGeometry)
+geometryCollection :: Trifecta.Parser (Sequence.Seq Geospatial.GeospatialGeometry)
 geometryCollection = do
   _ <- Trifecta.string "geometrycollection"
   _ <- Trifecta.spaces
   Wkt.emptySet <|> bracketedAll
 
-bracketedAll :: Trifecta.Parser (Vector.Vector Geospatial.GeospatialGeometry)
+bracketedAll :: Trifecta.Parser (Sequence.Seq Geospatial.GeospatialGeometry)
 bracketedAll = do
   _ <- Trifecta.char '(' >> Trifecta.spaces
   x <- parseAll
   _ <- Trifecta.spaces >> Trifecta.char ')'
   pure x
 
-parseAll :: Trifecta.Parser (Vector.Vector Geospatial.GeospatialGeometry)
+parseAll :: Trifecta.Parser (Sequence.Seq Geospatial.GeospatialGeometry)
 parseAll = do
   let
     single = Geospatial.Point <$> Point.point <|> Geospatial.Line <$> Line.lineString <|> Geospatial.Polygon <$> Polygon.polygon
     multi = Geospatial.MultiPoint <$> Point.multiPoint <|> Geospatial.MultiLine <$> Line.multiLineString <|> Geospatial.MultiPolygon <$> Polygon.multiPolygon
   x <- single <|> multi
   xs <- Trifecta.many (Trifecta.char ',' >> Trifecta.spaces >> (single <|> multi))
-  pure $ Vector.cons x (Vector.fromList xs)
+  pure $  x Sequence.:<| Sequence.fromList xs
 
-emptyGeometryCollection :: Vector.Vector Geospatial.GeospatialGeometry
-emptyGeometryCollection = Vector.empty
+emptyGeometryCollection :: Sequence.Seq Geospatial.GeospatialGeometry
+emptyGeometryCollection = Sequence.empty
diff --git a/src/Data/Internal/Wkt/Line.hs b/src/Data/Internal/Wkt/Line.hs
--- a/src/Data/Internal/Wkt/Line.hs
+++ b/src/Data/Internal/Wkt/Line.hs
@@ -10,8 +10,7 @@
 import           Control.Applicative      ((<|>))
 import qualified Data.Geospatial          as Geospatial
 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
 import qualified Text.Trifecta            as Trifecta
 
 import qualified Data.Internal.Wkt.Common as Wkt
@@ -30,13 +29,13 @@
   x <- Wkt.emptySet <|> manyLines
   pure $ Geospatial.GeoMultiLine x
 
-manyLines :: Trifecta.Parser (Vector.Vector (LineString.LineString Geospatial.GeoPositionWithoutCRS))
+manyLines :: Trifecta.Parser (Sequence.Seq (LineString.LineString Geospatial.GeoPositionWithoutCRS))
 manyLines = do
   _ <- Trifecta.spaces >> Trifecta.char '('
   x <- line
   xs <- Trifecta.many (Trifecta.char ',' >> Trifecta.spaces >> line)
   _ <-  Trifecta.char ')' >> Trifecta.spaces
-  pure $ Vector.cons x (Vector.fromList xs)
+  pure $ x Sequence.:<| Sequence.fromList xs
 
 line :: Trifecta.Parser (LineString.LineString Geospatial.GeoPositionWithoutCRS)
 line = do
@@ -45,7 +44,7 @@
   second <- commandPoint
   rest <- Trifecta.many commandPoint
   _ <- Trifecta.char ')' >> Trifecta.spaces
-  pure $ LineString.makeLineString first second (VectorStorable.fromList rest)
+  pure $ LineString.makeLineString first second (Sequence.fromList rest)
 
 commandPoint :: Trifecta.Parser Geospatial.GeoPositionWithoutCRS
 commandPoint = do
@@ -54,7 +53,7 @@
   Point.justPoints
 
 emptyLine :: Geospatial.GeoLine
-emptyLine = Geospatial.GeoLine $ LineString.makeLineString Geospatial.GeoEmpty Geospatial.GeoEmpty VectorStorable.empty
+emptyLine = Geospatial.GeoLine $ LineString.makeLineString Geospatial.GeoEmpty Geospatial.GeoEmpty Sequence.empty
 
 emptyMultiLine :: Geospatial.GeoMultiLine
-emptyMultiLine = Geospatial.mergeGeoLines Vector.empty
+emptyMultiLine = Geospatial.mergeGeoLines Sequence.empty
diff --git a/src/Data/Internal/Wkt/Point.hs b/src/Data/Internal/Wkt/Point.hs
--- a/src/Data/Internal/Wkt/Point.hs
+++ b/src/Data/Internal/Wkt/Point.hs
@@ -8,12 +8,11 @@
 
 import           Control.Applicative      ((<|>))
 import qualified Data.Geospatial          as Geospatial
+import qualified Data.Internal.Wkt.Common as Wkt
 import qualified Data.Scientific          as Scientific
-import qualified Data.Vector              as Vector
+import qualified Data.Sequence            as Sequence
 import qualified Text.Trifecta            as Trifecta
 
-import qualified Data.Internal.Wkt.Common as Wkt
-
 point :: Trifecta.Parser Geospatial.GeoPoint
 point = do
   _ <- Trifecta.string "point"
@@ -27,24 +26,24 @@
   xl <- Wkt.emptySet <|> manyPoints
   pure $ Geospatial.GeoMultiPoint xl
 
-manyPoints :: Trifecta.Parser (Vector.Vector Geospatial.GeoPositionWithoutCRS)
+manyPoints :: Trifecta.Parser (Sequence.Seq Geospatial.GeoPositionWithoutCRS)
 manyPoints = do
   _ <- Trifecta.char '(' >> Trifecta.spaces
   xl <- unbracketedPoints <|> bracketedPoints
   _ <- Trifecta.spaces >> Trifecta.char ')' >> Trifecta.spaces
   pure xl
 
-unbracketedPoints :: Trifecta.Parser (Vector.Vector Geospatial.GeoPositionWithoutCRS)
+unbracketedPoints :: Trifecta.Parser (Sequence.Seq Geospatial.GeoPositionWithoutCRS)
 unbracketedPoints = do
   x <- justPoints
   xs <- Trifecta.many (Trifecta.char ',' >> Trifecta.spaces >> justPoints)
-  pure $ Vector.cons x (Vector.fromList xs)
+  pure $ x Sequence.<| Sequence.fromList xs
 
-bracketedPoints :: Trifecta.Parser (Vector.Vector Geospatial.GeoPositionWithoutCRS)
+bracketedPoints :: Trifecta.Parser (Sequence.Seq Geospatial.GeoPositionWithoutCRS)
 bracketedPoints = do
   x <- bracketedPoint
   xs <- Trifecta.many (Trifecta.char ',' >> Trifecta.spaces >> bracketedPoint)
-  pure $ Vector.cons x (Vector.fromList xs)
+  pure $ x Sequence.<| Sequence.fromList xs
 
 bracketedPoint :: Trifecta.Parser Geospatial.GeoPositionWithoutCRS
 bracketedPoint = do
@@ -64,4 +63,4 @@
 emptyPoint = Geospatial.GeoPoint Geospatial.GeoEmpty
 
 emptyMultiPoint :: Geospatial.GeoMultiPoint
-emptyMultiPoint = Geospatial.GeoMultiPoint Vector.empty
+emptyMultiPoint = Geospatial.GeoMultiPoint Sequence.empty
diff --git a/src/Data/Internal/Wkt/Polygon.hs b/src/Data/Internal/Wkt/Polygon.hs
--- a/src/Data/Internal/Wkt/Polygon.hs
+++ b/src/Data/Internal/Wkt/Polygon.hs
@@ -8,13 +8,13 @@
 import           Control.Applicative      ((<|>))
 import qualified Data.Geospatial          as Geospatial
 import qualified Data.LinearRing          as LinearRing
-import qualified Data.Vector              as Vector
-import qualified Data.Vector.Storable     as VectorStorable
+import qualified Data.Sequence            as Sequence
 import qualified Text.Trifecta            as Trifecta
 
 import qualified Data.Internal.Wkt.Common as Wkt
 import qualified Data.Internal.Wkt.Line   as Line
 import qualified Data.Internal.Wkt.Point  as Point
+import qualified Data.SeqHelper           as SeqHelper
 
 polygon :: Trifecta.Parser Geospatial.GeoPolygon
 polygon = do
@@ -30,21 +30,21 @@
   xs <- Wkt.emptySet <|> multiPolygon'
   pure $ Geospatial.GeoMultiPolygon xs
 
-polygon' :: Trifecta.Parser (Vector.Vector (LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS))
+polygon' :: Trifecta.Parser (Sequence.Seq (LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS))
 polygon' = do
   _ <- Trifecta.spaces >> Trifecta.char '('
   x <- linearRing
   xs <- Trifecta.many (Trifecta.char ',' >> Trifecta.spaces >> linearRing)
   _ <- Trifecta.char ')' >> Trifecta.spaces
-  pure $ Vector.cons x (Vector.fromList xs)
+  pure $ x Sequence.:<| Sequence.fromList xs
 
-multiPolygon' :: Trifecta.Parser (Vector.Vector (Vector.Vector (LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS)))
+multiPolygon' :: Trifecta.Parser (Sequence.Seq (Sequence.Seq (LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS)))
 multiPolygon' = do
   _ <- Trifecta.spaces >> Trifecta.char '('
   x <- polygon'
   xs <- Trifecta.many (Trifecta.char ',' >> Trifecta.spaces >> polygon')
   _ <- Trifecta.char ')' >> Trifecta.spaces
-  pure $ Vector.cons x (Vector.fromList xs)
+  pure $ x Sequence.:<| Sequence.fromList xs
 
 linearRing :: Trifecta.Parser (LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS)
 linearRing = do
@@ -54,10 +54,11 @@
   third <- Line.commandPoint
   rest <- Trifecta.many Line.commandPoint
   _ <- Trifecta.char ')' >> Trifecta.spaces
-  pure $ LinearRing.makeLinearRing first second third (VectorStorable.init $ VectorStorable.fromList rest)
+  pure $ LinearRing.makeLinearRing first second third (SeqHelper.sequenceHead $ Sequence.fromList rest)
 
 emptyPolygon :: Geospatial.GeoPolygon
-emptyPolygon = Geospatial.GeoPolygon Vector.empty
+emptyPolygon = Geospatial.GeoPolygon Sequence.empty
 
 emptyMultiPolygon :: Geospatial.GeoMultiPolygon
-emptyMultiPolygon = Geospatial.mergeGeoPolygons Vector.empty
+emptyMultiPolygon = Geospatial.mergeGeoPolygons Sequence.empty
+
diff --git a/test/Data/SpecHelper.hs b/test/Data/SpecHelper.hs
--- a/test/Data/SpecHelper.hs
+++ b/test/Data/SpecHelper.hs
@@ -1,9 +1,9 @@
 module Data.SpecHelper where
 
-import qualified Data.Geospatial      as Geospatial
-import qualified Data.LinearRing      as LinearRing
-import qualified Data.LineString      as LineString
-import qualified Data.Vector.Storable as VectorStorable
+import qualified Data.Geospatial as Geospatial
+import qualified Data.LinearRing as LinearRing
+import qualified Data.LineString as LineString
+import qualified Data.Sequence   as Sequence
 
 point1 :: Geospatial.GeoPositionWithoutCRS
 point1 = Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.0)
@@ -12,19 +12,19 @@
 point2 = Geospatial.GeoPointXY (Geospatial.PointXY 3.0 4.0)
 
 lineString1 :: LineString.LineString Geospatial.GeoPositionWithoutCRS
-lineString1 = LineString.makeLineString (Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 3.0 4.0)) VectorStorable.empty
+lineString1 = LineString.makeLineString (Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 3.0 4.0)) Sequence.empty
 
 lineString2 :: LineString.LineString Geospatial.GeoPositionWithoutCRS
-lineString2 = LineString.makeLineString (Geospatial.GeoPointXY (Geospatial.PointXY 1.5 2.5)) (Geospatial.GeoPointXY (Geospatial.PointXY 3.5 4.5)) VectorStorable.empty
+lineString2 = LineString.makeLineString (Geospatial.GeoPointXY (Geospatial.PointXY 1.5 2.5)) (Geospatial.GeoPointXY (Geospatial.PointXY 3.5 4.5)) Sequence.empty
 
 lineString3 :: LineString.LineString Geospatial.GeoPositionWithoutCRS
-lineString3 = LineString.makeLineString (Geospatial.GeoPointXY (Geospatial.PointXY 15 15)) (Geospatial.GeoPointXY (Geospatial.PointXY 20 20)) (VectorStorable.singleton (Geospatial.GeoPointXY (Geospatial.PointXY 20 20)))
+lineString3 = LineString.makeLineString (Geospatial.GeoPointXY (Geospatial.PointXY 15 15)) (Geospatial.GeoPointXY (Geospatial.PointXY 20 20)) (Sequence.singleton (Geospatial.GeoPointXY (Geospatial.PointXY 20 20)))
 
 lineString4 :: LineString.LineString Geospatial.GeoPositionWithoutCRS
-lineString4 = LineString.makeLineString (Geospatial.GeoPointXY (Geospatial.PointXY 15 15)) (Geospatial.GeoPointXY (Geospatial.PointXY 20 20)) (VectorStorable.singleton (Geospatial.GeoPointXY (Geospatial.PointXY 25 25)))
+lineString4 = LineString.makeLineString (Geospatial.GeoPointXY (Geospatial.PointXY 15 15)) (Geospatial.GeoPointXY (Geospatial.PointXY 20 20)) (Sequence.singleton (Geospatial.GeoPointXY (Geospatial.PointXY 25 25)))
 
 linearRing1 :: LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS
-linearRing1 = LinearRing.makeLinearRing (Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 3.0 4.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 5.0 6.0)) VectorStorable.empty
+linearRing1 = LinearRing.makeLinearRing (Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 3.0 4.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 5.0 6.0)) Sequence.empty
 
 linearRing2 :: LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS
-linearRing2 = LinearRing.makeLinearRing (Geospatial.GeoPointXY (Geospatial.PointXY 1.5 2.5)) (Geospatial.GeoPointXY (Geospatial.PointXY 3.5 4.5)) (Geospatial.GeoPointXY (Geospatial.PointXY 5.5 6.5)) VectorStorable.empty
+linearRing2 = LinearRing.makeLinearRing (Geospatial.GeoPointXY (Geospatial.PointXY 1.5 2.5)) (Geospatial.GeoPointXY (Geospatial.PointXY 3.5 4.5)) (Geospatial.GeoPointXY (Geospatial.PointXY 5.5 6.5)) Sequence.empty
diff --git a/test/Data/WkbGeometryCollectionSpec.hs b/test/Data/WkbGeometryCollectionSpec.hs
--- a/test/Data/WkbGeometryCollectionSpec.hs
+++ b/test/Data/WkbGeometryCollectionSpec.hs
@@ -7,7 +7,7 @@
 import qualified Data.ByteString.Lazy    as LazyByteString
 import qualified Data.Geospatial         as Geospatial
 import           Data.Monoid             ((<>))
-import qualified Data.Vector             as Vector
+import qualified Data.Sequence           as Sequence
 import qualified Data.Wkb                as Wkb
 import           Test.Hspec              (Spec, describe, it, shouldBe)
 
@@ -22,7 +22,7 @@
   describe "Test wkb geometry collection" $
     it "Parse valid wkb geometry collection" $
       Wkb.parseByteString exampleWkbGeometryCollection `shouldBe` (Right . Geospatial.Collection $
-        Vector.fromList
+        Sequence.fromList
           [ Geospatial.Point $ Geospatial.GeoPoint SpecHelper.point1
           , Geospatial.Point $ Geospatial.GeoPoint SpecHelper.point2
           , Geospatial.Line $ Geospatial.GeoLine SpecHelper.lineString3
diff --git a/test/Data/WkbLineSpec.hs b/test/Data/WkbLineSpec.hs
--- a/test/Data/WkbLineSpec.hs
+++ b/test/Data/WkbLineSpec.hs
@@ -6,7 +6,7 @@
 import qualified Data.ByteString.Lazy    as LazyByteString
 import qualified Data.Geospatial         as Geospatial
 import           Data.Monoid             ((<>))
-import qualified Data.Vector             as Vector
+import qualified Data.Sequence           as Sequence
 import           Test.Hspec              (Spec, describe, it, shouldBe)
 
 import qualified Data.Wkb                as Wkb
@@ -39,7 +39,7 @@
 testWkbMultiLineParsing =
   describe "Test wkb multi line" $
     it "Parse valid wkb multi line" $
-      Wkb.parseByteString exampleWkbMultiLine `shouldBe` (Right $ Geospatial.MultiLine $ Geospatial.GeoMultiLine (Vector.fromList [SpecHelper.lineString1, SpecHelper.lineString2]))
+      Wkb.parseByteString exampleWkbMultiLine `shouldBe` (Right $ Geospatial.MultiLine $ Geospatial.GeoMultiLine (Sequence.fromList [SpecHelper.lineString1, SpecHelper.lineString2]))
 
 exampleWkbMultiLine :: LazyByteString.ByteString
 exampleWkbMultiLine =
diff --git a/test/Data/WkbPointSpec.hs b/test/Data/WkbPointSpec.hs
--- a/test/Data/WkbPointSpec.hs
+++ b/test/Data/WkbPointSpec.hs
@@ -6,7 +6,7 @@
 import qualified Data.ByteString.Lazy    as LazyByteString
 import qualified Data.Geospatial         as Geospatial
 import           Data.Monoid             ((<>))
-import qualified Data.Vector             as Vector
+import qualified Data.Sequence           as Sequence
 import           Test.Hspec              (Spec, describe, it, shouldBe)
 
 import qualified Data.Wkb                as Wkb
@@ -36,7 +36,7 @@
 testWkbMultiPointParsing =
   describe "Test wkb multi point" $
     it "Parse valid wkb multi point" $
-      Wkb.parseByteString exampleWkbMultiPoint `shouldBe` (Right $ Geospatial.MultiPoint (Geospatial.GeoMultiPoint (Vector.fromList [SpecHelper.point1, SpecHelper.point2])))
+      Wkb.parseByteString exampleWkbMultiPoint `shouldBe` (Right $ Geospatial.MultiPoint (Geospatial.GeoMultiPoint (Sequence.fromList [SpecHelper.point1, SpecHelper.point2])))
 
 exampleWkbMultiPoint :: LazyByteString.ByteString
 exampleWkbMultiPoint =
diff --git a/test/Data/WkbPolygonSpec.hs b/test/Data/WkbPolygonSpec.hs
--- a/test/Data/WkbPolygonSpec.hs
+++ b/test/Data/WkbPolygonSpec.hs
@@ -6,7 +6,7 @@
 import qualified Data.ByteString.Lazy    as LazyByteString
 import qualified Data.Geospatial         as Geospatial
 import           Data.Monoid             ((<>))
-import qualified Data.Vector             as Vector
+import qualified Data.Sequence           as Sequence
 import           Test.Hspec              (Spec, describe, it, shouldBe)
 
 import qualified Data.Wkb                as Wkb
@@ -22,7 +22,7 @@
 testWkbPolygonParsing =
   describe "Test wkb polygon" $ do
     it "Parse valid wkb polygon" $
-      Wkb.parseByteString exampleWkbPolygon `shouldBe` (Right $ Geospatial.Polygon $ Geospatial.GeoPolygon (Vector.singleton SpecHelper.linearRing1))
+      Wkb.parseByteString exampleWkbPolygon `shouldBe` (Right $ Geospatial.Polygon $ Geospatial.GeoPolygon (Sequence.singleton SpecHelper.linearRing1))
     it "Not parse bad wkb polygon" $
       Wkb.parseByteString exampleBadWkbPolygon `shouldBe` Left "Could not parse wkb: First and last points of linear ring are different: first=GeoPointXY (PointXY {_xyX = 1.0, _xyY = 2.0}) last=GeoPointXY (PointXY {_xyX = 7.0, _xyY = 8.0})"
 
@@ -63,9 +63,9 @@
   describe "Test wkb multi polygon" $
     it "Parse valid wkb multi polygon" $
       Wkb.parseByteString exampleWkbMultiPolygon `shouldBe` (Right $ Geospatial.MultiPolygon $ Geospatial.GeoMultiPolygon
-        (Vector.fromList
-          [ Vector.singleton SpecHelper.linearRing1
-          , Vector.singleton SpecHelper.linearRing2
+        (Sequence.fromList
+          [ Sequence.singleton SpecHelper.linearRing1
+          , Sequence.singleton SpecHelper.linearRing2
         ]))
 
 exampleWkbMultiPolygon :: LazyByteString.ByteString
diff --git a/test/Data/WktGeometryCollectionSpec.hs b/test/Data/WktGeometryCollectionSpec.hs
--- a/test/Data/WktGeometryCollectionSpec.hs
+++ b/test/Data/WktGeometryCollectionSpec.hs
@@ -4,7 +4,7 @@
 
 import           Control.Lens    ((^?!))
 import qualified Data.Geospatial as Geospatial
-import qualified Data.Vector     as Vector
+import qualified Data.Sequence   as Sequence
 import           Test.Hspec      (Spec, describe, it, shouldBe)
 import qualified Text.Trifecta   as Trifecta
 
@@ -25,9 +25,9 @@
     it "Parse something with spaces" $
       Wkt.parseString Wkt.geometryCollection "GeometryCollection ( POINT ( 1 2) , POINT (3 4) , LINESTRING (15 15  , 20 20, 25 25 ) ) " ^?! Trifecta._Success `shouldBe` exampleGeometryCollection
 
-exampleGeometryCollection :: Vector.Vector Geospatial.GeospatialGeometry
+exampleGeometryCollection :: Sequence.Seq Geospatial.GeospatialGeometry
 exampleGeometryCollection =
-  Vector.fromList
+  Sequence.fromList
     [ Geospatial.Point $ Geospatial.GeoPoint SpecHelper.point1
     , Geospatial.Point $ Geospatial.GeoPoint SpecHelper.point2
     , Geospatial.Line $ Geospatial.GeoLine SpecHelper.lineString4
diff --git a/test/Data/WktLineSpec.hs b/test/Data/WktLineSpec.hs
--- a/test/Data/WktLineSpec.hs
+++ b/test/Data/WktLineSpec.hs
@@ -2,17 +2,15 @@
 
 module Data.WktLineSpec where
 
-import           Control.Lens         ((^?), (^?!))
-import qualified Data.Geospatial      as Geospatial
-import qualified Data.LineString      as LineString
-import qualified Data.Maybe           as Maybe
-import qualified Data.Vector          as Vector
-import qualified Data.Vector.Storable as VectorStorable
-import           Test.Hspec           (Spec, describe, it, shouldBe,
-                                       shouldSatisfy)
-import qualified Text.Trifecta        as Trifecta
+import           Control.Lens    ((^?), (^?!))
+import qualified Data.Geospatial as Geospatial
+import qualified Data.LineString as LineString
+import qualified Data.Maybe      as Maybe
+import qualified Data.Sequence   as Sequence
+import           Test.Hspec      (Spec, describe, it, shouldBe, shouldSatisfy)
+import qualified Text.Trifecta   as Trifecta
 
-import qualified Data.Wkt             as Wkt
+import qualified Data.Wkt        as Wkt
 
 spec :: Spec
 spec = do
@@ -51,7 +49,7 @@
 exampleLine = Geospatial.GeoLine exampleLineString
 
 exampleMultiLine :: Geospatial.GeoMultiLine
-exampleMultiLine =  Geospatial.GeoMultiLine (Vector.singleton exampleLineString)
+exampleMultiLine =  Geospatial.GeoMultiLine (Sequence.singleton exampleLineString)
 
 exampleLineString :: LineString.LineString Geospatial.GeoPositionWithoutCRS
-exampleLineString = LineString.makeLineString (Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.5)) (VectorStorable.singleton (Geospatial.GeoPointXY (Geospatial.PointXY 1.0 3.0)))
+exampleLineString = LineString.makeLineString (Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.5)) (Sequence.singleton (Geospatial.GeoPointXY (Geospatial.PointXY 1.0 3.0)))
diff --git a/test/Data/WktPointSpec.hs b/test/Data/WktPointSpec.hs
--- a/test/Data/WktPointSpec.hs
+++ b/test/Data/WktPointSpec.hs
@@ -5,7 +5,7 @@
 import           Control.Lens    ((^?), (^?!))
 import qualified Data.Geospatial as Geospatial
 import qualified Data.Maybe      as Maybe
-import qualified Data.Vector     as Vector
+import qualified Data.Sequence   as Sequence
 import           Test.Hspec      (Spec, describe, expectationFailure, it,
                                   shouldBe, shouldSatisfy)
 import qualified Text.Trifecta   as Trifecta
@@ -57,4 +57,4 @@
 examplePoint = Geospatial.GeoPoint (Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.0))
 
 exampleMultiPoint :: Geospatial.GeoMultiPoint
-exampleMultiPoint = Geospatial.GeoMultiPoint (Vector.fromList [Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.0), Geospatial.GeoPointXY (Geospatial.PointXY 2.0 2.0)])
+exampleMultiPoint = Geospatial.GeoMultiPoint (Sequence.fromList [Geospatial.GeoPointXY (Geospatial.PointXY 1.0 2.0), Geospatial.GeoPointXY (Geospatial.PointXY 2.0 2.0)])
diff --git a/test/Data/WktPolygonSpec.hs b/test/Data/WktPolygonSpec.hs
--- a/test/Data/WktPolygonSpec.hs
+++ b/test/Data/WktPolygonSpec.hs
@@ -2,15 +2,14 @@
 
 module Data.WktPolygonSpec where
 
-import           Control.Lens         ((^?!))
-import qualified Data.Geospatial      as Geospatial
-import qualified Data.LinearRing      as LinearRing
-import qualified Data.Vector          as Vector
-import qualified Data.Vector.Storable as VectorStorable
-import           Test.Hspec           (Spec, describe, it, shouldBe)
-import qualified Text.Trifecta        as Trifecta
+import           Control.Lens    ((^?!))
+import qualified Data.Geospatial as Geospatial
+import qualified Data.LinearRing as LinearRing
+import qualified Data.Sequence   as Sequence
+import           Test.Hspec      (Spec, describe, it, shouldBe)
+import qualified Text.Trifecta   as Trifecta
 
-import qualified Data.Wkt             as Wkt
+import qualified Data.Wkt        as Wkt
 
 spec :: Spec
 spec = do
@@ -43,22 +42,22 @@
 
 examplePolygon :: Geospatial.GeoPolygon
 examplePolygon =
-  Geospatial.GeoPolygon (Vector.singleton linearRingSingle)
+  Geospatial.GeoPolygon (Sequence.singleton linearRingSingle)
 
 examplePolygonWithHole :: Geospatial.GeoPolygon
 examplePolygonWithHole = Geospatial.GeoPolygon linearRingDouble
 
 linearRingSingle :: LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS
-linearRingSingle = LinearRing.makeLinearRing (Geospatial.GeoPointXY (Geospatial.PointXY 4.0 0.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 0.0 4.0)) (Geospatial.GeoPointXY (Geospatial.PointXY (-4.0) 0.0)) (VectorStorable.fromList [Geospatial.GeoPointXY (Geospatial.PointXY 0.0 (-4.0))])
+linearRingSingle = LinearRing.makeLinearRing (Geospatial.GeoPointXY (Geospatial.PointXY 4.0 0.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 0.0 4.0)) (Geospatial.GeoPointXY (Geospatial.PointXY (-4.0) 0.0)) (Sequence.fromList [Geospatial.GeoPointXY (Geospatial.PointXY 0.0 (-4.0))])
 
-linearRingDouble :: Vector.Vector (LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS)
-linearRingDouble = Vector.fromList
+linearRingDouble :: Sequence.Seq (LinearRing.LinearRing Geospatial.GeoPositionWithoutCRS)
+linearRingDouble = Sequence.fromList
   [ linearRingSingle
-  , LinearRing.makeLinearRing (Geospatial.GeoPointXY (Geospatial.PointXY 2.0 0.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 0.0 2.0)) (Geospatial.GeoPointXY (Geospatial.PointXY (-2.0) 0.0)) (VectorStorable.fromList [ Geospatial.GeoPointXY (Geospatial.PointXY 0.0 (-2.0))])
+  , LinearRing.makeLinearRing (Geospatial.GeoPointXY (Geospatial.PointXY 2.0 0.0)) (Geospatial.GeoPointXY (Geospatial.PointXY 0.0 2.0)) (Geospatial.GeoPointXY (Geospatial.PointXY (-2.0) 0.0)) (Sequence.fromList [ Geospatial.GeoPointXY (Geospatial.PointXY 0.0 (-2.0))])
   ]
 
 exampleMultiPolygon :: Geospatial.GeoMultiPolygon
-exampleMultiPolygon = Geospatial.GeoMultiPolygon (Vector.singleton (Vector.singleton linearRingSingle))
+exampleMultiPolygon = Geospatial.GeoMultiPolygon (Sequence.singleton (Sequence.singleton linearRingSingle))
 
 exampleMultiPolygonWithHole :: Geospatial.GeoMultiPolygon
-exampleMultiPolygonWithHole = Geospatial.GeoMultiPolygon (Vector.singleton linearRingDouble)
+exampleMultiPolygonWithHole = Geospatial.GeoMultiPolygon (Sequence.singleton linearRingDouble)
diff --git a/wkt-geom.cabal b/wkt-geom.cabal
--- a/wkt-geom.cabal
+++ b/wkt-geom.cabal
@@ -1,5 +1,5 @@
 name:                wkt-geom
-version:             0.0.1
+version:             0.0.2
 synopsis:            A parser of WKT, WKB and eWKB.
 description:         Well Known Text (WKT), Well Known Binary and the Postgresql extension Extended Well Know Binary (eWKB) are vector geometry representations.
                      .
@@ -39,7 +39,8 @@
   build-depends:       base < 5 &&      >= 4.8 
                      , binary           >= 0.8
                      , bytestring       >= 0.10
-                     , geojson          >= 2.0.0
+                     , containers      >= 0.5.10.1
+                     , geojson          >= 3.0.1
                      , scientific       >= 0.3.6
                      , trifecta         >= 1.7
                      , utf8-string      >= 1
@@ -68,7 +69,8 @@
                      , binary          >= 0.8
                      , ansi-wl-pprint  >= 0.6
                      , bytestring      >= 0.10
-                     , geojson         >= 2.0.0
+                     , containers      >= 0.5.10.1
+                     , geojson         >= 3.0.1
                      , hspec
                      , lens
                      , QuickCheck
@@ -81,4 +83,9 @@
 
 source-repository head
   type:     git
-  location: https://github.com/githubuser/wkt-geom
+  location: https://github.com/indicatrix/wkt-geom
+
+source-repository this
+  type:     git
+  location: https://github.com/indicatrix/hs-geojson.git
+  tag:      0.0.2
