fix|api: Zero-init FFI output slots; add calloca; Order type for sort

Add `calloca` (zero-initialised stack alloc via alloca+fillBytes) and
use it in infoFromArray2/22/3 so the imaginary-part output pointer is
always 0.0 for real-valued arrays instead of uninitialized stack garbage,
matching the Rust bindings' explicit zero-init pattern.

Replace Bool with a new Order (Asc | Desc) type in sort, sortIndex,
and sortByKey for clarity. Fix sumNaN/productNaN/allTrue docstrings to
use inputs that actually exercise the behaviour being documented.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: dmjio

src/ArrayFire/Algorithm.hs

@@ -66,7 +66,7 @@ sum x (fromIntegral -> n) = (x `op1` (\p a -> af_sum p a n))
 
 -- | Sum all of the elements in 'Array' along the specified dimension, using a default value for NaN
 --
--- >>> A.sumNaN (A.vector @Double 10 [1..]) 0 0.0
+-- >>> let nan = 0/0 in A.sumNaN (A.vector @Double 10 (nan : [1..])) 0 10.0
 -- ArrayFire Array
 -- [1 1 1 1]
 --   55.0000
@@ -100,7 +100,7 @@ product x (fromIntegral -> n) = (x `op1` (\p a -> af_product p a n))
 
 -- | Product all of the elements in 'Array' along the specified dimension, using a default value for NaN
 --
--- >>> A.productNaN (A.vector @Double 10 [1..]) 0 0.0
+-- >>> let nan = 0/0 in A.productNaN (A.vector @Double 10 (nan : [1..])) 0 2.0
 -- ArrayFire Array
 -- [1 1 1 1]
 -- 3628800.0000
@@ -150,10 +150,10 @@ max x (fromIntegral -> n) = x `op1` (\p a -> af_max p a n)
 
 -- | Find if all elements in an 'Array' are 'True' along a dimension
 --
--- >>> A.allTrue (A.vector @CBool 10 (repeat 0)) 0
+-- >>> A.allTrue (A.vector @CBool 10 (repeat 1)) 0
 -- ArrayFire Array
 -- [1 1 1 1]
---         0
+--         1
 allTrue
   :: AFType a
   => Array a
@@ -212,7 +212,7 @@ sumAll = (`infoFromArray2` af_sum_all)
 
 -- | Sum all elements in an 'Array' along all dimensions, using a default value for NaN
 --
--- >>> A.sumNaNAll (A.vector @Double 10 [1..]) 0.0
+-- >>> let nan = 0/0 in A.sumNaNAll (A.vector @Double 10 (nan : [1..])) 0.0
 -- (55.0,0.0)
 sumNaNAll
   :: (AFType a, Fractional a)
@@ -516,15 +516,15 @@ diff2 a (fromIntegral -> n) = a `op1` (\p x -> af_diff2 p x n)
 
 -- | Sort an Array along a specified dimension, specifying ordering of results (ascending / descending)
 --
--- >>> A.sort (A.vector @Double 4 [ 2,4,3,1 ]) 0 True
+-- >>> A.sort (A.vector @Double 4 [ 2,4,3,1 ]) 0 Asc
 -- ArrayFire Array
 -- [4 1 1 1]
 --     1.0000
 --     2.0000
 --     3.0000
 --     4.0000
 --
--- >>> A.sort (A.vector @Double 4 [ 2,4,3,1 ]) 0 False
+-- >>> A.sort (A.vector @Double 4 [ 2,4,3,1 ]) 0 Desc
 -- ArrayFire Array
 -- [4 1 1 1]
 --     4.0000
@@ -537,7 +537,7 @@ sort
   -- ^ Input array
   -> Int
   -- ^ Dimension along `sort` is performed
-  -> Bool
+  -> Order
   -- ^ Return results in ascending order
   -> Array a
   -- ^ Will contain sorted input
@@ -546,7 +546,7 @@ sort a (fromIntegral -> n) (fromIntegral . fromEnum -> b) =
 
 -- | Sort an 'Array' along a specified dimension, specifying ordering of results (ascending / descending), returns indices of sorted results
 --
--- >>> A.sortIndex (A.vector @Double 4 [3,2,1,4]) 0 True
+-- >>> A.sortIndex (A.vector @Double 4 [3,2,1,4]) 0 Asc
 -- (ArrayFire Array
 -- [4 1 1 1]
 --     1.0000
@@ -566,13 +566,18 @@ sortIndex
   -- ^ Input array
   -> Int
   -- ^ Dimension along `sortIndex` is performed
-  -> Bool
+  -> Order
   -- ^ Return results in ascending order
   -> (Array a, Array Word32)
   -- ^ Contains the sorted, contains indices for original input
 sortIndex a (fromIntegral -> n) (fromIntegral . fromEnum -> b) =
   a `op2p` (\p1 p2 p3 -> af_sort_index p1 p2 p3 n b)
 
+
+-- | Data type for expressing sort order
+data Order = Desc | Asc
+  deriving (Enum, Show, Eq)
+
 -- | Sort an 'Array' along a specified dimension by keys, specifying ordering of results (ascending / descending)
 --
 -- >>> A.sortByKey (A.vector @Double 4 [2,1,4,3]) (A.vector @Double 4 [10,9,8,7]) 0 True
@@ -597,7 +602,7 @@ sortByKey
   -- ^ Values input array
   -> Int
   -- ^ Dimension along which to perform the operation
-  -> Bool
+  -> Order
   -- ^ Return results in ascending order
   -> (Array a, Array a)
 sortByKey a1 a2 (fromIntegral -> n) (fromIntegral . fromEnum -> b) =

src/ArrayFire/FFI.hs

@@ -34,8 +34,16 @@ import Foreign.Storable
 import Foreign.Ptr
 import Foreign.C
 import Foreign.Marshal.Alloc
+import Foreign.Marshal.Utils (fillBytes)
 import System.IO.Unsafe
 
+-- | Like 'alloca' but zero-initialises the memory before handing the pointer
+-- to the continuation. Prevents uninitialized stack garbage from leaking into
+-- output scalars when the C function does not write the imaginary-part pointer
+-- for real-valued arrays (e.g. af_mean_all_weighted).
+calloca :: forall a b. Storable a => (Ptr a -> IO b) -> IO b
+calloca f = alloca $ \p -> fillBytes p 0 (sizeOf (undefined :: a)) >> f p
+
 foreign import ccall unsafe "af_cast"
     af_cast :: Ptr AFArray -> AFArray -> AFDtype -> IO AFErr
 
@@ -538,8 +546,8 @@ infoFromArray2
 infoFromArray2 (Array fptr1) op =
   unsafePerformIO . mask_ $ do
     withForeignPtr fptr1 $ \ptr1 ->
-      bracket (callocBytes (sizeOf (undefined :: a))) free $ \ptrInput1 ->
-        bracket (callocBytes (sizeOf (undefined :: b))) free $ \ptrInput2 -> do
+      calloca $ \ptrInput1 ->
+        calloca $ \ptrInput2 -> do
           throwAFError =<< op ptrInput1 ptrInput2 ptr1
           (,) <$> peek ptrInput1 <*> peek ptrInput2
 
@@ -556,8 +564,8 @@ infoFromArray22 (Array fptr1) (Array fptr2) op =
   unsafePerformIO . mask_ $ do
     withForeignPtr fptr1 $ \ptr1 ->
       withForeignPtr fptr2 $ \ptr2 ->
-        bracket (callocBytes (sizeOf (undefined :: a))) free $ \ptrInput1 ->
-          bracket (callocBytes (sizeOf (undefined :: b))) free $ \ptrInput2 -> do
+        calloca $ \ptrInput1 ->
+          calloca $ \ptrInput2 -> do
             throwAFError =<< op ptrInput1 ptrInput2 ptr1 ptr2
             (,) <$> peek ptrInput1 <*> peek ptrInput2
 
@@ -572,9 +580,9 @@ infoFromArray3
 infoFromArray3 (Array fptr1) op =
   unsafePerformIO . mask_ $
     withForeignPtr fptr1 $ \ptr1 ->
-      bracket (callocBytes (sizeOf (undefined :: a))) free $ \ptrInput1 ->
-        bracket (callocBytes (sizeOf (undefined :: b))) free $ \ptrInput2 ->
-          bracket (callocBytes (sizeOf (undefined :: c))) free $ \ptrInput3 -> do
+      calloca $ \ptrInput1 ->
+        calloca $ \ptrInput2 ->
+          calloca $ \ptrInput3 -> do
             throwAFError =<< op ptrInput1 ptrInput2 ptrInput3 ptr1
             (,,) <$> peek ptrInput1
                  <*> peek ptrInput2