Redesign

.gitignore

@@ -6,3 +6,4 @@ node_modules/
 .psci_modules/
 yarn-error.log
 yarn.lock
+generated-docs/

bower.json

@@ -16,10 +16,17 @@
     "purescript-arraybuffer-types": "^2.0.0",
     "purescript-maybe": "^4.0.0",
     "purescript-effect": "^2.0.0",
-    "purescript-uint": "^5.0.0"
+    "purescript-nullable": "^4.1.0",
+    "purescript-typelevel": "^4.0.0",
+    "purescript-parseint": "^1.1.0",
+    "purescript-uint": "^5.1.0",
+    "purescript-sized-vectors": "^3.1.0",
+    "purescript-float32": "^0.0.1"
   },
   "devDependencies": {
     "purescript-debug": "^4.0.0",
-    "purescript-quickcheck": "^5.0.0"
+    "purescript-quickcheck": "^5.0.0",
+    "purescript-partial": "^2.0.0",
+    "purescript-quickcheck-combinators": "^0.1.0"
   }
 }

src/Data/ArrayBuffer/ArrayBuffer.js

@@ -2,26 +2,14 @@
 
 // module Data.ArrayBuffer.ArrayBuffer
 
-exports.create = function(s) {
-  return function () {
+exports.emptyImpl = function empty (s) {
     return new ArrayBuffer(s);
-  };
 };
 
-exports.byteLength = function(a) {
-  return a.byteLength;
+exports.byteLength = function byteLength (a) {
+    return a.byteLength;
 };
 
-exports.sliceImpl = function(s, e, a) {
-  return function () {
-    return a.slice(s, e);
-  };
-};
-
-exports.fromArray = function(s) {
-  return (new Uint8Array(s)).buffer;
-};
-
-exports.fromIntArray = function(s) {
-  return (new Uint8Array(s)).buffer;
+exports.sliceImpl = function sliceImpl (a, ms, me) {
+    return me === null ? (ms === null ? a.slice() : a.slice(ms)) : a.slice(ms,me);
 };

src/Data/ArrayBuffer/ArrayBuffer.purs

@@ -1,29 +1,37 @@
-module Data.ArrayBuffer.ArrayBuffer ( create
-                                    , byteLength
-                                    , slice
-                                    , fromArray
-                                    , fromIntArray
-                                   ) where
+-- | This module represents the functional bindings to JavaScript's `ArrayBuffer`
+-- | objects. See [MDN's spec](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) for details.
+
+module Data.ArrayBuffer.ArrayBuffer
+  ( empty
+  , byteLength
+  , slice
+  ) where
 
 import Data.ArrayBuffer.Types (ArrayBuffer, ByteOffset, ByteLength)
 import Data.Function.Uncurried (Fn3, runFn3)
+import Data.Maybe (Maybe(..))
+import Data.Nullable (Nullable, notNull, null)
+import Data.Tuple (Tuple(..))
 import Effect (Effect)
+import Effect.Uncurried (EffectFn1, runEffectFn1)
+
+
+foreign import emptyImpl :: EffectFn1 ByteLength ArrayBuffer
 
 
 -- | Create an `ArrayBuffer` with the given capacity.
-foreign import create :: ByteLength -> Effect ArrayBuffer
+empty :: ByteLength -> Effect ArrayBuffer
+empty l = runEffectFn1 emptyImpl l
 
 -- | Represents the length of an `ArrayBuffer` in bytes.
 foreign import byteLength :: ArrayBuffer -> ByteLength
 
-foreign import sliceImpl :: Fn3 ByteOffset ByteOffset ArrayBuffer (Effect ArrayBuffer)
+foreign import sliceImpl :: Fn3 ArrayBuffer (Nullable ByteOffset) (Nullable ByteOffset) 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 -> Effect ArrayBuffer
-slice = runFn3 sliceImpl
-
--- | Convert an array into an `ArrayBuffer` representation.
-foreign import fromArray :: Array Number -> ArrayBuffer
-
--- | Convert an array into an `ArrayBuffer` representation.
-foreign import fromIntArray :: Array Int -> ArrayBuffer
+slice :: ArrayBuffer -> Maybe (Tuple ByteOffset (Maybe ByteOffset)) -> ArrayBuffer
+slice a mz = case mz of
+  Nothing -> runFn3 sliceImpl a null null
+  Just (Tuple s me) -> case me of
+    Nothing -> runFn3 sliceImpl a (notNull s) null
+    Just e -> runFn3 sliceImpl a (notNull s) (notNull e)

src/Data/ArrayBuffer/ArrayBuffer/Gen.purs

@@ -0,0 +1,13 @@
+module Data.ArrayBuffer.ArrayBuffer.Gen where
+
+import Control.Monad.Gen.Class (class MonadGen)
+import Data.ArrayBuffer.Typed (buffer)
+import Data.ArrayBuffer.Typed.Gen (genTypedArray, genUint8)
+import Data.ArrayBuffer.Types (ArrayBuffer, Uint8Array)
+import Prelude ((<$>))
+
+
+genArrayBuffer :: forall m
+                . MonadGen m
+               => m ArrayBuffer
+genArrayBuffer = buffer <$> (genTypedArray genUint8 :: m Uint8Array)

src/Data/ArrayBuffer/DataView.js

@@ -3,43 +3,41 @@
 // module Data.ArrayBuffer.DataView
 
 
-exports.whole = function(b) {
-  return new DataView(b);
-}
-
-exports.sliceImpl = function(just, nothing, s, l, b) {
-  return ((s + l)>>>0) <= b.byteLength ? just(new DataView(b, s, l)) : nothing;
-}
-
-exports.buffer = function(v) {
-  return v.buffer;
-}
-
-exports.byteOffset = function(v) {
-  return v.byteOffset;
-}
-
-exports.byteLength = function(v) {
-  return v.byteLength;
-}
-
-exports.getterImpl = function(just, nothing, s, l, e, v, o) {
-  return function() {
-    return ((o + l)>>>0) <= v.byteLength? just(v[s].call(v,o,e)) : nothing;
-  };
-}
-
-exports.setter = function(s) {
-  return function(e) {
-    return function(v) {
-      var f = v[s];
-      return function(n) {
-        return function(o) {
-            return function() {
-            f.call(v,o,n,e);
-          };
-        };
-      };
-    };
-  };
-}
+exports.whole = function whole (b) {
+    return new DataView(b);
+};
+
+exports.remainderImpl = function remainderImpl (b,i) {
+    return new DataView(b,i);
+};
+
+exports.partImpl = function partImpl (b,i,j) {
+    return new DataView(b,i,j);
+};
+
+exports.buffer = function buffer (v) {
+    return v.buffer;
+};
+
+exports.byteOffset = function byteOffset (v) {
+    return v.byteOffset;
+};
+
+exports.byteLength = function byteLength (v) {
+    return v.byteLength;
+};
+
+exports.getterImpl = function getterImpl (data, v, o) {
+    return ((o + data.bytesPerValue) >>> 0) <= v.byteLength
+        ? data.just (v[data.functionName].call(v,o,data.littleEndian))
+        : data.nothing;
+};
+
+exports.setterImpl = function setterImpl (data, v, o, n) {
+    if (((o + data.bytesPerValue) >>> 0) <= v.byteLength) {
+        v[data.functionName].call(v,o,n,data.littleEndian);
+        return true;
+    } else {
+        return false;
+    }
+};