Merge pull request #9 from sgronblo/make-arraybuffer-creation-effectful

Make ArrayBuffer creation effectful

Author: jacereda

bower.json

@@ -21,6 +21,7 @@
   },
   "devDependencies": {
     "purescript-debug": "^2.0.0",
-    "purescript-quickcheck": "^3.0.0"
+    "purescript-quickcheck": "^3.0.0",
+    "purescript-partial": "^1.2.0"
   }
 }

src/Data/ArrayBuffer/ArrayBuffer.js

@@ -3,26 +3,36 @@
 // module Data.ArrayBuffer.ArrayBuffer
 
 exports.create = function(s) {
-  return new ArrayBuffer(s);
+  return function () {
+    return new ArrayBuffer(s);
+  }
 }
 
 exports.byteLength = function(a) {
-  return a.byteLength;
+  return function () {
+    return a.byteLength;
+  }
 }
 
 exports.sliceImpl = function(s, e, a) {
-  return a.slice(s,e);
+  return function () {
+    return a.slice(s, e);
+  }
 }
 
 exports.fromArray = function(s) {
-  return (new Uint8Array(s)).buffer;
+  return function() {
+    return (new Uint8Array(s)).buffer;
+  }
 }
 
 exports.fromString = function(s) {
-  var l = s.length;
-  var ab = new ArrayBuffer(l * 2);
-  var a = new Uint16Array(ab);
-  for (var i = 0; i < l; i++)
-    a[i] = s.charCodeAt(i);
-  return ab;
+  return function() {
+    var l = s.length;
+    var ab = new ArrayBuffer(l * 2);
+    var a = new Uint16Array(ab);
+    for (var i = 0; i < l; i++)
+      a[i] = s.charCodeAt(i);
+    return ab;
+  }
 }

src/Data/ArrayBuffer/ArrayBuffer.purs

@@ -1,24 +1,31 @@
-module Data.ArrayBuffer.ArrayBuffer where
-
+module Data.ArrayBuffer.ArrayBuffer( ARRAYBUFFER()
+                                   , create
+                                   , byteLength
+                                   , slice
+                                   , fromArray
+                                   , fromString
+                                   ) where
+
+import Control.Monad.Eff (Eff)
 import Data.Function.Uncurried (Fn3, runFn3)
 import Data.ArrayBuffer.Types (ArrayBuffer, ByteOffset, ByteLength)
 
+foreign import data ARRAYBUFFER :: !
 
 -- | Create an `ArrayBuffer` with the given capacity.
-foreign import create :: ByteLength -> ArrayBuffer
+foreign import create :: forall e. ByteLength -> Eff (arrayBuffer :: ARRAYBUFFER | e) ArrayBuffer
 
 -- | Represents the length of an `ArrayBuffer` in bytes.
-foreign import byteLength :: ArrayBuffer -> ByteLength
+foreign import byteLength :: forall e. ArrayBuffer -> Eff (arrayBuffer :: ARRAYBUFFER | e) ByteLength
 
-foreign import sliceImpl :: Fn3 ByteOffset ByteOffset ArrayBuffer ArrayBuffer
+foreign import sliceImpl :: forall e. Fn3 ByteOffset ByteOffset ArrayBuffer (Eff (arrayBuffer :: ARRAYBUFFER | e) ArrayBuffer)
 
 -- | Returns a new `ArrayBuffer` whose contents are a copy of this ArrayBuffer's bytes from begin, inclusive, up to end, exclusive.
-slice :: ByteOffset -> ByteOffset -> ArrayBuffer -> ArrayBuffer
+slice :: forall e. ByteOffset -> ByteOffset -> ArrayBuffer -> Eff (arrayBuffer :: ARRAYBUFFER | e) ArrayBuffer
 slice = runFn3 sliceImpl
 
 -- | Convert an array into an `ArrayBuffer` representation.
-foreign import fromArray :: Array Number -> ArrayBuffer
+foreign import fromArray :: forall e. Array Number -> Eff (arrayBuffer :: ARRAYBUFFER | e) ArrayBuffer
 
 -- | Convert a string into an `ArrayBuffer` representation.
-foreign import fromString :: String -> ArrayBuffer
-
+foreign import fromString :: forall e. String -> Eff (arrayBuffer :: ARRAYBUFFER | e) ArrayBuffer

src/Data/ArrayBuffer/DataView.js

@@ -4,23 +4,33 @@
 
 
 exports.whole = function(b) {
-  return new DataView(b);
+  return function() {
+    return new DataView(b);
+  }
 }
 
 exports.sliceImpl = function(just, nothing, s, l, b) {
-  return s + l <= b.byteLength? just(new DataView(b, s, l)) : nothing;
+  return function() {
+    return s + l <= b.byteLength ? just(new DataView(b, s, l)) : nothing;
+  }
 }
 
 exports.buffer = function(v) {
-  return v.buffer;
+  return function() {
+    return v.buffer;
+  }
 }
 
 exports.byteOffset = function(v) {
-  return v.byteOffset;
+  return function() {
+    return v.byteOffset;
+  }
 }
 
 exports.byteLength = function(v) {
-  return v.byteLength;
+  return function() {
+    return v.byteLength;
+  }
 }
 
 exports.getterImpl = function(just, nothing, s, l, e, v, o) {

src/Data/ArrayBuffer/DataView.purs

@@ -1,6 +1,4 @@
-module Data.ArrayBuffer.DataView( READER()
-                                , WRITER()
-                                , whole
+module Data.ArrayBuffer.DataView( whole
                                 , slice
                                 , buffer
                                 , byteOffset
@@ -38,50 +36,47 @@ module Data.ArrayBuffer.DataView( READER()
                                 ) where
 
 import Prelude
+import Data.ArrayBuffer.ArrayBuffer (ARRAYBUFFER)
 import Data.ArrayBuffer.Types (ByteOffset, DataView, ByteLength, ArrayBuffer)
 import Data.Function.Uncurried (Fn5, Fn7, runFn5, runFn7)
 import Data.Maybe (Maybe(..))
 import Control.Monad.Eff (Eff)
 import Data.UInt (UInt)
 
 -- | Type for all fetching functions.
-type Getter r = forall e. DataView -> ByteOffset -> Eff (reader :: READER | e) (Maybe r)
+type Getter r = forall e. DataView -> ByteOffset -> Eff (arrayBuffer :: ARRAYBUFFER | e) (Maybe r)
 
 -- | Type for all storing functions.
-type Setter r = forall e. DataView -> r -> ByteOffset -> Eff (writer :: WRITER | e) Unit
+type Setter r = forall e. DataView -> r -> ByteOffset -> Eff (arrayBuffer :: ARRAYBUFFER | e) Unit
 
 -- | View mapping the whole `ArrayBuffer`.
-foreign import whole :: ArrayBuffer -> DataView
+foreign import whole :: forall e. ArrayBuffer -> Eff (arrayBuffer :: ARRAYBUFFER | e) DataView
 
-foreign import sliceImpl :: Fn5 (DataView -> Maybe DataView) (Maybe DataView) ByteOffset ByteLength ArrayBuffer (Maybe DataView)
+foreign import sliceImpl :: forall e. Fn5 (DataView -> Maybe DataView) (Maybe DataView) ByteOffset ByteLength ArrayBuffer (Eff (arrayBuffer :: ARRAYBUFFER | e) (Maybe DataView))
 
 -- | View mapping a region of the `ArrayBuffer`.
-slice :: ByteOffset -> ByteLength -> ArrayBuffer -> Maybe DataView
+slice :: forall e. ByteOffset -> ByteLength -> ArrayBuffer -> (Eff (arrayBuffer :: ARRAYBUFFER | e) (Maybe DataView))
 slice = runFn5 sliceImpl Just Nothing
 
 -- | `ArrayBuffer` being mapped by the view.
-foreign import buffer :: DataView -> ArrayBuffer
+foreign import buffer :: forall e. DataView -> Eff (arrayBuffer :: ARRAYBUFFER | e) ArrayBuffer
 
 -- | Represents the offset of this view from the start of its `ArrayBuffer`.
-foreign import byteOffset :: DataView -> ByteOffset
+foreign import byteOffset :: forall e. DataView -> Eff (arrayBuffer :: ARRAYBUFFER | e) ByteOffset
 
 -- | Represents the length of this view.
-foreign import byteLength :: DataView -> ByteLength
+foreign import byteLength :: forall e. DataView -> Eff (arrayBuffer :: ARRAYBUFFER | e) ByteLength
 
 
-foreign import data READER :: !
-
 type Endianness = Boolean
 
-foreign import getterImpl :: forall e r. Fn7 (r -> Maybe r) (Maybe r) String ByteLength Endianness DataView ByteOffset (Eff (reader :: READER | e) (Maybe r))
+foreign import getterImpl :: forall e r. Fn7 (r -> Maybe r) (Maybe r) String ByteLength Endianness DataView ByteOffset (Eff (arrayBuffer :: ARRAYBUFFER | e) (Maybe r))
 
-getter :: forall e r. String ->  ByteLength -> Endianness -> DataView -> ByteOffset -> Eff (reader :: READER | e) (Maybe r)
+getter :: forall e r. String ->  ByteLength -> Endianness -> DataView -> ByteOffset -> Eff (arrayBuffer :: ARRAYBUFFER | e) (Maybe r)
 getter = runFn7 getterImpl Just Nothing
 
 
-foreign import data WRITER :: !
-
-foreign import setter :: forall e r. String -> Endianness -> DataView -> r -> ByteOffset -> Eff (writer :: WRITER | e) Unit
+foreign import setter :: forall e r. String -> Endianness -> DataView -> r -> ByteOffset -> Eff (arrayBuffer :: ARRAYBUFFER | e) Unit
 
 
 -- | Fetch int8 value at a certain index in a `DataView`.
@@ -182,5 +177,4 @@ setFloat64be :: Setter Number
 setFloat64be = setter "setFloat64" false
 
 setFloat64le :: Setter Number
-setFloat64le = setter "setFloat64" true
-
+setFloat64le = setter "setFloat64" true

src/Data/ArrayBuffer/Typed.js

@@ -39,7 +39,9 @@ exports.asFloat64Array = function(v) {
 }
 
 exports.dataView = function(a) {
-  return a;
+  return function() {
+    return a;
+  }
 }
 
 exports.setImpl = function(ra, off, a) {
@@ -49,25 +51,33 @@ exports.setImpl = function(ra, off, a) {
 }
 
 exports.unsafeAtImpl = function(a, i) {
+  return function() {
    return a[i];
+  }
 }
 
 exports.hasIndexImpl = function(a, i) {
-  return i in a;
+  return function() {
+    return i in a;
+  }
 }
 
 exports.toArray = function(a) {
-  var l = a.length;
-  var ret = new Array(l);
-  for (var i = 0; i < l; i++)
-    ret[i] = a[i];
-  return ret;
+  return function() {
+    var l = a.length;
+    var ret = new Array(l);
+    for (var i = 0; i < l; i++)
+      ret[i] = a[i];
+    return ret;
+  }
 }
 
 exports.toIntArray = function(a) {
-  var l = a.length;
-  var ret = new Array(l);
-  for (var i = 0; i < l; i++)
-    ret[i] = a[i]|0;
-  return ret;
-}
+  return function() {
+    var l = a.length;
+    var ret = new Array(l);
+    for (var i = 0; i < l; i++)
+      ret[i] = a[i] | 0;
+    return ret;
+  }
+}

src/Data/ArrayBuffer/Typed.purs

@@ -1,5 +1,4 @@
-module Data.ArrayBuffer.Typed( Writer()
-                             , asInt8Array
+module Data.ArrayBuffer.Typed( asInt8Array
                              , asInt16Array
                              , asInt32Array
                              , asUint8Array
@@ -17,18 +16,16 @@ module Data.ArrayBuffer.Typed( Writer()
                              , toIntArray
                              ) where
 
-import Prelude (Unit, ($))
+import Control.Monad.Eff (Eff)
+import Data.ArrayBuffer.ArrayBuffer (ARRAYBUFFER)
 import Data.ArrayBuffer.Types (ArrayView, ByteOffset, DataView, Float64Array, Float32Array, Uint8ClampedArray, Uint32Array, Uint16Array, Uint8Array, Int32Array, Int16Array, Int8Array)
 import Data.Function.Uncurried (Fn2, Fn3, runFn2, runFn3)
 import Data.Maybe (Maybe(..))
-import Control.Monad.Eff (Eff)
-
-foreign import data Writer :: !
+import Prelude (Unit, ($), bind, pure)
 
 -- | Create typed int8 array viewing the buffer mapped by the `DataView`
 foreign import asInt8Array :: DataView -> Int8Array
 
-
 -- | Create typed int16 array viewing the buffer mapped by the `DataView`
 foreign import asInt16Array :: DataView -> Int16Array
 
@@ -54,36 +51,39 @@ foreign import asFloat32Array :: DataView -> Float32Array
 foreign import asFloat64Array :: DataView -> Float64Array
 
 -- | Interpret typed array as a `DataView`.
-foreign import dataView  :: forall a. ArrayView a -> DataView
+foreign import dataView  :: forall a e. ArrayView a -> Eff (arrayBuffer :: ARRAYBUFFER | e) DataView
 
-foreign import setImpl :: forall a e. Fn3 (ArrayView a) ByteOffset (ArrayView a) (Eff (writer :: Writer | e) Unit)
+foreign import setImpl :: forall a e. Fn3 (ArrayView a) ByteOffset (ArrayView a) (Eff (arrayBuffer :: ARRAYBUFFER | e) Unit)
 
 -- | Stores multiple values in the last typed array, reading input values from ther first typed array.
-set :: forall a e. ArrayView a -> ByteOffset -> ArrayView a -> Eff (writer :: Writer | e) Unit
+set :: forall a e. ArrayView a -> ByteOffset -> ArrayView a -> Eff (arrayBuffer :: ARRAYBUFFER | e) Unit
 set = runFn3 setImpl
 
-foreign import unsafeAtImpl :: forall a. Fn2 (ArrayView a) Int Number
+foreign import unsafeAtImpl :: forall a e. Fn2 (ArrayView a) Int (Eff (arrayBuffer :: ARRAYBUFFER | e) Number)
 
 -- | Fetch element at index.
-unsafeAt :: forall a. ArrayView a -> Int -> Number
+unsafeAt :: forall a e. ArrayView a -> Int -> Eff (arrayBuffer :: ARRAYBUFFER | e) Number
 unsafeAt = runFn2 unsafeAtImpl
 
-foreign import hasIndexImpl :: forall a. Fn2 (ArrayView a) Int Boolean
+foreign import hasIndexImpl :: forall a e. Fn2 (ArrayView a) Int (Eff (arrayBuffer :: ARRAYBUFFER | e) Boolean)
 
 -- | Determine if a certain index is valid.
-hasIndex :: forall a. ArrayView a -> Int -> Boolean
+hasIndex :: forall a e. ArrayView a -> Int -> Eff (arrayBuffer :: ARRAYBUFFER | e) Boolean
 hasIndex = runFn2 hasIndexImpl
 
 -- | Fetch element at index.
-at :: forall a. ArrayView a -> Int -> Maybe Number
-at a n = if a `hasIndex` n then
-           Just $ unsafeAt a n
-         else
-           Nothing
+at :: forall a e. ArrayView a -> Int -> Eff (arrayBuffer :: ARRAYBUFFER | e) (Maybe Number)
+at a n = do
+  indexExists <- a `hasIndex` n
+  if indexExists
+    then do
+      element <- unsafeAt a n
+      pure $ Just element
+    else
+      pure Nothing
 
 -- | Turn typed array into an array.
-foreign import toArray :: forall a. ArrayView a -> Array Number
+foreign import toArray :: forall a e. ArrayView a -> Eff (arrayBuffer :: ARRAYBUFFER | e) (Array Number)
 
 -- | Turn typed array into integer array.
-foreign import toIntArray :: forall a. ArrayView a -> Array Int
-
+foreign import toIntArray :: forall a e. ArrayView a -> Eff (arrayBuffer :: ARRAYBUFFER | e) (Array Int)