Cleanups from PR review

Author: Divesh-Otwani

src/Data/Array/Destination.hs

@@ -123,6 +123,7 @@ module Data.Array.Destination
   , mirror
   , fromFunction
   , fill
+  , dropEmpty
   )
   where
 
@@ -179,6 +180,14 @@ fill = Unsafe.toLinear2 unsafeFill
       else
         unsafeDupablePerformIO Prelude.$ MVector.write ds 0 a
 
+-- | @dropEmpty dest@ consumes and empty array and fails otherwise.
+dropEmpty :: HasCallStack => DArray a %1-> ()
+dropEmpty = Unsafe.toLinear unsafeDrop where
+  unsafeDrop :: DArray a -> ()
+  unsafeDrop (DArray ds)
+    | MVector.length ds > 0 = error "Destination.dropEmpty on non-empty array."
+    | otherwise = ()
+
 -- | @'split' n dest = (destl, destr)@ such as @destl@ has length @n@.
 --
 -- 'split' is total: if @n@ is larger than the length of @dest@, then

src/Data/Array/Polarized.hs

@@ -102,8 +102,8 @@ module Data.Array.Polarized
 import qualified Data.Array.Polarized.Pull.Internal as Pull
 import qualified Data.Array.Polarized.Pull as Pull
 import qualified Data.Array.Polarized.Push as Push
+import qualified Data.Foldable as NonLinear
 import Prelude.Linear
-import qualified Prelude
 import Data.Vector (Vector)
 
 -- DEVELOPER NOTE:
@@ -130,8 +130,7 @@ import Data.Vector (Vector)
 -- NOTE: this does NOT require allocation and can be in-lined.
 transfer :: Pull.Array a %1-> Push.Array a
 transfer (Pull.Array f n) =
-  Push.Array
-    (\k -> Prelude.foldl (\m i -> m <> (k (f i))) mempty [0..(n-1)])
+  Push.Array (\k -> NonLinear.foldMap' (\x -> k (f x)) [0..(n-1)])
 
 -- | This is a shortcut convenience function
 -- for @transfer . Pull.fromVector@.

src/Data/Array/Polarized/Push.hs

@@ -22,7 +22,6 @@ import qualified Data.Array.Destination as DArray
 import Data.Array.Destination (DArray)
 import Data.Vector (Vector)
 import qualified Prelude
-import qualified Unsafe.Linear as Unsafe
 import Prelude.Linear
 import GHC.Stack
 
@@ -64,7 +63,7 @@ alloc (Array k) = allocArrayWriter $ k singletonWriter where
 -- element is @x@.
 make :: HasCallStack => a -> Int -> Array a
 make x n
-  | n < 0 = error "Making negative length push array"
+  | n < 0 = error "Making a negative length push array"
   | otherwise = Array (\makeA -> mconcat $ Prelude.replicate n (makeA x))
 
 
@@ -110,13 +109,8 @@ addWriters (ArrayWriter k1 l1) (ArrayWriter k2 l2) =
     (\darr ->
       (DArray.split l1 darr) & \(darr1,darr2) -> consume (k1 darr1, k2 darr2))
     (l1+l2)
--- Remark. In order for the function above to work, consume must forcibly
--- evaluate both tuples. If it was lazy, then we might not actually perform
--- @k1@ or @k2@ and the unsafe IO won't get done. In general, this makes me
--- think we haven't spelled out the careful rules of what consuming functions
--- must follow so that we can release a safe API.
 
 emptyWriter :: ArrayWriter a
-emptyWriter = ArrayWriter (Unsafe.toLinear (const ())) 0
+emptyWriter = ArrayWriter DArray.dropEmpty 0
 -- Remark. @emptyWriter@ assumes we can split a destination array at 0.