module Data.Vector.Generic.New (
New(..), run, unstream, transform, unstreamR, transformR,
accum, update, reverse,
slice, init, tail, take, drop,
unsafeSlice, unsafeInit, unsafeTail,
unsafeAccum, unsafeUpdate
) where
import qualified Data.Vector.Generic.Mutable as MVector
import Data.Vector.Generic.Mutable ( MVector )
import Data.Vector.Fusion.Stream ( Stream, MStream )
import qualified Data.Vector.Fusion.Stream as Stream
import Control.Monad.ST ( ST )
import Control.Monad ( liftM )
import Prelude hiding ( init, tail, take, drop, reverse, map, filter )
#include "vector.h"
data New a = New (forall mv s. MVector mv a => ST s (mv s a))
run :: MVector mv a => New a -> ST s (mv s a)
run (New p) = p
apply :: (forall mv s a. MVector mv a => mv s a -> mv s a) -> New a -> New a
apply f (New p) = New (liftM f p)
modify :: New a -> (forall mv s. MVector mv a => mv s a -> ST s ()) -> New a
modify (New p) q = New (do { v <- p; q v; return v })
unstream :: Stream a -> New a
unstream s = s `seq` New (MVector.unstream s)
transform :: (forall m. Monad m => MStream m a -> MStream m a) -> New a -> New a
transform f (New p) = New (MVector.transform f =<< p)
unstreamR :: Stream a -> New a
unstreamR s = s `seq` New (MVector.unstreamR s)
transformR :: (forall m. Monad m => MStream m a -> MStream m a) -> New a -> New a
transformR f (New p) = New (MVector.transformR f =<< p)
slice :: Int -> Int -> New a -> New a
slice i n m = apply (MVector.slice i n) m
init :: New a -> New a
init m = apply MVector.init m
tail :: New a -> New a
tail m = apply MVector.tail m
take :: Int -> New a -> New a
take n m = apply (MVector.take n) m
drop :: Int -> New a -> New a
drop n m = apply (MVector.drop n) m
unsafeSlice :: Int -> Int -> New a -> New a
unsafeSlice i n m = apply (MVector.unsafeSlice i n) m
unsafeInit :: New a -> New a
unsafeInit m = apply MVector.unsafeInit m
unsafeTail :: New a -> New a
unsafeTail m = apply MVector.unsafeTail m
unsafeAccum :: (a -> b -> a) -> New a -> Stream (Int, b) -> New a
unsafeAccum f m s = s `seq` modify m (\v -> MVector.unsafeAccum f v s)
accum :: (a -> b -> a) -> New a -> Stream (Int, b) -> New a
accum f m s = s `seq` modify m (\v -> MVector.accum f v s)
unsafeUpdate :: New a -> Stream (Int, a) -> New a
unsafeUpdate m s = s `seq` modify m (\v -> MVector.unsafeUpdate v s)
update :: New a -> Stream (Int, a) -> New a
update m s = s `seq` modify m (\v -> MVector.update v s)
reverse :: New a -> New a
reverse m = modify m (MVector.reverse)