module ArrayCopy(extractSpan, extractSpanM, copySpan, saveSpan) where

import Data.Ix
import Data.Array.IArray
import Data.Array.MArray

-- for specialization:
import Data.Array.IO
import Data.Array.Unboxed
import Data.Word


extractSpan :: (IArray sa e, IArray da e, Ix i) =>
	        (i, i) -> sa i e -> da i e

extractSpanM :: (MArray sa e m, IArray da e, Ix i) =>
	        (i, i) -> sa i e -> m (da i e)

copySpan :: (MArray sa e m, MArray da e m, Ix i, Ix j) => 
	        (i, i) -> sa i e -> (j, j) -> da j e -> m ()

saveSpan :: (IArray sa e, MArray da e m, Ix i, Ix j) => 
	        (i, i) -> sa i e -> (j, j) -> da j e -> m ()


extractSpan r a = array r [(i, a!i) | i <- range r]

extractSpanM (r :: (i,i)) (a :: sa i e) =
    do (d :: sa i e) <- newArray_ r
       copySpan r a r d
       unsafeFreeze d

copySpan srcRange srcA destRange destA 
    | rangeSize srcRange == rangeSize destRange 
      = sequence_ [readArray srcA f >>= writeArray destA t
		   | (f,t) <- zip (range srcRange) (range destRange)]

saveSpan srcRange srcA destRange destA 
    | rangeSize srcRange == rangeSize destRange 
      = sequence_ [writeArray destA t (srcA ! f)
		   | (f,t) <- zip (range srcRange) (range destRange)]


{-# specialize 
    saveSpan :: (Int, Int) -> UArray Int Word8 -> (Int, Int)
                  -> IOUArray Int Word8 -> IO ()  #-}
{-# specialize 
    copySpan :: (Int, Int) -> IOUArray Int Word8 -> (Int, Int)
                  -> IOUArray Int Word8 -> IO () #-}
{-# specialize 
    extractSpan :: (Int, Int) -> UArray Int Word8 -> UArray Int Word8 #-}
{-# specialize 
    extractSpanM :: (Int, Int) -> IOUArray Int Word8 -> IO (UArray Int Word8) #-}