#include "phases.h"
module Data.Vector.MVector.New (
New(..), run, unstream, transform, accum, update, reverse,
slice, init, tail, take, drop
) where
import qualified Data.Vector.MVector as MVector
import Data.Vector.MVector ( MVector, MVectorPure )
import Data.Vector.Fusion.Stream ( Stream, MStream )
import qualified Data.Vector.Fusion.Stream as Stream
import qualified Data.Vector.Fusion.Stream.Monadic as MStream
import Control.Monad ( liftM )
import Prelude hiding ( init, tail, take, drop, reverse, map, filter )
newtype New a = New (forall m mv. MVector mv m a => m (mv a))
run :: MVector mv m a => New a -> m (mv a)
run (New p) = p
apply :: (forall mv a. MVectorPure mv a => mv a -> mv a) -> New a -> New a
apply f (New p) = New (liftM f p)
modify :: New a -> (forall m mv. MVector mv m a => mv a -> m ()) -> New a
modify (New p) q = New (do { v <- p; q v; return v })
unstream :: Stream a -> New a
unstream s = 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)
slice :: New a -> Int -> Int -> New a
slice m i n = apply (\v -> MVector.slice v i n) m
init :: New a -> New a
init m = apply (\v -> MVector.slice v 0 (MVector.length v 1)) m
tail :: New a -> New a
tail m = apply (\v -> MVector.slice v 1 (MVector.length v 1)) m
take :: Int -> New a -> New a
take n m = apply (\v -> MVector.slice v 0 (min n (MVector.length v))) m
drop :: Int -> New a -> New a
drop n m = apply (\v -> MVector.slice v n (max 0 (MVector.length v n))) m
accum :: (a -> b -> a) -> New a -> Stream (Int, b) -> New a
accum f m s = modify m (\v -> MVector.accum f v s)
update :: New a -> Stream (Int, a) -> New a
update m s = modify m (\v -> MVector.update v s)
reverse :: New a -> New a
reverse m = modify m (MVector.reverse)