Add fromVector: zero-copy Storable Vector → Array ingestion

Avoids the linked-list traversal and intermediate newArray allocation
of mkArray by pinning the vector's buffer and passing it directly to
af_create_array. Includes round-trip and dimension-mismatch tests.

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

Author: dmjio

src/ArrayFire/Array.hs

@@ -209,6 +209,46 @@ mkArray dims xs =
 
 -- af_err af_create_handle(af_array *arr, const unsigned ndims, const dim_t * const dims, const af_dtype type);
 
+-- | Constructs an 'Array' from a 'Storable' 'Vector', avoiding the intermediate list allocation of 'mkArray'.
+--
+-- The vector's pinned buffer is passed directly to @af_create_array@.
+-- Throws 'AFException' if the vector length does not match the product of the given dimensions.
+--
+-- >>> fromVector @Double [3] (Data.Vector.Storable.fromList [1,2,3])
+-- ArrayFire Array
+-- [3 1 1 1]
+--     1.0000
+--     2.0000
+--     3.0000
+fromVector
+  :: forall a
+   . AFType a
+  => [Int]
+  -- ^ Dimensions
+  -> Vector a
+  -- ^ Source storable vector
+  -> Array a
+{-# NOINLINE fromVector #-}
+fromVector dims vec =
+  unsafePerformIO . mask_ $ do
+    let size  = Prelude.product dims
+        ndims = fromIntegral (Prelude.length dims)
+        dType = afType (Proxy @a)
+    when (V.length vec /= size) $
+      throwIO $ AFException SizeError 203 $
+        "fromVector: dimension product " <> show size <>
+        " does not match vector length " <> show (V.length vec)
+    alloca $ \arrayPtr -> do
+      zeroOutArray arrayPtr
+      dimsPtr <- newArray (DimT . fromIntegral <$> dims)
+      onException
+        (V.unsafeWith vec $ \ptr -> do
+          throwAFError =<< af_create_array arrayPtr (castPtr ptr) ndims dimsPtr dType
+          free dimsPtr)
+        (free dimsPtr)
+      arr <- peek arrayPtr
+      Array <$> newForeignPtr af_release_array_finalizer arr
+
 -- | Copies an 'Array' to a new 'Array'
 --
 -- >>> copyArray (scalar @Double 10)

test/ArrayFire/ArraySpec.hs

@@ -168,3 +168,25 @@ spec =
       it "length of toVector matches getElements" $ do
         let arr = mkArray @Double [7, 13] (repeat 0)
         V.length (toVector arr) `shouldBe` getElements arr
+
+    describe "fromVector" $ do
+      it "round-trips a Double vector" $ do
+        let xs  = V.fromList [1..10 :: Double]
+            arr = fromVector @Double [10] xs
+        toVector arr `shouldBe` xs
+      it "round-trips an Int vector" $ do
+        let xs  = V.fromList [1..100 :: Int]
+            arr = fromVector @Int [100] xs
+        toVector arr `shouldBe` xs
+      it "round-trips a Complex Double vector" $ do
+        let xs  = V.fromList [1 :+ 2, 3 :+ 4 :: Complex Double]
+            arr = fromVector @(Complex Double) [2] xs
+        toVector arr `shouldBe` xs
+      it "produces the same result as mkArray" $ do
+        let xs  = [1..25 :: Double]
+            arr1 = mkArray @Double [5,5] xs
+            arr2 = fromVector @Double [5,5] (V.fromList xs)
+        arr2 `shouldBe` arr1
+      it "throws on dimension mismatch" $ do
+        let xs = V.fromList [1,2,3 :: Double]
+        evaluate (fromVector @Double [4] xs) `shouldThrow` anyException