Refactoring

Author: jacereda

bower.json

@@ -11,7 +11,6 @@
     "output"
   ], 
   "devDependencies": {
-    "purescript-transformers": "*",
     "purescript-quickcheck": "*"
   }
 }

src/Data/ArrayBuffer.purs

@@ -1,12 +1,10 @@
 module Data.ArrayBuffer where
 
 import Data.Function
+import Data.ArrayBuffer.Types
 
 foreign import data ArrayBuffer :: *
 
-type ByteOffset = Number
-type ByteLength = Number
-
 instance showArrayBuffer :: Show ArrayBuffer where
   show = showImpl
 

src/Data/ArrayBuffer/DataView.purs

@@ -1,6 +1,6 @@
 module Data.ArrayBuffer.DataView where
 
-import Data.ArrayBuffer(ArrayBuffer(), ByteOffset(), ByteLength())
+import Data.ArrayBuffer(ArrayBuffer())
 import Data.ArrayBuffer.Types
 import Data.Function
 import Control.Monad.Eff
@@ -64,13 +64,13 @@ foreign import data Writer :: !
 foreign import setInt8
 """
 function setInt8(v) {
-  return function(o) {
-    return function(n) {
+  return function(n) {
+    return function(o) {
       return function() {
         v.setInt8(o, n);
       };
     };
   };
 }
-""" :: forall e. DataView -> ByteOffset -> Int8 -> Eff (writer :: Writer | e) Unit
+""" :: forall e. DataView -> Int8 -> ByteOffset -> Eff (writer :: Writer | e) Unit
 

src/Data/ArrayBuffer/Deserializer.purs

@@ -4,29 +4,17 @@ import Data.ArrayBuffer.Types
 import qualified Data.ArrayBuffer as AB
 import qualified Data.ArrayBuffer.DataView as DV
 import Data.Function
+import Data.ArrayBuffer.Advancer
 import Control.Monad.Eff
 
-foreign import advance
-"""
-function advance(d) {
-  return function(s) {
-    return function() {
-      d.off += s;
-    };
-  };
-}
-""" :: forall e. Deserializer -> AB.ByteOffset -> Eff (reader :: DV.Reader | e) Unit
-newtype Deserializer = Deserializer { dv :: DV.DataView, off :: AB.ByteOffset }
+type Deserializer = Advancer
 
 class IsDeserializable a where
   get :: forall e. Deserializer -> Eff (reader :: DV.Reader | e) a
 
 instance isDeserializableInt8 :: IsDeserializable Int8 where
-  get ds@(Deserializer d) = do
-    v <- DV.getInt8 d.dv d.off
-    advance ds 1
-    return v
+  get d = advance 1 d >>= DV.getInt8 d.dv
 
 deserializer :: forall e. AB.ArrayBuffer -> Eff (reader :: DV.Reader | e) Deserializer
-deserializer ab = return $ Deserializer { dv : DV.whole ab, off : 0 }
+deserializer ab = return $ { dv : DV.whole ab, off : 0 }
 

src/Data/ArrayBuffer/Serializer.purs

@@ -3,38 +3,26 @@ module Data.ArrayBuffer.Serializer where
 import Data.ArrayBuffer.Types
 import qualified Data.ArrayBuffer as AB
 import qualified Data.ArrayBuffer.DataView as DV
+import Data.ArrayBuffer.Advancer
 import Data.Function
 import Control.Monad.Eff
 
-foreign import advance
-"""
-function advance(d) {
-  return function(s) {
-    return function() {
-      d.off += s;
-    };
-  };
-}
-""" :: forall e. Serializer -> AB.ByteOffset -> Eff (writer :: DV.Writer | e) Unit
-
-newtype Serializer = Serializer { dv :: DV.DataView, off :: AB.ByteOffset }
+type Serializer = Advancer
 
 class IsSerializable a where
   put :: forall e. Serializer -> a -> Eff (writer :: DV.Writer | e) Unit
 
 instance isSerializableInt8 :: IsSerializable Int8 where
-  put ss@(Serializer s) v = do
-    DV.setInt8 s.dv s.off v
-    advance ss 1
+  put s v = advance 1 s >>= DV.setInt8 s.dv v
 
-serializer :: forall e. AB.ByteLength -> Eff (writer :: DV.Writer | e) Serializer
-serializer l = return $ Serializer { dv : DV.whole $ AB.create l, off : 0 }
+serializer :: forall e. ByteLength -> Eff (writer :: DV.Writer | e) Serializer
+serializer l = return $ { dv : DV.whole $ AB.create l, off : 0 }
 
 close :: Serializer -> forall e. Eff (writer :: DV.Writer | e) AB.ArrayBuffer
-close (Serializer s) = return $ AB.slice 0 s.off (DV.buffer s.dv)
+close s = return $ AB.slice 0 s.off (DV.buffer s.dv)
 
-serialized :: forall e. (Serializer -> Eff (writer :: DV.Writer | e) Unit) -> Eff (writer :: DV.Writer | e) AB.ArrayBuffer
-serialized f = do
-  s <- serializer 1000
+serialized :: forall e. ByteLength -> (Serializer -> Eff (writer :: DV.Writer | e) Unit) -> Eff (writer :: DV.Writer | e) AB.ArrayBuffer
+serialized n f = do
+  s <- serializer n
   f s
   close s

src/Data/ArrayBuffer/Types.purs

@@ -1,5 +1,9 @@
 module Data.ArrayBuffer.Types where
 
+type ByteOffset = Number
+type ByteLength = Number
+
+
 newtype Int8 = Int8 Number
 --newtype Uint8
 --newtype Uint8Clamped

test/Main.purs

@@ -12,7 +12,6 @@ import qualified Data.ArrayBuffer.Deserializer as D
 import Control.Monad.Eff
 import Control.Monad.Eff.Random
 import Control.Monad.Eff.Exception
-import Control.Monad.Trans
 import Math
 
 instance eqInt8 :: Eq Int8 where
@@ -122,14 +121,23 @@ main = do
      let i8 = TA.asInt8Array dv
      ((Just 2) == i8 `TA.at` 1) && (Nothing == i8 `TA.at` 4) && (Nothing == i8 `TA.at` (-1))
 
-  quickCheck serdes
+  quickCheck' 5000 serdes
 
-serdes :: M4I8 -> Boolean
-serdes v0 = forcePure $ do
-    a <- S.serialized $ \s -> S.put s v0
+serdes :: M4I8 -> M4I8 -> M4I8 -> M4I8 -> Boolean
+serdes m0 m1 m2 m3 = forcePure $ do
+    a <- S.serialized 256 $ \s -> do
+      let p = S.put s
+      p m0
+      p m1
+      p m2
+      p m3      
     d <- D.deserializer a
-    v1 <- D.get d
-    return $ v0 == v1
+    let g = D.get d
+    m0' <- g
+    m1' <- g
+    m2' <- g
+    m3' <- g
+    return $ m0 == m0' && m1 == m1' && m2 == m2' && m3 == m3'
 
 
 assert :: Boolean -> QC Unit