avoiding sized-vector dependency

Author: athanclark

bower.json

@@ -19,7 +19,6 @@
     "purescript-nullable": "^4.1.1",
     "purescript-typelevel": "^6.0.0",
     "purescript-uint": "^5.1.1",
-    "purescript-sized-vectors": "git://github.com/athanclark/purescript-sized-vectors.git#4fcf13f5ed949e95242b99bcace1648e29bbcbad",
     "purescript-partial": "^2.0.1",
     "purescript-float32": "~0.1.1"
   },

src/Data/ArrayBuffer/DataView/Gen.purs

@@ -1,6 +1,6 @@
 module Data.ArrayBuffer.DataView.Gen where
 
-import Prelude ((<$>), bind, ($), (<=), (-), pure)
+import Prelude ((<$>), bind, (<=), (-), pure)
 
 import Control.Monad.Gen (suchThat)
 import Control.Monad.Gen.Class (class MonadGen, chooseInt)
@@ -9,12 +9,8 @@ import Data.ArrayBuffer.ArrayBuffer.Gen (genArrayBuffer)
 import Data.ArrayBuffer.DataView (whole, byteLength)
 import Data.ArrayBuffer.Types (DataView, ByteOffset, kind ArrayViewType)
 import Data.ArrayBuffer.ValueMapping (class BytesPerValue, class BinaryValue)
-import Data.Maybe (Maybe(Just))
 import Data.Typelevel.Num (class Nat, toInt')
 import Data.Unfoldable (replicateA)
-import Data.Vec (Vec)
-import Data.Vec (fromArray) as Vec
-import Partial.Unsafe (unsafePartial)
 import Type.Proxy (Proxy(..))
 
 
@@ -27,7 +23,7 @@ genDataView = whole <$> genArrayBuffer
 
 -- | For generating some set of offsets residing inside the generated array, with some computable value
 data WithOffsetAndValue n (a :: ArrayViewType) t =
-  WithOffsetAndValue (Vec n ByteOffset) t DataView
+  WithOffsetAndValue (Array ByteOffset) t DataView
 
 genWithOffsetAndValue :: forall m n a b t
                       . MonadGen m
@@ -44,8 +40,6 @@ genWithOffsetAndValue gen genT = do
       b = toInt' (Proxy :: Proxy b)
   xs <- gen `suchThat` \xs -> b <= byteLength xs
   let l = byteLength xs
-  mos <- replicateA n (chooseInt 0 (l - b))
-  let os = unsafePartial $ case Vec.fromArray mos of
-        Just q -> q
+  os <- replicateA n (chooseInt 0 (l - b))
   t <- genT
   pure (WithOffsetAndValue os t xs)

src/Data/ArrayBuffer/Typed/Gen.purs

@@ -2,23 +2,19 @@
 
 module Data.ArrayBuffer.Typed.Gen where
 
+import Prelude ((<$>), bind, (/), (-), negate, ($), bottom, pure, top)
 import Control.Monad.Gen.Class (class MonadGen, sized, chooseInt, chooseFloat)
 import Data.ArrayBuffer.Typed (class TypedArray)
 import Data.ArrayBuffer.Typed as TA
 import Data.ArrayBuffer.Types (ArrayView)
 import Data.Float32 (Float32, fromNumber') as F
 import Data.Generic.Rep (class Generic)
-import Data.Maybe (Maybe(..))
 import Data.Typelevel.Num (class Nat, toInt')
 import Data.UInt (UInt)
 import Data.UInt (fromInt) as UInt
 import Data.UInt.Gen (genUInt) as UInt
 import Data.Unfoldable (replicateA)
-import Data.Vec (Vec)
-import Data.Vec (fromArray) as Vec
 import Effect.Unsafe (unsafePerformEffect)
-import Partial.Unsafe (unsafePartial)
-import Prelude ((<$>), bind, (/), (-), negate, ($), bottom, pure, top)
 import Type.Proxy (Proxy(..))
 
 
@@ -58,7 +54,7 @@ genFloat64 = chooseFloat ((-1.7976931348623157e+308)/div) (1.7976931348623157e+3
   where div = 4.0
 
 -- | For generating some set of offsets residing inside the generated array
-data WithIndices n a = WithIndices (Vec n TA.Index) (ArrayView a)
+data WithIndices n a = WithIndices (Array TA.Index) (ArrayView a)
 derive instance genericWithIndices :: Generic (ArrayView a) a' => Generic (WithIndices n a) _
 
 genWithIndices :: forall m n a
@@ -70,7 +66,5 @@ genWithIndices gen = do
   let n = toInt' (Proxy :: Proxy n)
   xs <- gen
   let l = TA.length xs
-  mos <- replicateA n (chooseInt 0 (l - 1))
-  let os = unsafePartial $ case Vec.fromArray mos of
-        Just q -> q
+  os <- replicateA n (chooseInt 0 (l - 1))
   pure (WithIndices os xs)