{-# LANGUAGE CPP, Trustworthy #-}

module Text.EditDistance.ArrayUtilities (
    unsafeReadArray, unsafeWriteArray,
    unsafeReadArray', unsafeWriteArray',
    stringToArray
  ) where

import Control.Monad (forM_)
import Control.Monad.ST

import Data.Array.ST
import Data.Array.Base (unsafeRead, unsafeWrite)

#ifdef __GLASGOW_HASKELL__
import GHC.Arr (unsafeIndex)
#else
import Data.Ix (index)

{-# INLINE unsafeIndex #-}
unsafeIndex :: Ix i => (i, i) -> i -> Int
unsafeIndex = index
#endif


{-# INLINE unsafeReadArray #-}
unsafeReadArray :: (MArray a e m, Ix i) => a i e -> i -> m e
unsafeReadArray :: forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> i -> m e
unsafeReadArray a i e
marr i
i = do
    i -> m e
f <- a i e -> m (i -> m e)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i -> m e)
unsafeReadArray' a i e
marr
    i -> m e
f i
i

{-# INLINE unsafeWriteArray #-}
unsafeWriteArray :: (MArray a e m, Ix i) => a i e -> i -> e -> m ()
unsafeWriteArray :: forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> i -> e -> m ()
unsafeWriteArray a i e
marr i
i e
e = do
  i -> e -> m ()
f <- a i e -> m (i -> e -> m ())
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i -> e -> m ())
unsafeWriteArray' a i e
marr
  i -> e -> m ()
f i
i e
e


{-# INLINE unsafeReadArray' #-}
unsafeReadArray' :: (MArray a e m, Ix i) => a i e -> m (i -> m e)
unsafeReadArray' :: forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i -> m e)
unsafeReadArray' a i e
marr = do
    (i
l,i
u) <- a i e -> m (i, i)
forall i. Ix i => a i e -> m (i, i)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
    (i -> m e) -> m (i -> m e)
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ((i -> m e) -> m (i -> m e)) -> (i -> m e) -> m (i -> m e)
forall a b. (a -> b) -> a -> b
$ \i
i -> a i e -> Int -> m e
forall i. Ix i => a i e -> Int -> m e
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> m e
unsafeRead a i e
marr ((i, i) -> i -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (i
l,i
u) i
i)

{-# INLINE unsafeWriteArray' #-}
unsafeWriteArray' :: (MArray a e m, Ix i) => a i e -> m (i -> e -> m ())
unsafeWriteArray' :: forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i -> e -> m ())
unsafeWriteArray' a i e
marr = do
  (i
l,i
u) <- a i e -> m (i, i)
forall i. Ix i => a i e -> m (i, i)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i, i)
getBounds a i e
marr
  (i -> e -> m ()) -> m (i -> e -> m ())
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ((i -> e -> m ()) -> m (i -> e -> m ()))
-> (i -> e -> m ()) -> m (i -> e -> m ())
forall a b. (a -> b) -> a -> b
$ \i
i e
e -> a i e -> Int -> e -> m ()
forall i. Ix i => a i e -> Int -> e -> m ()
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> Int -> e -> m ()
unsafeWrite a i e
marr ((i, i) -> i -> Int
forall a. Ix a => (a, a) -> a -> Int
unsafeIndex (i
l,i
u) i
i) e
e

{-# INLINE stringToArray #-}
stringToArray :: String -> Int -> ST s (STUArray s Int Char)
stringToArray :: forall s. String -> Int -> ST s (STUArray s Int Char)
stringToArray String
str Int
str_len = do
    STUArray s Int Char
array <- (Int, Int) -> ST s (STUArray s Int Char)
forall i. Ix i => (i, i) -> ST s (STUArray s i Char)
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
(i, i) -> m (a i e)
newArray_ (Int
1, Int
str_len)
    Int -> Char -> ST s ()
write <- STUArray s Int Char -> ST s (Int -> Char -> ST s ())
forall (a :: * -> * -> *) e (m :: * -> *) i.
(MArray a e m, Ix i) =>
a i e -> m (i -> e -> m ())
unsafeWriteArray' STUArray s Int Char
array
    [(Int, Char)] -> ((Int, Char) -> ST s ()) -> ST s ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
t a -> (a -> m b) -> m ()
forM_ ([Int] -> String -> [(Int, Char)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
1..] String
str) ((Int -> Char -> ST s ()) -> (Int, Char) -> ST s ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int -> Char -> ST s ()
write)
    STUArray s Int Char -> ST s (STUArray s Int Char)
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return STUArray s Int Char
array

{-
showArray :: STUArray s (Int, Int) Int -> ST s String
showArray array = do
    ((il, jl), (iu, ju)) <- getBounds array
    flip (flip foldM "") [(i, j) | i <- [il..iu], j <- [jl.. ju]] $ \rest (i, j) -> do
        elt <- readArray array (i, j)
        return $ rest ++ show (i, j) ++ ": " ++ show elt ++ ", "
-}