(original) (raw)

{-# LANGUAGE BangPatterns #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeFamilyDependencies #-} {-# OPTIONS_HADDOCK hide #-}

module Data.Vector.Generic.Base ( Vector(..), Mutable ) where

import Data.Vector.Generic.Mutable.Base ( MVector ) import qualified Data.Vector.Generic.Mutable.Base as M import Data.Vector.Fusion.Util (Box(..), liftBox) import qualified Data.Primitive.Array as Prim import qualified Data.Primitive.SmallArray as Prim import qualified Data.Primitive.PrimArray as Prim

import Control.Monad.ST import Data.Kind (Type)

type family Mutable (v :: Type -> Type) = (mv :: Type -> Type -> Type) | mv -> v

type instance Mutable Prim.Array = Prim.MutableArray type instance Mutable Prim.SmallArray = Prim.SmallMutableArray type instance Mutable Prim.PrimArray = Prim.MutablePrimArray

class MVector (Mutable v) a => Vector v a where

basicUnsafeFreeze :: Mutable v s a -> ST s (v a)

basicUnsafeThaw :: v a -> ST s (Mutable v s a)

basicLength :: v a -> Int

basicUnsafeSlice :: Int -> Int -> v a -> v a

basicUnsafeIndexM :: v a -> Int -> Box a

basicUnsafeCopy :: Mutable v s a -> v a -> ST s ()

{-# INLINE basicUnsafeCopy #-} basicUnsafeCopy !Mutable v s a dst !v a src = Int -> ST s () do_copy Int 0 where !n :: Int n = v a -> Int forall (v :: * -> *) a. Vector v a => v a -> Int basicLength v a src

  do_copy :: Int -> ST s ()

do_copy Int i | Int i Int -> Int -> Bool forall a. Ord a => a -> a -> Bool < Int n = do a x <- Box a -> ST s a forall (m :: * -> *) a. Monad m => Box a -> m a liftBox (Box a -> ST s a) -> Box a -> ST s a forall a b. (a -> b) -> a -> b $ v a -> Int -> Box a forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a basicUnsafeIndexM v a src Int i Mutable v s a -> Int -> a -> ST s () forall s. Mutable v s a -> Int -> a -> ST s () forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int -> a -> ST s () M.basicUnsafeWrite Mutable v s a dst Int i a x Int -> ST s () do_copy (Int iInt -> Int -> Int forall a. Num a => a -> a -> a +Int 1) | Bool otherwise = () -> ST s () forall a. a -> ST s a forall (m :: * -> *) a. Monad m => a -> m a return ()

elemseq :: v a -> a -> b -> b

{-# INLINE elemseq #-} elemseq v a _ = \a _ b x -> b x

{-# MINIMAL basicUnsafeFreeze, basicUnsafeThaw, basicLength, basicUnsafeSlice, basicUnsafeIndexM #-}