@@ -251,8 +251,8 @@ newArray n@(I# n#) =
251251--
252252-- /Pre-release/
253253{-# INLINE putIndexUnsafe #-}
254−putIndexUnsafe :: forall m a. MonadIO m => Array a -> Int -> a -> m ()
255−putIndexUnsafe Array {..} i x =
254+putIndexUnsafe :: forall m a. MonadIO m => Int -> a -> Array a -> m ()
255+putIndexUnsafe i x Array {..} =
256256 liftIO
257257 $ IO
258258 $ \s# ->
@@ -268,14 +268,14 @@ invalidIndex label i =
268268-- | /O(1)/ Write the given element at the given index in the array.
269269-- Performs in-place mutation of the array.
270270--
271−-- >>> putIndex arr ix val = Array.modifyIndex arr ix (const (val, ()))
271+-- >>> putIndex ix val arr = Array.modifyIndex ix (const (val, ())) arr
272272--
273273-- /Pre-release/
274274{-# INLINE putIndex #-}
275−putIndex :: MonadIO m => Array a -> Int -> a -> m ()
276−putIndex arr@Array {..} i x =
275+putIndex :: MonadIO m => Int -> a -> Array a -> m ()
276+putIndex i x arr@Array {..} =
277277 if i >= 0 && i < arrLen
278− then putIndexUnsafe arr i x
278+ then putIndexUnsafe i x arr
279279 else invalidIndex "putIndex" i
280280
281281-- | Modify a given index of an array using a modifier function without checking
@@ -284,8 +284,8 @@ putIndex arr@Array {..} i x =
284284-- Unsafe because it does not check the bounds of the array.
285285--
286286-- /Pre-release/
287−modifyIndexUnsafe :: MonadIO m => Array a -> Int -> (a -> (a, b)) -> m b
288−modifyIndexUnsafe Array {..} i f = do
287+modifyIndexUnsafe :: MonadIO m => Int -> (a -> (a, b)) -> Array a -> m b
288+modifyIndexUnsafe i f Array {..} = do
289289 liftIO
290290 $ IO
291291 $ \s# ->
@@ -300,10 +300,10 @@ modifyIndexUnsafe Array {..} i f = do
300300-- | Modify a given index of an array using a modifier function.
301301--
302302-- /Pre-release/
303−modifyIndex :: MonadIO m => Array a -> Int -> (a -> (a, b)) -> m b
304−modifyIndex arr@Array {..} i f = do
303+modifyIndex :: MonadIO m => Int -> (a -> (a, b)) -> Array a -> m b
304+modifyIndex i f arr@Array {..} = do
305305 if i >= 0 && i < arrLen
306− then modifyIndexUnsafe arr i f
306+ then modifyIndexUnsafe i f arr
307307 else invalidIndex "modifyIndex" i
308308
309309-------------------------------------------------------------------------------
@@ -362,7 +362,7 @@ reallocWith label sizer reqSize arr = do
362362snocUnsafe :: MonadIO m => Array a -> a -> m (Array a)
363363snocUnsafe arr@Array {..} a = do
364364 assert (arrStart + arrLen < arrTrueLen) (return ())
365− putIndexUnsafe arr arrLen a
365+ putIndexUnsafe arrLen a arr
366366 return $ arr {arrLen = arrLen + 1}
367367
368368-- NOINLINE to move it out of the way and not pollute the instruction cache.
@@ -417,8 +417,8 @@ snoc = snocWith (* 2)
417417--
418418-- Unsafe because it does not check the bounds of the array.
419419{-# INLINE_NORMAL getIndexUnsafe #-}
420−getIndexUnsafe :: MonadIO m => Array a -> Int -> m a
421−getIndexUnsafe Array {..} n =
420+getIndexUnsafe :: MonadIO m => Int -> Array a -> m a
421+getIndexUnsafe n Array {..} =
422422 liftIO
423423 $ IO
424424 $ \s# ->
@@ -428,10 +428,10 @@ getIndexUnsafe Array {..} n =
428428-- | /O(1)/ Lookup the element at the given index. Index starts from 0.
429429--
430430{-# INLINE getIndex #-}
431−getIndex :: MonadIO m => Array a -> Int -> m a
432−getIndex arr@Array {..} i =
431+getIndex :: MonadIO m => Int -> Array a -> m a
432+getIndex i arr@Array {..} =
433433 if i >= 0 && i < arrLen
434− then getIndexUnsafe arr i
434+ then getIndexUnsafe i arr
435435 else invalidIndex "getIndex" i
436436
437437-------------------------------------------------------------------------------
@@ -484,7 +484,7 @@ getSlice index len arr@Array{..} =
484484-- /Pre-release/
485485{-# INLINE toList #-}
486486toList :: MonadIO m => Array a -> m [a]
487−toList arr@Array{..} = mapM (getIndexUnsafe arr) [0 .. (arrLen - 1)]
487+toList arr@Array{..} = mapM (`getIndexUnsafe` arr) [0 .. (arrLen - 1)]
488488
489489-- | Use the 'read' unfold instead.
490490--
@@ -494,7 +494,7 @@ toList arr@Array{..} = mapM (getIndexUnsafe arr) [0 .. (arrLen - 1)]
494494{-# INLINE_NORMAL toStreamD #-}
495495toStreamD :: MonadIO m => Array a -> D.Stream m a
496496toStreamD arr@Array{..} =
497− D.mapM (getIndexUnsafe arr) $ D.enumerateFromToIntegral 0 (arrLen - 1)
497+ D.mapM (`getIndexUnsafe` arr) $ D.enumerateFromToIntegral 0 (arrLen - 1)
498498
499499{-# INLINE toStreamK #-}
500500toStreamK :: MonadIO m => Array a -> K.Stream m a
@@ -505,7 +505,7 @@ toStreamK arr@Array{..} = K.unfoldrM step 0
505505 step i
506506 | i == arrLen = return Nothing
507507 | otherwise = do
508− x <- getIndexUnsafe arr i
508+ x <- getIndexUnsafe i arr
509509 return $ Just (x, i + 1)
510510
511511
@@ -563,7 +563,7 @@ producerWith liftio = Producer step inject extract
563563 step (arr, i)
564564 | assert (arrLen arr >= 0) (i == arrLen arr) = return D.Stop
565565 step (arr, i) = do
566− x <- liftio $ getIndexUnsafe arr i
566+ x <- liftio $ getIndexUnsafe i arr
567567 return $ D.Yield x (arr, i + 1)
568568
569569-- | Resumable unfold of an array.