@@ -701,12 +701,14 @@ toListFB c n Array{..} = go (unsafeForeignPtrToPtr aStart)
702 -- This should be safe as the array contents are guaranteed to be
702 -- This should be safe as the array contents are guaranteed to be
703 -- evaluated/written to before we peek at them.
703 -- evaluated/written to before we peek at them.
704 let !x = unsafeInlineIO $ do
705 let !x = unsafeInlineIO $ do
705 r <- peek p
706 r <- peek p
706 touchForeignPtr aStart
707 touchForeignPtr aStart
708 in c x (go (p `plusPtr` sizeOf (undefined :: a)))
709 in c x (go (p `plusPtr` sizeOf (undefined :: a)))
711+-- XXX Should be monadic
710-- | Convert an 'Array' into a list.
712-- | Convert an 'Array' into a list.
712-- @since 0.7.0
714-- @since 0.7.0
@@ -736,6 +738,9 @@ toStreamD Array{..} =
737 -- This should be safe as the array contents are guaranteed to be
739 -- This should be safe as the array contents are guaranteed to be
738 -- evaluated/written to before we peek at them.
740 -- evaluated/written to before we peek at them.
742+ -- XXX This may not be safe for mutable arrays.
739 let !x = unsafeInlineIO $ do
744 let !x = unsafeInlineIO $ do
740 r <- peek p
745 r <- peek p
741 touchForeignPtr aStart
746 touchForeignPtr aStart
@@ -753,6 +758,7 @@ toStreamK Array{..} =
753 go p | assert (p <= aEnd) (p == aEnd) = K.nil
758 go p | assert (p <= aEnd) (p == aEnd) = K.nil
754 | otherwise =
759 | otherwise =
755 -- See Note in toStreamD.
760 -- See Note in toStreamD.
761+ -- XXX May not be safe for mutable arrays.
756 let !x = unsafeInlineIO $ do
762 let !x = unsafeInlineIO $ do
757 r <- peek p
763 r <- peek p
758 touchForeignPtr aStart
764 touchForeignPtr aStart
@@ -776,6 +782,7 @@ toStreamDRev Array{..} =
776 step _ p | p < unsafeForeignPtrToPtr aStart = return D.Stop
782 step _ p | p < unsafeForeignPtrToPtr aStart = return D.Stop
777 step _ p = do
783 step _ p = do
778 -- See comments in toStreamD for why we use unsafeInlineIO
784 -- See comments in toStreamD for why we use unsafeInlineIO
779 let !x = unsafeInlineIO $ do
786 let !x = unsafeInlineIO $ do
780 r <- peek p
787 r <- peek p
781 touchForeignPtr aStart
788 touchForeignPtr aStart
@@ -792,6 +799,7 @@ toStreamKRev Array {..} =
793 go p | p < unsafeForeignPtrToPtr aStart = K.nil
800 go p | p < unsafeForeignPtrToPtr aStart = K.nil
794 | otherwise =
801 | otherwise =
795 let !x = unsafeInlineIO $ do
803 let !x = unsafeInlineIO $ do
796 r <- peek p
804 r <- peek p
797 touchForeignPtr aStart
805 touchForeignPtr aStart
@@ -802,13 +810,18 @@ toStreamKRev Array {..} =
802-- Folding
810-- Folding
803-------------------------------------------------------------------------------
811-------------------------------------------------------------------------------
813+-- XXX Need something like "Array m a" enforcing monadic action to avoid the
814+-- possibility of such APIs.
805-- | Strict left fold of an array.
816-- | Strict left fold of an array.
806{-# INLINE_NORMAL foldl' #-}
817{-# INLINE_NORMAL foldl' #-}
807foldl' :: forall a b. Storable a => (b -> a -> b) -> b -> Array a -> b
818foldl' :: forall a b. Storable a => (b -> a -> b) -> b -> Array a -> b
819+-- XXX Should be monadic
808foldl' f z arr = runIdentity $ D.foldl' f z $ toStreamD arr
820foldl' f z arr = runIdentity $ D.foldl' f z $ toStreamD arr
810-- | Right fold of an array.
822-- | Right fold of an array.
811{-# INLINE_NORMAL foldr #-}
823{-# INLINE_NORMAL foldr #-}
824+-- XXX Should be monadic
812foldr :: Storable a => (a -> b -> b) -> b -> Array a -> b
825foldr :: Storable a => (a -> b -> b) -> b -> Array a -> b
813foldr f z arr = runIdentity $ D.foldr f z $ toStreamD arr
826foldr f z arr = runIdentity $ D.foldr f z $ toStreamD arr