Shorten ST names, put STArray arguments at the end

Author: garyb

src/Data/Array.purs

@@ -128,7 +128,7 @@ import Data.Foldable (foldl, foldr, foldMap, fold, intercalate, elem, notElem, f
 import Data.Maybe (Maybe(..), maybe, isJust, fromJust)
 import Data.Traversable (scanl, scanr) as Exports
 import Data.Traversable (sequence, traverse)
-import Data.Tuple (Tuple(..), uncurry)
+import Data.Tuple (Tuple(..))
 import Data.Unfoldable (class Unfoldable, unfoldr)
 import Partial.Unsafe (unsafePartial)
 import Unsafe.Coerce (unsafeCoerce)
@@ -658,7 +658,7 @@ mapWithIndex f xs =
 -- |
 updateAtIndices :: forall t a. Foldable t => t (Tuple Int a) -> Array a -> Array a
 updateAtIndices us xs =
-  ST.run (STA.withArray (\res -> traverse_ (uncurry $ STA.pokeSTArray res) us) xs)
+  ST.run (STA.withArray (\res -> traverse_ (\(Tuple i a) -> STA.poke i a res) us) xs)
 
 -- | Apply a function to the element at the specified indices,
 -- | creating a new array. Out-of-bounds indices will have no effect.
@@ -671,7 +671,7 @@ updateAtIndices us xs =
 -- |
 modifyAtIndices :: forall t a. Foldable t => t Int -> (a -> a) -> Array a -> Array a
 modifyAtIndices is f xs =
-  ST.run (STA.withArray (\res -> traverse_ (\i -> STA.modifySTArray res i f) is) xs)
+  ST.run (STA.withArray (\res -> traverse_ (\i -> STA.modify i f res) is) xs)
 
 --------------------------------------------------------------------------------
 -- Sorting ---------------------------------------------------------------------
@@ -860,14 +860,14 @@ group' = group <<< sort
 groupBy :: forall a. (a -> a -> Boolean) -> Array a -> Array (NonEmptyArray a)
 groupBy op xs =
   ST.run do
-    result <- STA.emptySTArray
+    result <- STA.empty
     iter <- STAI.iterator (xs !! _)
     STAI.iterate iter \x -> void do
-      sub <- STA.emptySTArray
+      sub <- STA.empty
       STAI.pushWhile (op x) iter sub
-      _ <- STA.pushSTArray sub x
+      _ <- STA.push x sub
       grp <- STA.unsafeFreeze sub
-      STA.pushSTArray result ((unsafeCoerce :: Array ~> NonEmptyArray) grp)
+      STA.push ((unsafeCoerce :: Array ~> NonEmptyArray) grp) result
     STA.unsafeFreeze result
 
 -- | Remove the duplicates from an array, creating a new array.
@@ -1035,12 +1035,12 @@ zip = zipWith Tuple
 unzip :: forall a b. Array (Tuple a b) -> Tuple (Array a) (Array b)
 unzip xs =
   ST.run do
-    fsts <- STA.emptySTArray
-    snds <- STA.emptySTArray
+    fsts <- STA.empty
+    snds <- STA.empty
     iter <- STAI.iterator (xs !! _)
     STAI.iterate iter \(Tuple fst snd) -> do
-      void $ STA.pushSTArray fsts fst
-      void $ STA.pushSTArray snds snd
+      void $ STA.push fst fsts
+      void $ STA.push snd snds
     fsts' <- STA.unsafeFreeze fsts
     snds' <- STA.unsafeFreeze snds
     pure $ Tuple fsts' snds'

src/Data/Array/ST.js

@@ -1,13 +1,13 @@
 "use strict";
 
-exports.emptySTArray = function () {
+exports.empty = function () {
   return [];
 };
 
-exports.peekSTArrayImpl = function (just) {
+exports.peekImpl = function (just) {
   return function (nothing) {
-    return function (xs) {
-      return function (i) {
+    return function (i) {
+      return function (xs) {
         return function () {
           return i >= 0 && i < xs.length ? just(xs[i]) : nothing;
         };
@@ -16,9 +16,9 @@ exports.peekSTArrayImpl = function (just) {
   };
 };
 
-exports.pokeSTArray = function (xs) {
-  return function (i) {
-    return function (a) {
+exports.poke = function (i) {
+  return function (a) {
+    return function (xs) {
       return function () {
         var ret = i >= 0 && i < xs.length;
         if (ret) xs[i] = a;
@@ -28,18 +28,18 @@ exports.pokeSTArray = function (xs) {
   };
 };
 
-exports.pushAllSTArray = function (xs) {
-  return function (as) {
+exports.pushAll = function (as) {
+  return function (xs) {
     return function () {
       return xs.push.apply(xs, as);
     };
   };
 };
 
-exports.spliceSTArray = function (xs) {
-  return function (i) {
-    return function (howMany) {
-      return function (bs) {
+exports.splice = function (i) {
+  return function (howMany) {
+    return function (bs) {
+      return function (xs) {
         return function () {
           return xs.splice.apply(xs, [i, howMany].concat(bs));
         };

src/Data/Array/ST.purs

@@ -6,13 +6,13 @@ module Data.Array.ST
   ( STArray(..)
   , Assoc
   , withArray
-  , emptySTArray
-  , peekSTArray
-  , pokeSTArray
-  , pushSTArray
-  , modifySTArray
-  , pushAllSTArray
-  , spliceSTArray
+  , empty
+  , peek
+  , poke
+  , push
+  , modify
+  , pushAll
+  , splice
   , freeze
   , thaw
   , unsafeFreeze
@@ -61,7 +61,7 @@ unsafeThaw :: forall h a. Array a -> ST h (STArray h a)
 unsafeThaw = pure <<< (unsafeCoerce :: Array a -> STArray h a)
 
 -- | Create an empty mutable array.
-foreign import emptySTArray :: forall h a. ST h (STArray h a)
+foreign import empty :: forall h a. ST h (STArray h a)
 
 -- | Create a mutable copy of an immutable array.
 thaw :: forall h a. Array a -> ST h (STArray h a)
@@ -74,59 +74,54 @@ freeze = copyImpl
 foreign import copyImpl :: forall h a b. a -> ST h b
 
 -- | Read the value at the specified index in a mutable array.
-peekSTArray
+peek
   :: forall h a
-   . STArray h a
-  -> Int
+   . Int
+  -> STArray h a
   -> ST h (Maybe a)
-peekSTArray = peekSTArrayImpl Just Nothing
+peek = peekImpl Just Nothing
 
-foreign import peekSTArrayImpl
+foreign import peekImpl
   :: forall h a r
    . (a -> r)
   -> r
-  -> STArray h a
   -> Int
+  -> STArray h a
   -> (ST h r)
 
 -- | Change the value at the specified index in a mutable array.
-foreign import pokeSTArray
-  :: forall h a
-   . STArray h a -> Int -> a -> ST h Boolean
+foreign import poke :: forall h a. Int -> a -> STArray h a -> ST h Boolean
 
 -- | Append an element to the end of a mutable array. Returns the new length of
 -- | the array.
-pushSTArray :: forall h a. STArray h a -> a -> ST h Int
-pushSTArray arr a = pushAllSTArray arr [a]
+push :: forall h a. a -> STArray h a -> ST h Int
+push a = pushAll [a]
 
 -- | Append the values in an immutable array to the end of a mutable array.
 -- | Returns the new length of the mutable array.
-foreign import pushAllSTArray
+foreign import pushAll
   :: forall h a
-   . STArray h a
-  -> Array a
+   . Array a
+  -> STArray h a
   -> ST h Int
 
 -- | Mutate the element at the specified index using the supplied function.
-modifySTArray :: forall h a. STArray h a -> Int -> (a -> a) -> ST h Boolean
-modifySTArray xs i f = do
-  entry <- peekSTArray xs i
+modify :: forall h a. Int -> (a -> a) -> STArray h a -> ST h Boolean
+modify i f xs = do
+  entry <- peek i xs
   case entry of
-    Just x  -> pokeSTArray xs i (f x)
+    Just x  -> poke i (f x) xs
     Nothing -> pure false
 
 -- | Remove and/or insert elements from/into a mutable array at the specified index.
-foreign import spliceSTArray
+foreign import splice
   :: forall h a
-   . STArray h a
-  -> Int
+   . Int
   -> Int
   -> Array a
+  -> STArray h a
   -> ST h (Array a)
 
 -- | Create an immutable copy of a mutable array, where each element
 -- | is labelled with its index in the original array.
-foreign import toAssocArray
-  :: forall h a
-   . STArray h a
-  -> ST h (Array (Assoc a))
+foreign import toAssocArray :: forall h a. STArray h a -> ST h (Array (Assoc a))

src/Data/Array/ST/Iterator.purs

@@ -14,7 +14,8 @@ import Control.Monad.ST (ST)
 import Control.Monad.ST as ST
 import Control.Monad.ST.Ref (STRef)
 import Control.Monad.ST.Ref as STRef
-import Data.Array.ST (STArray, pushSTArray)
+import Data.Array.ST (STArray)
+import Data.Array.ST as STA
 
 import Data.Maybe (Maybe(..), isNothing)
 
@@ -69,7 +70,7 @@ pushWhile p iter array = do
     mx <- peek iter
     case mx of
       Just x | p x -> do
-        _ <- pushSTArray array x
+        _ <- STA.push x array
         void $ next iter
       _ ->
         void $ STRef.write true break

src/Data/Array/ST/Partial.js

@@ -1,16 +1,16 @@
 "use strict";
 
-exports.peekSTArrayImpl = function (xs) {
-  return function (i) {
+exports.peekImpl = function (i) {
+  return function (xs) {
     return function () {
       return xs[i];
     };
   };
 };
 
-exports.pokeSTArrayImpl = function (xs) {
-  return function (i) {
-    return function (a) {
+exports.pokeImpl = function (i) {
+  return function (a) {
+    return function (xs) {
       return function () {
         xs[i] = a;
         return {};

src/Data/Array/ST/Partial.purs

@@ -3,38 +3,38 @@
 -- | This module is particularly helpful when performance is very important.
 
 module Data.Array.ST.Partial
-  ( peekSTArray
-  , pokeSTArray
+  ( peek
+  , poke
   ) where
 
 import Control.Monad.ST (ST)
 import Data.Array.ST (STArray)
 import Data.Unit (Unit)
 
 -- | Read the value at the specified index in a mutable array.
-peekSTArray
+peek
   :: forall h a
    . Partial
-  => STArray h a
-  -> Int
+  => Int
+  -> STArray h a
   -> ST h a
-peekSTArray = peekSTArrayImpl
+peek = peekImpl
 
-foreign import peekSTArrayImpl :: forall h a. STArray h a -> Int -> ST h a
+foreign import peekImpl :: forall h a. Int -> STArray h a -> ST h a
 
 -- | Change the value at the specified index in a mutable array.
-pokeSTArray
+poke
   :: forall h a
    . Partial
-  => STArray h a
-  -> Int
+  => Int
   -> a
+  -> STArray h a
   -> ST h Unit
-pokeSTArray = pokeSTArrayImpl
+poke = pokeImpl
 
-foreign import pokeSTArrayImpl
+foreign import pokeImpl
   :: forall h a
-   . STArray h a
-  -> Int
+   . Int
   -> a
+  -> STArray h a
   -> ST h Unit