Use purescript-arraybuffer-types

Author: jacereda

bower.json

@@ -8,9 +8,10 @@
     "output"
   ], 
   "dependencies": {
-    "purescript-maybe": "*"
+    "purescript-arraybuffer-types": "~0.1.0",
+    "purescript-maybe": "~0.2.1"
   },
   "devDependencies": {
-    "purescript-quickcheck": "*"
+    "purescript-quickcheck": "~0.5.0"
   }
 }

src/Data/ArrayBuffer.purs

@@ -3,8 +3,6 @@ module Data.ArrayBuffer where
 import Data.Function
 import Data.ArrayBuffer.Types
 
-foreign import data ArrayBuffer :: *
-
 foreign import create
 """
 function create(s) {

src/Data/ArrayBuffer/Advancer.purs

@@ -1,6 +1,5 @@
 module Data.ArrayBuffer.Advancer where
 
-import Data.ArrayBuffer.DataView(DataView())
 import Data.ArrayBuffer.Types
 import Control.Monad.Eff
 

src/Data/ArrayBuffer/DataView.purs

@@ -1,13 +1,10 @@
 module Data.ArrayBuffer.DataView where
 
-import Data.ArrayBuffer(ArrayBuffer())
 import Data.ArrayBuffer.Types
 import Data.Function
 import Data.Maybe
 import Control.Monad.Eff
 
-foreign import data DataView :: *
-
 foreign import whole
 """
 function whole(b) {

src/Data/ArrayBuffer/Deserializer.purs

@@ -37,44 +37,44 @@ getFloat32 d = chkErr <$> (advance 4 d >>= DV.getFloat32 d.dv)
 getFloat64 :: Getter Float64
 getFloat64 d = chkErr <$> (advance 8 d >>= DV.getFloat64 d.dv)
 
-getDataView :: Deserializer -> ByteLength -> DE DV.DataView
+getDataView :: Deserializer -> ByteLength -> DE DataView
 getDataView d n = do
   o <- advance n d
   return $ case DV.slice o n (DV.buffer d.dv) of
     (Just dv) -> Right dv
     otherwise -> Left "short read"
 
-getTypedArray :: forall t. Deserializer -> Number -> (DV.DataView -> t) -> DE t
+getTypedArray :: forall t. Deserializer -> Number -> (DataView -> t) -> DE t
 getTypedArray d sz conv = do
   edv <- getDataView d sz
   return $ case edv of
     Right dv -> Right $ conv dv
     Left err -> Left err
 
-getInt8Array :: ArrayGetter TA.Int8Array
+getInt8Array :: ArrayGetter Int8Array
 getInt8Array d n = getTypedArray d n TA.asInt8Array
-getInt16Array :: ArrayGetter TA.Int16Array
+getInt16Array :: ArrayGetter Int16Array
 getInt16Array d n = getTypedArray d (n * 2) TA.asInt16Array
-getInt32Array :: ArrayGetter TA.Int32Array
+getInt32Array :: ArrayGetter Int32Array
 getInt32Array d n = getTypedArray d (n * 4) TA.asInt32Array
-getUint8Array :: ArrayGetter TA.Uint8Array
+getUint8Array :: ArrayGetter Uint8Array
 getUint8Array d n = getTypedArray d n TA.asUint8Array
-getUint16Array :: ArrayGetter TA.Uint16Array
+getUint16Array :: ArrayGetter Uint16Array
 getUint16Array d n = getTypedArray d (n * 2) TA.asUint16Array
-getUint32Array :: ArrayGetter TA.Uint32Array
+getUint32Array :: ArrayGetter Uint32Array
 getUint32Array d n = getTypedArray d (n * 4) TA.asUint32Array
-getUint8ClampedArray :: ArrayGetter TA.Uint8ClampedArray
+getUint8ClampedArray :: ArrayGetter Uint8ClampedArray
 getUint8ClampedArray d n = getTypedArray d n TA.asUint8ClampedArray
-getFloat32Array :: ArrayGetter TA.Float32Array
+getFloat32Array :: ArrayGetter Float32Array
 getFloat32Array d n = getTypedArray d (n * 4) TA.asFloat32Array
-getFloat64Array :: ArrayGetter TA.Float64Array
+getFloat64Array :: ArrayGetter Float64Array
 getFloat64Array d n = getTypedArray d (n * 8) TA.asFloat64Array
 
-deserializer :: AB.ArrayBuffer -> Eff (reader :: DV.Reader) Deserializer
+deserializer :: ArrayBuffer -> Eff (reader :: DV.Reader) Deserializer
 deserializer ab = return $ { dv : DV.whole ab, off : 0 }
 
 
-deserialized :: forall a. (Deserializer -> Eff (reader :: DV.Reader) (Either String a)) -> AB.ArrayBuffer -> Either String a
+deserialized :: forall a. (Deserializer -> Eff (reader :: DV.Reader) (Either String a)) -> ArrayBuffer -> Either String a
 deserialized f b = runRPure (do
           d <- deserializer b
           res <- f d

src/Data/ArrayBuffer/Serializer.purs

@@ -36,18 +36,18 @@ putFloat32 = putter 4 DV.setFloat32
 putFloat64 :: Putter Float64
 putFloat64 = putter 8 DV.setFloat64
 
-mapDataView :: ByteLength -> Serializer -> Eff (writer :: DV.Writer) (Maybe DV.DataView)
+mapDataView :: ByteLength -> Serializer -> Eff (writer :: DV.Writer) (Maybe DataView)
 mapDataView n s = do
   o <- advance n s
   return $ DV.slice o n (DV.buffer s.dv)
 
 serializer :: ByteLength -> Eff (writer :: DV.Writer) Serializer
 serializer l = return $ { dv : DV.whole $ AB.create l, off : 0 }
 
-close :: Serializer -> Eff (writer :: DV.Writer) AB.ArrayBuffer
+close :: Serializer -> Eff (writer :: DV.Writer) ArrayBuffer
 close s = return $ AB.slice 0 s.off (DV.buffer s.dv)
 
-serialized :: ByteLength -> (Serializer -> Eff (writer :: DV.Writer) Serializer) -> AB.ArrayBuffer
+serialized :: ByteLength -> (Serializer -> Eff (writer :: DV.Writer) Serializer) -> ArrayBuffer
 serialized n f = runWPure (serializer n >>= f >>= close)
 
 foreign import runWPure

src/Data/ArrayBuffer/Show.purs

@@ -1,22 +1,23 @@
 module Data.ArrayBuffer.Show where
-       
+
+import Data.ArrayBuffer.Types
 import qualified Data.ArrayBuffer as AB
 import qualified Data.ArrayBuffer.DataView as DV
 import qualified Data.ArrayBuffer.Typed as T
 
-instance showArrayView :: Show (T.ArrayView a) where
+instance showArrayView :: Show (ArrayView a) where
   show = showImpl
 
-instance showDataView :: Show DV.DataView where
+instance showDataView :: Show DataView where
   show = show <<< T.asInt8Array
 
-instance showArrayBuffer :: Show AB.ArrayBuffer where
+instance showArrayBuffer :: Show ArrayBuffer where
   show = show <<< DV.whole
 
 foreign import showImpl
 """
 function showImpl(a) {
   return require('util').inspect(a);
 }
-""" :: forall a. T.ArrayView a -> String
+""" :: forall a. ArrayView a -> String
 

src/Data/ArrayBuffer/Typed.purs

@@ -2,23 +2,10 @@
 module Data.ArrayBuffer.Typed where
 
 import Data.ArrayBuffer
-import Data.ArrayBuffer.DataView(DataView())
 import Data.Function
 import Data.Maybe
 import Data.ArrayBuffer.Types
 
-foreign import data ArrayView :: * -> *
-
-type Int8Array = ArrayView Int8
-type Int16Array = ArrayView Int16
-type Int32Array = ArrayView Int32
-type Uint8Array = ArrayView Uint8
-type Uint16Array = ArrayView Uint16
-type Uint32Array = ArrayView Uint32
-type Uint8ClampedArray = ArrayView Uint8Clamped
-type Float32Array = ArrayView Float32
-type Float64Array = ArrayView Float64 
-
 foreign import asInt8Array
 """
 function asInt8Array(v) {