{-# LANGUAGE BangPatterns, CPP, MultiParamTypeClasses, TypeFamilies, FlexibleContexts #-}
#if __GLASGOW_HASKELL__ >= 707
{-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}
#endif
#if __GLASGOW_HASKELL__ >= 706
{-# LANGUAGE PolyKinds #-}
#endif
{-# OPTIONS_HADDOCK hide #-}
module Data.Vector.Unboxed.Base (
MVector(..), IOVector, STVector, Vector(..), Unbox
) where
import qualified Data.Vector.Generic as G
import qualified Data.Vector.Generic.Mutable as M
import qualified Data.Vector.Primitive as P
import Control.Applicative (Const(..))
import Control.DeepSeq ( NFData(rnf)
#if MIN_VERSION_deepseq(1,4,3)
, NFData1(liftRnf)
#endif
)
import Control.Monad.Primitive
import Control.Monad ( liftM )
#if MIN_VERSION_base(4,8,0)
import Data.Functor.Identity
#endif
#if MIN_VERSION_base(4,9,0)
import Data.Functor.Compose
#endif
import Data.Word ( Word8, Word16, Word32, Word64 )
import Data.Int ( Int8, Int16, Int32, Int64 )
import Data.Complex
import Data.Monoid (Dual(..),Sum(..),Product(..),All(..),Any(..))
#if MIN_VERSION_base(4,8,0)
import Data.Monoid (Alt(..))
#endif
#if MIN_VERSION_base(4,9,0)
import Data.Semigroup (Min(..),Max(..),First(..),Last(..),WrappedMonoid(..),Arg(..))
#endif
#if !MIN_VERSION_base(4,8,0)
import Data.Word ( Word )
#endif
#if __GLASGOW_HASKELL__ >= 707
import Data.Typeable ( Typeable )
#else
import Data.Typeable ( Typeable1(..), Typeable2(..), mkTyConApp,
mkTyCon3
)
#endif
import Data.Data ( Data(..) )
import GHC.Exts ( Down(..) )
#define NOT_VECTOR_MODULE
#include "vector.h"
data family MVector s a
data family Vector a
type IOVector = MVector RealWorld
type STVector s = MVector s
type instance G.Mutable Vector = MVector
class (G.Vector Vector a, M.MVector MVector a) => Unbox a
instance NFData (Vector a) where rnf :: Vector a -> ()
rnf !Vector a
_ = ()
instance NFData (MVector s a) where rnf :: MVector s a -> ()
rnf !MVector s a
_ = ()
#if MIN_VERSION_deepseq(1,4,3)
instance NFData1 Vector where
liftRnf :: (a -> ()) -> Vector a -> ()
liftRnf _ !Vector a
_ = ()
instance NFData1 (MVector s) where
liftRnf :: (a -> ()) -> MVector s a -> ()
liftRnf _ !MVector s a
_ = ()
#endif
#if __GLASGOW_HASKELL__ >= 707
deriving instance Typeable Vector
deriving instance Typeable MVector
#else
vectorTyCon = mkTyCon3 "vector"
instance Typeable1 Vector where
typeOf1 _ = mkTyConApp (vectorTyCon "Data.Vector.Unboxed" "Vector") []
instance Typeable2 MVector where
typeOf2 _ = mkTyConApp (vectorTyCon "Data.Vector.Unboxed.Mutable" "MVector") []
#endif
instance (Data a, Unbox a) => Data (Vector a) where
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector a -> c (Vector a)
gfoldl = (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector a -> c (Vector a)
forall (v :: * -> *) a (c :: * -> *).
(Vector v a, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> v a -> c (v a)
G.gfoldl
toConstr :: Vector a -> Constr
toConstr _ = String -> Constr
G.mkVecConstr "Data.Vector.Unboxed.Vector"
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Vector a)
gunfold = (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Vector a)
forall (v :: * -> *) a (c :: * -> *).
(Vector v a, Data a) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (v a)
G.gunfold
dataTypeOf :: Vector a -> DataType
dataTypeOf _ = String -> DataType
G.mkVecType "Data.Vector.Unboxed.Vector"
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Vector a))
dataCast1 = (forall d. Data d => c (t d)) -> Maybe (c (Vector a))
forall (v :: * -> *) a (t :: * -> *) (c :: * -> *).
(Vector v a, Data a, Typeable v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (v a))
G.dataCast
newtype instance MVector s () = MV_Unit Int
newtype instance Vector () = V_Unit Int
instance Unbox ()
instance M.MVector MVector () where
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicOverlaps #-}
{-# INLINE basicUnsafeNew #-}
{-# INLINE basicInitialize #-}
{-# INLINE basicUnsafeRead #-}
{-# INLINE basicUnsafeWrite #-}
{-# INLINE basicClear #-}
{-# INLINE basicSet #-}
{-# INLINE basicUnsafeCopy #-}
{-# INLINE basicUnsafeGrow #-}
basicLength :: MVector s () -> Int
basicLength (MV_Unit n) = Int
n
basicUnsafeSlice :: Int -> Int -> MVector s () -> MVector s ()
basicUnsafeSlice _ m :: Int
m (MV_Unit _) = Int -> MVector s ()
forall s. Int -> MVector s ()
MV_Unit Int
m
basicOverlaps :: MVector s () -> MVector s () -> Bool
basicOverlaps _ _ = Bool
False
basicUnsafeNew :: Int -> m (MVector (PrimState m) ())
basicUnsafeNew n :: Int
n = MVector (PrimState m) () -> m (MVector (PrimState m) ())
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> MVector (PrimState m) ()
forall s. Int -> MVector s ()
MV_Unit Int
n)
basicInitialize :: MVector (PrimState m) () -> m ()
basicInitialize _ = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
basicUnsafeRead :: MVector (PrimState m) () -> Int -> m ()
basicUnsafeRead (MV_Unit _) _ = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
basicUnsafeWrite :: MVector (PrimState m) () -> Int -> () -> m ()
basicUnsafeWrite (MV_Unit _) _ () = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
basicClear :: MVector (PrimState m) () -> m ()
basicClear _ = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
basicSet :: MVector (PrimState m) () -> () -> m ()
basicSet (MV_Unit _) () = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
basicUnsafeCopy :: MVector (PrimState m) () -> MVector (PrimState m) () -> m ()
basicUnsafeCopy (MV_Unit _) (MV_Unit _) = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
basicUnsafeGrow :: MVector (PrimState m) () -> Int -> m (MVector (PrimState m) ())
basicUnsafeGrow (MV_Unit n) m :: Int
m = MVector (PrimState m) () -> m (MVector (PrimState m) ())
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector (PrimState m) () -> m (MVector (PrimState m) ()))
-> MVector (PrimState m) () -> m (MVector (PrimState m) ())
forall a b. (a -> b) -> a -> b
$ Int -> MVector (PrimState m) ()
forall s. Int -> MVector s ()
MV_Unit (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
m)
instance G.Vector Vector () where
{-# INLINE basicUnsafeFreeze #-}
basicUnsafeFreeze :: Mutable Vector (PrimState m) () -> m (Vector ())
basicUnsafeFreeze (MV_Unit n) = Vector () -> m (Vector ())
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector () -> m (Vector ())) -> Vector () -> m (Vector ())
forall a b. (a -> b) -> a -> b
$ Int -> Vector ()
V_Unit Int
n
{-# INLINE basicUnsafeThaw #-}
basicUnsafeThaw :: Vector () -> m (Mutable Vector (PrimState m) ())
basicUnsafeThaw (V_Unit n) = MVector (PrimState m) () -> m (Mutable Vector (PrimState m) ())
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector (PrimState m) () -> m (Mutable Vector (PrimState m) ()))
-> MVector (PrimState m) () -> m (Mutable Vector (PrimState m) ())
forall a b. (a -> b) -> a -> b
$ Int -> MVector (PrimState m) ()
forall s. Int -> MVector s ()
MV_Unit Int
n
{-# INLINE basicLength #-}
basicLength :: Vector () -> Int
basicLength (V_Unit n) = Int
n
{-# INLINE basicUnsafeSlice #-}
basicUnsafeSlice :: Int -> Int -> Vector () -> Vector ()
basicUnsafeSlice _ m :: Int
m (V_Unit _) = Int -> Vector ()
V_Unit Int
m
{-# INLINE basicUnsafeIndexM #-}
basicUnsafeIndexM :: Vector () -> Int -> m ()
basicUnsafeIndexM (V_Unit _) _ = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
{-# INLINE basicUnsafeCopy #-}
basicUnsafeCopy :: Mutable Vector (PrimState m) () -> Vector () -> m ()
basicUnsafeCopy (MV_Unit _) (V_Unit _) = () -> m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
{-# INLINE elemseq #-}
elemseq :: Vector () -> () -> b -> b
elemseq _ = () -> b -> b
forall a b. a -> b -> b
seq
#define primMVector(ty,con) \
instance M.MVector MVector ty where { \
{-# INLINE basicLength #-} \
; {-# INLINE basicUnsafeSlice #-} \
; {-# INLINE basicOverlaps #-} \
; {-# INLINE basicUnsafeNew #-} \
; {-# INLINE basicInitialize #-} \
; {-# INLINE basicUnsafeReplicate #-} \
; {-# INLINE basicUnsafeRead #-} \
; {-# INLINE basicUnsafeWrite #-} \
; {-# INLINE basicClear #-} \
; {-# INLINE basicSet #-} \
; {-# INLINE basicUnsafeCopy #-} \
; {-# INLINE basicUnsafeGrow #-} \
; basicLength (con v) = M.basicLength v \
; basicUnsafeSlice i n (con v) = con $ M.basicUnsafeSlice i n v \
; basicOverlaps (con v1) (con v2) = M.basicOverlaps v1 v2 \
; basicUnsafeNew n = con `liftM` M.basicUnsafeNew n \
; basicInitialize (con v) = M.basicInitialize v \
; basicUnsafeReplicate n x = con `liftM` M.basicUnsafeReplicate n x \
; basicUnsafeRead (con v) i = M.basicUnsafeRead v i \
; basicUnsafeWrite (con v) i x = M.basicUnsafeWrite v i x \
; basicClear (con v) = M.basicClear v \
; basicSet (con v) x = M.basicSet v x \
; basicUnsafeCopy (con v1) (con v2) = M.basicUnsafeCopy v1 v2 \
; basicUnsafeMove (con v1) (con v2) = M.basicUnsafeMove v1 v2 \
; basicUnsafeGrow (con v) n = con `liftM` M.basicUnsafeGrow v n }
#define primVector(ty,con,mcon) \
instance G.Vector Vector ty where { \
{-# INLINE basicUnsafeFreeze #-} \
; {-# INLINE basicUnsafeThaw #-} \
; {-# INLINE basicLength #-} \
; {-# INLINE basicUnsafeSlice #-} \
; {-# INLINE basicUnsafeIndexM #-} \
; {-# INLINE elemseq #-} \
; basicUnsafeFreeze (mcon v) = con `liftM` G.basicUnsafeFreeze v \
; basicUnsafeThaw (con v) = mcon `liftM` G.basicUnsafeThaw v \
; basicLength (con v) = G.basicLength v \
; basicUnsafeSlice i n (con v) = con $ G.basicUnsafeSlice i n v \
; basicUnsafeIndexM (con v) i = G.basicUnsafeIndexM v i \
; basicUnsafeCopy (mcon mv) (con v) = G.basicUnsafeCopy mv v \
; elemseq _ = seq }
newtype instance MVector s Int = MV_Int (P.MVector s Int)
newtype instance Vector Int = V_Int (P.Vector Int)
instance Unbox Int
primMVector(Int, MV_Int)
primVector(Int, V_Int, MV_Int)
newtype instance MVector s Int8 = MV_Int8 (P.MVector s Int8)
newtype instance Vector Int8 = V_Int8 (P.Vector Int8)
instance Unbox Int8
primMVector(Int8, MV_Int8)
primVector(Int8, V_Int8, MV_Int8)
newtype instance MVector s Int16 = MV_Int16 (P.MVector s Int16)
newtype instance Vector Int16 = V_Int16 (P.Vector Int16)
instance Unbox Int16
primMVector(Int16, MV_Int16)
primVector(Int16, V_Int16, MV_Int16)
newtype instance MVector s Int32 = MV_Int32 (P.MVector s Int32)
newtype instance Vector Int32 = V_Int32 (P.Vector Int32)
instance Unbox Int32
primMVector(Int32, MV_Int32)
primVector(Int32, V_Int32, MV_Int32)
newtype instance MVector s Int64 = MV_Int64 (P.MVector s Int64)
newtype instance Vector Int64 = V_Int64 (P.Vector Int64)
instance Unbox Int64
primMVector(Int64, MV_Int64)
primVector(Int64, V_Int64, MV_Int64)
newtype instance MVector s Word = MV_Word (P.MVector s Word)
newtype instance Vector Word = V_Word (P.Vector Word)
instance Unbox Word
primMVector(Word, MV_Word)
primVector(Word, V_Word, MV_Word)
newtype instance MVector s Word8 = MV_Word8 (P.MVector s Word8)
newtype instance Vector Word8 = V_Word8 (P.Vector Word8)
instance Unbox Word8
primMVector(Word8, MV_Word8)
primVector(Word8, V_Word8, MV_Word8)
newtype instance MVector s Word16 = MV_Word16 (P.MVector s Word16)
newtype instance Vector Word16 = V_Word16 (P.Vector Word16)
instance Unbox Word16
primMVector(Word16, MV_Word16)
primVector(Word16, V_Word16, MV_Word16)
newtype instance MVector s Word32 = MV_Word32 (P.MVector s Word32)
newtype instance Vector Word32 = V_Word32 (P.Vector Word32)
instance Unbox Word32
primMVector(Word32, MV_Word32)
primVector(Word32, V_Word32, MV_Word32)
newtype instance MVector s Word64 = MV_Word64 (P.MVector s Word64)
newtype instance Vector Word64 = V_Word64 (P.Vector Word64)
instance Unbox Word64
primMVector(Word64, MV_Word64)
primVector(Word64, V_Word64, MV_Word64)
newtype instance MVector s Float = MV_Float (P.MVector s Float)
newtype instance Vector Float = V_Float (P.Vector Float)
instance Unbox Float
primMVector(Float, MV_Float)
primVector(Float, V_Float, MV_Float)
newtype instance MVector s Double = MV_Double (P.MVector s Double)
newtype instance Vector Double = V_Double (P.Vector Double)
instance Unbox Double
primMVector(Double, MV_Double)
primVector(Double, V_Double, MV_Double)
newtype instance MVector s Char = MV_Char (P.MVector s Char)
newtype instance Vector Char = V_Char (P.Vector Char)
instance Unbox Char
primMVector(Char, MV_Char)
primVector(Char, V_Char, MV_Char)
fromBool :: Bool -> Word8
{-# INLINE fromBool #-}
fromBool :: Bool -> Word8
fromBool True = 1
fromBool False = 0
toBool :: Word8 -> Bool
{-# INLINE toBool #-}
toBool :: Word8 -> Bool
toBool 0 = Bool
False
toBool _ = Bool
True
newtype instance MVector s Bool = MV_Bool (P.MVector s Word8)
newtype instance Vector Bool = V_Bool (P.Vector Word8)
instance Unbox Bool
instance M.MVector MVector Bool where
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicOverlaps #-}
{-# INLINE basicUnsafeNew #-}
{-# INLINE basicInitialize #-}
{-# INLINE basicUnsafeReplicate #-}
{-# INLINE basicUnsafeRead #-}
{-# INLINE basicUnsafeWrite #-}
{-# INLINE basicClear #-}
{-# INLINE basicSet #-}
{-# INLINE basicUnsafeCopy #-}
{-# INLINE basicUnsafeGrow #-}
basicLength :: MVector s Bool -> Int
basicLength (MV_Bool v) = MVector s Word8 -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
M.basicLength MVector s Word8
v
basicUnsafeSlice :: Int -> Int -> MVector s Bool -> MVector s Bool
basicUnsafeSlice i :: Int
i n :: Int
n (MV_Bool v) = MVector s Word8 -> MVector s Bool
forall s. MVector s Word8 -> MVector s Bool
MV_Bool (MVector s Word8 -> MVector s Bool)
-> MVector s Word8 -> MVector s Bool
forall a b. (a -> b) -> a -> b
$ Int -> Int -> MVector s Word8 -> MVector s Word8
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice Int
i Int
n MVector s Word8
v
basicOverlaps :: MVector s Bool -> MVector s Bool -> Bool
basicOverlaps (MV_Bool v1) (MV_Bool v2) = MVector s Word8 -> MVector s Word8 -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s Word8
v1 MVector s Word8
v2
basicUnsafeNew :: Int -> m (MVector (PrimState m) Bool)
basicUnsafeNew n :: Int
n = MVector (PrimState m) Word8 -> MVector (PrimState m) Bool
forall s. MVector s Word8 -> MVector s Bool
MV_Bool (MVector (PrimState m) Word8 -> MVector (PrimState m) Bool)
-> m (MVector (PrimState m) Word8)
-> m (MVector (PrimState m) Bool)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Int -> m (MVector (PrimState m) Word8)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
M.basicUnsafeNew Int
n
basicInitialize :: MVector (PrimState m) Bool -> m ()
basicInitialize (MV_Bool v) = MVector (PrimState m) Word8 -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
M.basicInitialize MVector (PrimState m) Word8
v
basicUnsafeReplicate :: Int -> Bool -> m (MVector (PrimState m) Bool)
basicUnsafeReplicate n :: Int
n x :: Bool
x = MVector (PrimState m) Word8 -> MVector (PrimState m) Bool
forall s. MVector s Word8 -> MVector s Bool
MV_Bool (MVector (PrimState m) Word8 -> MVector (PrimState m) Bool)
-> m (MVector (PrimState m) Word8)
-> m (MVector (PrimState m) Bool)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Int -> Word8 -> m (MVector (PrimState m) Word8)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> a -> m (v (PrimState m) a)
M.basicUnsafeReplicate Int
n (Bool -> Word8
fromBool Bool
x)
basicUnsafeRead :: MVector (PrimState m) Bool -> Int -> m Bool
basicUnsafeRead (MV_Bool v) i :: Int
i = Word8 -> Bool
toBool (Word8 -> Bool) -> m Word8 -> m Bool
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` MVector (PrimState m) Word8 -> Int -> m Word8
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) Word8
v Int
i
basicUnsafeWrite :: MVector (PrimState m) Bool -> Int -> Bool -> m ()
basicUnsafeWrite (MV_Bool v) i :: Int
i x :: Bool
x = MVector (PrimState m) Word8 -> Int -> Word8 -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) Word8
v Int
i (Bool -> Word8
fromBool Bool
x)
basicClear :: MVector (PrimState m) Bool -> m ()
basicClear (MV_Bool v) = MVector (PrimState m) Word8 -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
M.basicClear MVector (PrimState m) Word8
v
basicSet :: MVector (PrimState m) Bool -> Bool -> m ()
basicSet (MV_Bool v) x :: Bool
x = MVector (PrimState m) Word8 -> Word8 -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> a -> m ()
M.basicSet MVector (PrimState m) Word8
v (Bool -> Word8
fromBool Bool
x)
basicUnsafeCopy :: MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m ()
basicUnsafeCopy (MV_Bool v1) (MV_Bool v2) = MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
M.basicUnsafeCopy MVector (PrimState m) Word8
v1 MVector (PrimState m) Word8
v2
basicUnsafeMove :: MVector (PrimState m) Bool -> MVector (PrimState m) Bool -> m ()
basicUnsafeMove (MV_Bool v1) (MV_Bool v2) = MVector (PrimState m) Word8 -> MVector (PrimState m) Word8 -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
M.basicUnsafeMove MVector (PrimState m) Word8
v1 MVector (PrimState m) Word8
v2
basicUnsafeGrow :: MVector (PrimState m) Bool -> Int -> m (MVector (PrimState m) Bool)
basicUnsafeGrow (MV_Bool v) n :: Int
n = MVector (PrimState m) Word8 -> MVector (PrimState m) Bool
forall s. MVector s Word8 -> MVector s Bool
MV_Bool (MVector (PrimState m) Word8 -> MVector (PrimState m) Bool)
-> m (MVector (PrimState m) Word8)
-> m (MVector (PrimState m) Bool)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` MVector (PrimState m) Word8
-> Int -> m (MVector (PrimState m) Word8)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m (v (PrimState m) a)
M.basicUnsafeGrow MVector (PrimState m) Word8
v Int
n
instance G.Vector Vector Bool where
{-# INLINE basicUnsafeFreeze #-}
{-# INLINE basicUnsafeThaw #-}
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicUnsafeIndexM #-}
{-# INLINE elemseq #-}
basicUnsafeFreeze :: Mutable Vector (PrimState m) Bool -> m (Vector Bool)
basicUnsafeFreeze (MV_Bool v) = Vector Word8 -> Vector Bool
V_Bool (Vector Word8 -> Vector Bool)
-> m (Vector Word8) -> m (Vector Bool)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Mutable Vector (PrimState m) Word8 -> m (Vector Word8)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> m (v a)
G.basicUnsafeFreeze Mutable Vector (PrimState m) Word8
MVector (PrimState m) Word8
v
basicUnsafeThaw :: Vector Bool -> m (Mutable Vector (PrimState m) Bool)
basicUnsafeThaw (V_Bool v) = MVector (PrimState m) Word8 -> MVector (PrimState m) Bool
forall s. MVector s Word8 -> MVector s Bool
MV_Bool (MVector (PrimState m) Word8 -> MVector (PrimState m) Bool)
-> m (MVector (PrimState m) Word8)
-> m (MVector (PrimState m) Bool)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Vector Word8 -> m (Mutable Vector (PrimState m) Word8)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
v a -> m (Mutable v (PrimState m) a)
G.basicUnsafeThaw Vector Word8
v
basicLength :: Vector Bool -> Int
basicLength (V_Bool v) = Vector Word8 -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
G.basicLength Vector Word8
v
basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool
basicUnsafeSlice i :: Int
i n :: Int
n (V_Bool v) = Vector Word8 -> Vector Bool
V_Bool (Vector Word8 -> Vector Bool) -> Vector Word8 -> Vector Bool
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Vector Word8 -> Vector Word8
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice Int
i Int
n Vector Word8
v
basicUnsafeIndexM :: Vector Bool -> Int -> m Bool
basicUnsafeIndexM (V_Bool v) i :: Int
i = Word8 -> Bool
toBool (Word8 -> Bool) -> m Word8 -> m Bool
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Vector Word8 -> Int -> m Word8
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector Word8
v Int
i
basicUnsafeCopy :: Mutable Vector (PrimState m) Bool -> Vector Bool -> m ()
basicUnsafeCopy (MV_Bool mv) (V_Bool v) = Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m ()
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> v a -> m ()
G.basicUnsafeCopy Mutable Vector (PrimState m) Word8
MVector (PrimState m) Word8
mv Vector Word8
v
elemseq :: Vector Bool -> Bool -> b -> b
elemseq _ = Bool -> b -> b
forall a b. a -> b -> b
seq
newtype instance MVector s (Complex a) = MV_Complex (MVector s (a,a))
newtype instance Vector (Complex a) = V_Complex (Vector (a,a))
instance (Unbox a) => Unbox (Complex a)
instance (Unbox a) => M.MVector MVector (Complex a) where
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicOverlaps #-}
{-# INLINE basicUnsafeNew #-}
{-# INLINE basicInitialize #-}
{-# INLINE basicUnsafeReplicate #-}
{-# INLINE basicUnsafeRead #-}
{-# INLINE basicUnsafeWrite #-}
{-# INLINE basicClear #-}
{-# INLINE basicSet #-}
{-# INLINE basicUnsafeCopy #-}
{-# INLINE basicUnsafeGrow #-}
basicLength :: MVector s (Complex a) -> Int
basicLength (MV_Complex v) = MVector s (a, a) -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
M.basicLength MVector s (a, a)
v
basicUnsafeSlice :: Int -> Int -> MVector s (Complex a) -> MVector s (Complex a)
basicUnsafeSlice i :: Int
i n :: Int
n (MV_Complex v) = MVector s (a, a) -> MVector s (Complex a)
forall s a. MVector s (a, a) -> MVector s (Complex a)
MV_Complex (MVector s (a, a) -> MVector s (Complex a))
-> MVector s (a, a) -> MVector s (Complex a)
forall a b. (a -> b) -> a -> b
$ Int -> Int -> MVector s (a, a) -> MVector s (a, a)
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice Int
i Int
n MVector s (a, a)
v
basicOverlaps :: MVector s (Complex a) -> MVector s (Complex a) -> Bool
basicOverlaps (MV_Complex v1) (MV_Complex v2) = MVector s (a, a) -> MVector s (a, a) -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s (a, a)
v1 MVector s (a, a)
v2
basicUnsafeNew :: Int -> m (MVector (PrimState m) (Complex a))
basicUnsafeNew n :: Int
n = MVector (PrimState m) (a, a) -> MVector (PrimState m) (Complex a)
forall s a. MVector s (a, a) -> MVector s (Complex a)
MV_Complex (MVector (PrimState m) (a, a) -> MVector (PrimState m) (Complex a))
-> m (MVector (PrimState m) (a, a))
-> m (MVector (PrimState m) (Complex a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Int -> m (MVector (PrimState m) (a, a))
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
M.basicUnsafeNew Int
n
basicInitialize :: MVector (PrimState m) (Complex a) -> m ()
basicInitialize (MV_Complex v) = MVector (PrimState m) (a, a) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
M.basicInitialize MVector (PrimState m) (a, a)
v
basicUnsafeReplicate :: Int -> Complex a -> m (MVector (PrimState m) (Complex a))
basicUnsafeReplicate n :: Int
n (x :: a
x :+ y :: a
y) = MVector (PrimState m) (a, a) -> MVector (PrimState m) (Complex a)
forall s a. MVector s (a, a) -> MVector s (Complex a)
MV_Complex (MVector (PrimState m) (a, a) -> MVector (PrimState m) (Complex a))
-> m (MVector (PrimState m) (a, a))
-> m (MVector (PrimState m) (Complex a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Int -> (a, a) -> m (MVector (PrimState m) (a, a))
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> a -> m (v (PrimState m) a)
M.basicUnsafeReplicate Int
n (a
x,a
y)
basicUnsafeRead :: MVector (PrimState m) (Complex a) -> Int -> m (Complex a)
basicUnsafeRead (MV_Complex v) i :: Int
i = (a -> a -> Complex a) -> (a, a) -> Complex a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> a -> Complex a
forall a. a -> a -> Complex a
(:+) ((a, a) -> Complex a) -> m (a, a) -> m (Complex a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` MVector (PrimState m) (a, a) -> Int -> m (a, a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) (a, a)
v Int
i
basicUnsafeWrite :: MVector (PrimState m) (Complex a) -> Int -> Complex a -> m ()
basicUnsafeWrite (MV_Complex v) i :: Int
i (x :: a
x :+ y :: a
y) = MVector (PrimState m) (a, a) -> Int -> (a, a) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) (a, a)
v Int
i (a
x,a
y)
basicClear :: MVector (PrimState m) (Complex a) -> m ()
basicClear (MV_Complex v) = MVector (PrimState m) (a, a) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
M.basicClear MVector (PrimState m) (a, a)
v
basicSet :: MVector (PrimState m) (Complex a) -> Complex a -> m ()
basicSet (MV_Complex v) (x :: a
x :+ y :: a
y) = MVector (PrimState m) (a, a) -> (a, a) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> a -> m ()
M.basicSet MVector (PrimState m) (a, a)
v (a
x,a
y)
basicUnsafeCopy :: MVector (PrimState m) (Complex a)
-> MVector (PrimState m) (Complex a) -> m ()
basicUnsafeCopy (MV_Complex v1) (MV_Complex v2) = MVector (PrimState m) (a, a)
-> MVector (PrimState m) (a, a) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
M.basicUnsafeCopy MVector (PrimState m) (a, a)
v1 MVector (PrimState m) (a, a)
v2
basicUnsafeMove :: MVector (PrimState m) (Complex a)
-> MVector (PrimState m) (Complex a) -> m ()
basicUnsafeMove (MV_Complex v1) (MV_Complex v2) = MVector (PrimState m) (a, a)
-> MVector (PrimState m) (a, a) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
M.basicUnsafeMove MVector (PrimState m) (a, a)
v1 MVector (PrimState m) (a, a)
v2
basicUnsafeGrow :: MVector (PrimState m) (Complex a)
-> Int -> m (MVector (PrimState m) (Complex a))
basicUnsafeGrow (MV_Complex v) n :: Int
n = MVector (PrimState m) (a, a) -> MVector (PrimState m) (Complex a)
forall s a. MVector s (a, a) -> MVector s (Complex a)
MV_Complex (MVector (PrimState m) (a, a) -> MVector (PrimState m) (Complex a))
-> m (MVector (PrimState m) (a, a))
-> m (MVector (PrimState m) (Complex a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` MVector (PrimState m) (a, a)
-> Int -> m (MVector (PrimState m) (a, a))
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m (v (PrimState m) a)
M.basicUnsafeGrow MVector (PrimState m) (a, a)
v Int
n
instance (Unbox a) => G.Vector Vector (Complex a) where
{-# INLINE basicUnsafeFreeze #-}
{-# INLINE basicUnsafeThaw #-}
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicUnsafeIndexM #-}
{-# INLINE elemseq #-}
basicUnsafeFreeze :: Mutable Vector (PrimState m) (Complex a) -> m (Vector (Complex a))
basicUnsafeFreeze (MV_Complex v) = Vector (a, a) -> Vector (Complex a)
forall a. Vector (a, a) -> Vector (Complex a)
V_Complex (Vector (a, a) -> Vector (Complex a))
-> m (Vector (a, a)) -> m (Vector (Complex a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Mutable Vector (PrimState m) (a, a) -> m (Vector (a, a))
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> m (v a)
G.basicUnsafeFreeze Mutable Vector (PrimState m) (a, a)
MVector (PrimState m) (a, a)
v
basicUnsafeThaw :: Vector (Complex a) -> m (Mutable Vector (PrimState m) (Complex a))
basicUnsafeThaw (V_Complex v) = MVector (PrimState m) (a, a) -> MVector (PrimState m) (Complex a)
forall s a. MVector s (a, a) -> MVector s (Complex a)
MV_Complex (MVector (PrimState m) (a, a) -> MVector (PrimState m) (Complex a))
-> m (MVector (PrimState m) (a, a))
-> m (MVector (PrimState m) (Complex a))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Vector (a, a) -> m (Mutable Vector (PrimState m) (a, a))
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
v a -> m (Mutable v (PrimState m) a)
G.basicUnsafeThaw Vector (a, a)
v
basicLength :: Vector (Complex a) -> Int
basicLength (V_Complex v) = Vector (a, a) -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
G.basicLength Vector (a, a)
v
basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a)
basicUnsafeSlice i :: Int
i n :: Int
n (V_Complex v) = Vector (a, a) -> Vector (Complex a)
forall a. Vector (a, a) -> Vector (Complex a)
V_Complex (Vector (a, a) -> Vector (Complex a))
-> Vector (a, a) -> Vector (Complex a)
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Vector (a, a) -> Vector (a, a)
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice Int
i Int
n Vector (a, a)
v
basicUnsafeIndexM :: Vector (Complex a) -> Int -> m (Complex a)
basicUnsafeIndexM (V_Complex v) i :: Int
i
= (a -> a -> Complex a) -> (a, a) -> Complex a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> a -> Complex a
forall a. a -> a -> Complex a
(:+) ((a, a) -> Complex a) -> m (a, a) -> m (Complex a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Vector (a, a) -> Int -> m (a, a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector (a, a)
v Int
i
basicUnsafeCopy :: Mutable Vector (PrimState m) (Complex a)
-> Vector (Complex a) -> m ()
basicUnsafeCopy (MV_Complex mv) (V_Complex v)
= Mutable Vector (PrimState m) (a, a) -> Vector (a, a) -> m ()
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> v a -> m ()
G.basicUnsafeCopy Mutable Vector (PrimState m) (a, a)
MVector (PrimState m) (a, a)
mv Vector (a, a)
v
elemseq :: Vector (Complex a) -> Complex a -> b -> b
elemseq _ (x :: a
x :+ y :: a
y) z :: b
z = Vector a -> a -> b -> b
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq (forall a. Vector a
forall a. HasCallStack => a
undefined :: Vector a) a
x
(b -> b) -> b -> b
forall a b. (a -> b) -> a -> b
$ Vector a -> a -> b -> b
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq (forall a. Vector a
forall a. HasCallStack => a
undefined :: Vector a) a
y b
z
#define newtypeMVector(inst_ctxt,inst_head,tyC,con) \
instance inst_ctxt => M.MVector MVector (inst_head) where { \
; {-# INLINE basicLength #-} \
; {-# INLINE basicUnsafeSlice #-} \
; {-# INLINE basicOverlaps #-} \
; {-# INLINE basicUnsafeNew #-} \
; {-# INLINE basicInitialize #-} \
; {-# INLINE basicUnsafeReplicate #-} \
; {-# INLINE basicUnsafeRead #-} \
; {-# INLINE basicUnsafeWrite #-} \
; {-# INLINE basicClear #-} \
; {-# INLINE basicSet #-} \
; {-# INLINE basicUnsafeCopy #-} \
; {-# INLINE basicUnsafeGrow #-} \
; basicLength (con v) = M.basicLength v \
; basicUnsafeSlice i n (con v) = con $ M.basicUnsafeSlice i n v \
; basicOverlaps (con v1) (con v2) = M.basicOverlaps v1 v2 \
; basicUnsafeNew n = con `liftM` M.basicUnsafeNew n \
; basicInitialize (con v) = M.basicInitialize v \
; basicUnsafeReplicate n (tyC x) = con `liftM` M.basicUnsafeReplicate n x \
; basicUnsafeRead (con v) i = tyC `liftM` M.basicUnsafeRead v i \
; basicUnsafeWrite (con v) i (tyC x) = M.basicUnsafeWrite v i x \
; basicClear (con v) = M.basicClear v \
; basicSet (con v) (tyC x) = M.basicSet v x \
; basicUnsafeCopy (con v1) (con v2) = M.basicUnsafeCopy v1 v2 \
; basicUnsafeMove (con v1) (con v2) = M.basicUnsafeMove v1 v2 \
; basicUnsafeGrow (con v) n = con `liftM` M.basicUnsafeGrow v n \
}
#define newtypeVector(inst_ctxt,inst_head,tyC,con,mcon) \
instance inst_ctxt => G.Vector Vector (inst_head) where { \
; {-# INLINE basicUnsafeFreeze #-} \
; {-# INLINE basicUnsafeThaw #-} \
; {-# INLINE basicLength #-} \
; {-# INLINE basicUnsafeSlice #-} \
; {-# INLINE basicUnsafeIndexM #-} \
; {-# INLINE elemseq #-} \
; basicUnsafeFreeze (mcon v) = con `liftM` G.basicUnsafeFreeze v \
; basicUnsafeThaw (con v) = mcon `liftM` G.basicUnsafeThaw v \
; basicLength (con v) = G.basicLength v \
; basicUnsafeSlice i n (con v) = con $ G.basicUnsafeSlice i n v \
; basicUnsafeIndexM (con v) i = tyC `liftM` G.basicUnsafeIndexM v i \
; basicUnsafeCopy (mcon mv) (con v) = G.basicUnsafeCopy mv v \
; elemseq _ (tyC a) = G.elemseq (undefined :: Vector a) a \
}
#define deriveNewtypeInstances(inst_ctxt,inst_head,rep,tyC,con,mcon) \
newtype instance MVector s (inst_head) = mcon (MVector s (rep)) ;\
newtype instance Vector (inst_head) = con (Vector (rep)) ;\
instance inst_ctxt => Unbox (inst_head) ;\
newtypeMVector(inst_ctxt, inst_head, tyC, mcon) ;\
newtypeVector(inst_ctxt, inst_head, tyC, con, mcon)
#if MIN_VERSION_base(4,8,0)
deriveNewtypeInstances(Unbox a, Identity a, a, Identity, V_Identity, MV_Identity)
#endif
deriveNewtypeInstances(Unbox a, Down a, a, Down, V_Down, MV_Down)
deriveNewtypeInstances(Unbox a, Dual a, a, Dual, V_Dual, MV_Dual)
deriveNewtypeInstances(Unbox a, Sum a, a, Sum, V_Sum, MV_Sum)
deriveNewtypeInstances(Unbox a, Product a, a, Product, V_Product, MV_Product)
#if MIN_VERSION_base(4,9,0)
deriveNewtypeInstances(Unbox a, Min a, a, Min, V_Min, MV_Min)
deriveNewtypeInstances(Unbox a, Max a, a, Max, V_Max, MV_Max)
deriveNewtypeInstances(Unbox a, First a, a, First, V_First, MV_First)
deriveNewtypeInstances(Unbox a, Last a, a, Last, V_Last, MV_Last)
deriveNewtypeInstances(Unbox a, WrappedMonoid a, a, WrapMonoid, V_WrappedMonoid, MV_WrappedMonoid)
newtype instance MVector s (Arg a b) = MV_Arg (MVector s (a,b))
newtype instance Vector (Arg a b) = V_Arg (Vector (a,b))
instance (Unbox a, Unbox b) => Unbox (Arg a b)
instance (Unbox a, Unbox b) => M.MVector MVector (Arg a b) where
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicOverlaps #-}
{-# INLINE basicUnsafeNew #-}
{-# INLINE basicInitialize #-}
{-# INLINE basicUnsafeReplicate #-}
{-# INLINE basicUnsafeRead #-}
{-# INLINE basicUnsafeWrite #-}
{-# INLINE basicClear #-}
{-# INLINE basicSet #-}
{-# INLINE basicUnsafeCopy #-}
{-# INLINE basicUnsafeGrow #-}
basicLength :: MVector s (Arg a b) -> Int
basicLength (MV_Arg v) = MVector s (a, b) -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
M.basicLength MVector s (a, b)
v
basicUnsafeSlice :: Int -> Int -> MVector s (Arg a b) -> MVector s (Arg a b)
basicUnsafeSlice i :: Int
i n :: Int
n (MV_Arg v) = MVector s (a, b) -> MVector s (Arg a b)
forall s a b. MVector s (a, b) -> MVector s (Arg a b)
MV_Arg (MVector s (a, b) -> MVector s (Arg a b))
-> MVector s (a, b) -> MVector s (Arg a b)
forall a b. (a -> b) -> a -> b
$ Int -> Int -> MVector s (a, b) -> MVector s (a, b)
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice Int
i Int
n MVector s (a, b)
v
basicOverlaps :: MVector s (Arg a b) -> MVector s (Arg a b) -> Bool
basicOverlaps (MV_Arg v1) (MV_Arg v2) = MVector s (a, b) -> MVector s (a, b) -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s (a, b)
v1 MVector s (a, b)
v2
basicUnsafeNew :: Int -> m (MVector (PrimState m) (Arg a b))
basicUnsafeNew n :: Int
n = MVector (PrimState m) (a, b) -> MVector (PrimState m) (Arg a b)
forall s a b. MVector s (a, b) -> MVector s (Arg a b)
MV_Arg (MVector (PrimState m) (a, b) -> MVector (PrimState m) (Arg a b))
-> m (MVector (PrimState m) (a, b))
-> m (MVector (PrimState m) (Arg a b))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Int -> m (MVector (PrimState m) (a, b))
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
M.basicUnsafeNew Int
n
basicInitialize :: MVector (PrimState m) (Arg a b) -> m ()
basicInitialize (MV_Arg v) = MVector (PrimState m) (a, b) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
M.basicInitialize MVector (PrimState m) (a, b)
v
basicUnsafeReplicate :: Int -> Arg a b -> m (MVector (PrimState m) (Arg a b))
basicUnsafeReplicate n :: Int
n (Arg x :: a
x y :: b
y) = MVector (PrimState m) (a, b) -> MVector (PrimState m) (Arg a b)
forall s a b. MVector s (a, b) -> MVector s (Arg a b)
MV_Arg (MVector (PrimState m) (a, b) -> MVector (PrimState m) (Arg a b))
-> m (MVector (PrimState m) (a, b))
-> m (MVector (PrimState m) (Arg a b))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Int -> (a, b) -> m (MVector (PrimState m) (a, b))
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> a -> m (v (PrimState m) a)
M.basicUnsafeReplicate Int
n (a
x,b
y)
basicUnsafeRead :: MVector (PrimState m) (Arg a b) -> Int -> m (Arg a b)
basicUnsafeRead (MV_Arg v) i :: Int
i = (a -> b -> Arg a b) -> (a, b) -> Arg a b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> b -> Arg a b
forall a b. a -> b -> Arg a b
Arg ((a, b) -> Arg a b) -> m (a, b) -> m (Arg a b)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` MVector (PrimState m) (a, b) -> Int -> m (a, b)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m a
M.basicUnsafeRead MVector (PrimState m) (a, b)
v Int
i
basicUnsafeWrite :: MVector (PrimState m) (Arg a b) -> Int -> Arg a b -> m ()
basicUnsafeWrite (MV_Arg v) i :: Int
i (Arg x :: a
x y :: b
y) = MVector (PrimState m) (a, b) -> Int -> (a, b) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> a -> m ()
M.basicUnsafeWrite MVector (PrimState m) (a, b)
v Int
i (a
x,b
y)
basicClear :: MVector (PrimState m) (Arg a b) -> m ()
basicClear (MV_Arg v) = MVector (PrimState m) (a, b) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
M.basicClear MVector (PrimState m) (a, b)
v
basicSet :: MVector (PrimState m) (Arg a b) -> Arg a b -> m ()
basicSet (MV_Arg v) (Arg x :: a
x y :: b
y) = MVector (PrimState m) (a, b) -> (a, b) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> a -> m ()
M.basicSet MVector (PrimState m) (a, b)
v (a
x,b
y)
basicUnsafeCopy :: MVector (PrimState m) (Arg a b)
-> MVector (PrimState m) (Arg a b) -> m ()
basicUnsafeCopy (MV_Arg v1) (MV_Arg v2) = MVector (PrimState m) (a, b)
-> MVector (PrimState m) (a, b) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
M.basicUnsafeCopy MVector (PrimState m) (a, b)
v1 MVector (PrimState m) (a, b)
v2
basicUnsafeMove :: MVector (PrimState m) (Arg a b)
-> MVector (PrimState m) (Arg a b) -> m ()
basicUnsafeMove (MV_Arg v1) (MV_Arg v2) = MVector (PrimState m) (a, b)
-> MVector (PrimState m) (a, b) -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
M.basicUnsafeMove MVector (PrimState m) (a, b)
v1 MVector (PrimState m) (a, b)
v2
basicUnsafeGrow :: MVector (PrimState m) (Arg a b)
-> Int -> m (MVector (PrimState m) (Arg a b))
basicUnsafeGrow (MV_Arg v) n :: Int
n = MVector (PrimState m) (a, b) -> MVector (PrimState m) (Arg a b)
forall s a b. MVector s (a, b) -> MVector s (Arg a b)
MV_Arg (MVector (PrimState m) (a, b) -> MVector (PrimState m) (Arg a b))
-> m (MVector (PrimState m) (a, b))
-> m (MVector (PrimState m) (Arg a b))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` MVector (PrimState m) (a, b)
-> Int -> m (MVector (PrimState m) (a, b))
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m (v (PrimState m) a)
M.basicUnsafeGrow MVector (PrimState m) (a, b)
v Int
n
instance (Unbox a, Unbox b) => G.Vector Vector (Arg a b) where
{-# INLINE basicUnsafeFreeze #-}
{-# INLINE basicUnsafeThaw #-}
{-# INLINE basicLength #-}
{-# INLINE basicUnsafeSlice #-}
{-# INLINE basicUnsafeIndexM #-}
{-# INLINE elemseq #-}
basicUnsafeFreeze :: Mutable Vector (PrimState m) (Arg a b) -> m (Vector (Arg a b))
basicUnsafeFreeze (MV_Arg v) = Vector (a, b) -> Vector (Arg a b)
forall a b. Vector (a, b) -> Vector (Arg a b)
V_Arg (Vector (a, b) -> Vector (Arg a b))
-> m (Vector (a, b)) -> m (Vector (Arg a b))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Mutable Vector (PrimState m) (a, b) -> m (Vector (a, b))
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> m (v a)
G.basicUnsafeFreeze Mutable Vector (PrimState m) (a, b)
MVector (PrimState m) (a, b)
v
basicUnsafeThaw :: Vector (Arg a b) -> m (Mutable Vector (PrimState m) (Arg a b))
basicUnsafeThaw (V_Arg v) = MVector (PrimState m) (a, b) -> MVector (PrimState m) (Arg a b)
forall s a b. MVector s (a, b) -> MVector s (Arg a b)
MV_Arg (MVector (PrimState m) (a, b) -> MVector (PrimState m) (Arg a b))
-> m (MVector (PrimState m) (a, b))
-> m (MVector (PrimState m) (Arg a b))
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Vector (a, b) -> m (Mutable Vector (PrimState m) (a, b))
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
v a -> m (Mutable v (PrimState m) a)
G.basicUnsafeThaw Vector (a, b)
v
basicLength :: Vector (Arg a b) -> Int
basicLength (V_Arg v) = Vector (a, b) -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
G.basicLength Vector (a, b)
v
basicUnsafeSlice :: Int -> Int -> Vector (Arg a b) -> Vector (Arg a b)
basicUnsafeSlice i :: Int
i n :: Int
n (V_Arg v) = Vector (a, b) -> Vector (Arg a b)
forall a b. Vector (a, b) -> Vector (Arg a b)
V_Arg (Vector (a, b) -> Vector (Arg a b))
-> Vector (a, b) -> Vector (Arg a b)
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Vector (a, b) -> Vector (a, b)
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice Int
i Int
n Vector (a, b)
v
basicUnsafeIndexM :: Vector (Arg a b) -> Int -> m (Arg a b)
basicUnsafeIndexM (V_Arg v) i :: Int
i = (a -> b -> Arg a b) -> (a, b) -> Arg a b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> b -> Arg a b
forall a b. a -> b -> Arg a b
Arg ((a, b) -> Arg a b) -> m (a, b) -> m (Arg a b)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
`liftM` Vector (a, b) -> Int -> m (a, b)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, Monad m) =>
v a -> Int -> m a
G.basicUnsafeIndexM Vector (a, b)
v Int
i
basicUnsafeCopy :: Mutable Vector (PrimState m) (Arg a b) -> Vector (Arg a b) -> m ()
basicUnsafeCopy (MV_Arg mv) (V_Arg v)
= Mutable Vector (PrimState m) (a, b) -> Vector (a, b) -> m ()
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> v a -> m ()
G.basicUnsafeCopy Mutable Vector (PrimState m) (a, b)
MVector (PrimState m) (a, b)
mv Vector (a, b)
v
elemseq :: Vector (Arg a b) -> Arg a b -> b -> b
elemseq _ (Arg x :: a
x y :: b
y) z :: b
z = Vector a -> a -> b -> b
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq (forall a. Vector a
forall a. HasCallStack => a
undefined :: Vector a) a
x
(b -> b) -> b -> b
forall a b. (a -> b) -> a -> b
$ Vector b -> b -> b -> b
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq (forall a. Vector a
forall a. HasCallStack => a
undefined :: Vector b) b
y b
z
#endif
deriveNewtypeInstances((), Any, Bool, Any, V_Any, MV_Any)
deriveNewtypeInstances((), All, Bool, All, V_All, MV_All)
deriveNewtypeInstances(Unbox a, Const a b, a, Const, V_Const, MV_Const)
#if MIN_VERSION_base(4,8,0)
deriveNewtypeInstances(Unbox (f a), Alt f a, f a, Alt, V_Alt, MV_Alt)
#endif
#if MIN_VERSION_base(4,9,0)
deriveNewtypeInstances(Unbox (f (g a)), Compose f g a, f (g a), Compose, V_Compose, MV_Compose)
#endif
#define DEFINE_INSTANCES
#include "unbox-tuple-instances"