{-# OPTIONS_GHC -fno-warn-unticked-promoted-constructors #-}
module Data.Repa.Scalar.Product
        ( -- * Product type
          (:*:)         (..)
        , IsProdList    (..)
        , IsKeyValues   (..)

          -- * Selecting
        , Select        (..)

          -- * Discarding
        , Discard       (..)

          -- * Masking
        , Mask          (..)
        , Keep          (..)
        , Drop          (..))
where
import Data.Repa.Scalar.Singleton.Nat
import qualified Data.Vector.Unboxed            as U
import qualified Data.Vector.Generic            as G
import qualified Data.Vector.Generic.Mutable    as M


---------------------------------------------------------------------------------------------------
-- | A strict product type, written infix.
data a :*: b    
        = !a :*: !b             
        deriving ((a :*: b) -> (a :*: b) -> Bool
((a :*: b) -> (a :*: b) -> Bool)
-> ((a :*: b) -> (a :*: b) -> Bool) -> Eq (a :*: b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b. (Eq a, Eq b) => (a :*: b) -> (a :*: b) -> Bool
$c== :: forall a b. (Eq a, Eq b) => (a :*: b) -> (a :*: b) -> Bool
== :: (a :*: b) -> (a :*: b) -> Bool
$c/= :: forall a b. (Eq a, Eq b) => (a :*: b) -> (a :*: b) -> Bool
/= :: (a :*: b) -> (a :*: b) -> Bool
Eq, Int -> (a :*: b) -> ShowS
[a :*: b] -> ShowS
(a :*: b) -> String
(Int -> (a :*: b) -> ShowS)
-> ((a :*: b) -> String) -> ([a :*: b] -> ShowS) -> Show (a :*: b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b. (Show a, Show b) => Int -> (a :*: b) -> ShowS
forall a b. (Show a, Show b) => [a :*: b] -> ShowS
forall a b. (Show a, Show b) => (a :*: b) -> String
$cshowsPrec :: forall a b. (Show a, Show b) => Int -> (a :*: b) -> ShowS
showsPrec :: Int -> (a :*: b) -> ShowS
$cshow :: forall a b. (Show a, Show b) => (a :*: b) -> String
show :: (a :*: b) -> String
$cshowList :: forall a b. (Show a, Show b) => [a :*: b] -> ShowS
showList :: [a :*: b] -> ShowS
Show)

infixr :*:

instance Functor ((:*:) a) where
 fmap :: forall a b. (a -> b) -> (a :*: a) -> a :*: b
fmap a -> b
f ((:*:) a
x a
y) = a -> b -> a :*: b
forall a b. a -> b -> a :*: b
(:*:) a
x (a -> b
f a
y)


-- | Sequences of products that form a valid list, 
--   using () for the nil value.
class IsProdList p where
 --
 -- @
 -- isProdList (1 :*: 4 :*: 5)  ... no instance
 --
 -- isProdList (1 :*: 4 :*: ()) = True
 -- @
 --
 isProdList :: p -> Bool

instance IsProdList () where
 isProdList :: () -> Bool
isProdList ()
_ = Bool
True
 {-# INLINE isProdList #-}

instance IsProdList fs => IsProdList (f :*: fs) where
 isProdList :: (f :*: fs) -> Bool
isProdList (f
_ :*: fs
xs) = fs -> Bool
forall p. IsProdList p => p -> Bool
isProdList fs
xs
 {-# INLINE isProdList #-}


-- Key-value pairs---------------------------------------------------------------------------------
-- | Sequences of products and tuples that form hetrogeneous key-value pairs.
class IsKeyValues p where
 type Keys   p 
 type Values p 

 -- | Get a cons-list of all the keys.
 keys   :: p -> [Keys p]

 -- | Get a heterogeneous product-list of all the values.
 values :: p -> Values p


instance IsKeyValues (k, v) where
 type Keys   (k, v)     = k
 type Values (k, v)     = v

 keys :: (k, v) -> [Keys (k, v)]
keys   (k
k, v
_)          = [k
Keys (k, v)
k]
 {-# INLINE keys #-}

 values :: (k, v) -> Values (k, v)
values (k
_, v
v)          = v
Values (k, v)
v
 {-# INLINE values #-}


instance (IsKeyValues p, IsKeyValues ps, Keys p ~ Keys ps)
       => IsKeyValues (p :*: ps) where

 type Keys   (p :*: ps) = Keys p
 type Values (p :*: ps) = Values p :*: Values ps

 keys :: (p :*: ps) -> [Keys (p :*: ps)]
keys   (p
p :*: ps
ps)      = p -> [Keys p]
forall p. IsKeyValues p => p -> [Keys p]
keys p
p   [Keys ps] -> [Keys ps] -> [Keys ps]
forall a. [a] -> [a] -> [a]
++  ps -> [Keys ps]
forall p. IsKeyValues p => p -> [Keys p]
keys ps
ps
 {-# INLINE keys #-}

 values :: (p :*: ps) -> Values (p :*: ps)
values (p
p :*: ps
ps)      = p -> Values p
forall p. IsKeyValues p => p -> Values p
values p
p Values p -> Values ps -> Values p :*: Values ps
forall a b. a -> b -> a :*: b
:*: ps -> Values ps
forall p. IsKeyValues p => p -> Values p
values ps
ps
 {-# INLINE values #-}


---------------------------------------------------------------------------------------------------
class    IsProdList t
      => Select  (n :: N) t where
 type    Select'    n        t
 -- | Return the element with this index from a product list.
 select ::          Nat n -> t -> Select' n t


instance IsProdList ts
      => Select  Z    (t1 :*: ts) where
 type Select'    Z    (t1 :*: ts) = t1
 select :: Nat 'Z -> (t1 :*: ts) -> Select' 'Z (t1 :*: ts)
select       Nat 'Z
Zero    (t1
t1 :*: ts
_)  = t1
Select' 'Z (t1 :*: ts)
t1
 {-# INLINE select #-}


instance Select n ts
      => Select (S n) (t1 :*: ts) where
 type Select'   (S n) (t1 :*: ts) = Select' n ts
 select :: Nat ('S n) -> (t1 :*: ts) -> Select' ('S n) (t1 :*: ts)
select      (Succ Nat n1
n) (t1
_  :*: ts
xs) = Nat n1 -> ts -> Select' n1 ts
forall (n :: N) t. Select n t => Nat n -> t -> Select' n t
select  Nat n1
n ts
xs
 {-# INLINE select #-}


---------------------------------------------------------------------------------------------------
class    IsProdList t 
      => Discard (n :: N) t where
 type    Discard'   n        t
 -- | Discard the element with this index from a product list.
 discard ::         Nat n -> t -> Discard' n t


instance IsProdList ts 
      => Discard Z     (t1 :*: ts) where
 type Discard'   Z     (t1 :*: ts) = ts
 discard :: Nat 'Z -> (t1 :*: ts) -> Discard' 'Z (t1 :*: ts)
discard      Nat 'Z
Zero     (t1
_  :*: ts
xs) = ts
Discard' 'Z (t1 :*: ts)
xs
 {-# INLINE discard #-}


instance Discard n ts 
      => Discard (S n) (t1 :*: ts) where
 type Discard'   (S n) (t1 :*: ts) = t1 :*: Discard' n ts
 discard :: Nat ('S n) -> (t1 :*: ts) -> Discard' ('S n) (t1 :*: ts)
discard      (Succ Nat n1
n) (t1
x1 :*: ts
xs) = t1
x1 t1 -> Discard' n ts -> t1 :*: Discard' n ts
forall a b. a -> b -> a :*: b
:*: Nat n1 -> ts -> Discard' n1 ts
forall (n :: N) t. Discard n t => Nat n -> t -> Discard' n t
discard  Nat n1
n ts
xs
 {-# INLINE discard #-}


---------------------------------------------------------------------------------------------------
-- | Singleton to indicate a field that should be dropped.
data Drop = Drop

-- | Singleton to indicate a field that should be kept.
data Keep = Keep


-- | Class of data types that can have parts masked out.
class (IsProdList m, IsProdList t) => Mask  m t where
 type Mask' m t
 -- | Mask out some component of a type.
 --
 -- @  
 -- mask (Keep :*: Drop  :*: Keep :*: ()) 
 --      (1    :*: \"foo\" :*: \'a\'  :*: ())   =   (1 :*: \'a\' :*: ())
 --
 -- mask (Drop :*: Drop  :*: Drop :*: ()) 
 --      (1    :*: \"foo\" :*: \'a\'  :*: ())   =   ()
 -- @
 --
 mask :: m -> t -> Mask' m t


instance Mask () () where
 type Mask' ()   () = ()
 mask :: () -> () -> Mask' () ()
mask       ()   () = ()
 {-# INLINE mask #-}


instance Mask ms ts 
      => Mask (Keep :*: ms) (t1 :*: ts) where
 type Mask'   (Keep :*: ms) (t1 :*: ts) = t1 :*: Mask' ms ts
 mask :: (Keep :*: ms) -> (t1 :*: ts) -> Mask' (Keep :*: ms) (t1 :*: ts)
mask         (Keep
_    :*: ms
ms) (t1
x1 :*: ts
xs) = t1
x1 t1 -> Mask' ms ts -> t1 :*: Mask' ms ts
forall a b. a -> b -> a :*: b
:*: ms -> ts -> Mask' ms ts
forall m t. Mask m t => m -> t -> Mask' m t
mask  ms
ms ts
xs
 {-# INLINE mask #-}


instance Mask ms ts
      => Mask (Drop :*: ms) (t1 :*: ts) where
 type Mask'   (Drop :*: ms) (t1 :*: ts) = Mask' ms ts
 mask :: (Drop :*: ms) -> (t1 :*: ts) -> Mask' (Drop :*: ms) (t1 :*: ts)
mask         (Drop
_    :*: ms
ms) (t1
_  :*: ts
xs) = ms -> ts -> Mask' ms ts
forall m t. Mask m t => m -> t -> Mask' m t
mask  ms
ms ts
xs
 {-# INLINE mask #-}


-- Unboxed ----------------------------------------------------------------------------------------
-- Unboxed instance adapted from:
-- http://code.haskell.org/vector/internal/unbox-tuple-instances
--
data instance U.Vector (a :*: b)
  = V_Prod 
        {-# UNPACK #-} !Int 
        !(U.Vector a)
        !(U.Vector b)


instance (U.Unbox a, U.Unbox b) 
       => U.Unbox (a :*: b)


data instance U.MVector s (a :*: b)
  = MV_Prod {-# UNPACK #-} !Int 
        !(U.MVector s a)
        !(U.MVector s b)


instance (U.Unbox a, U.Unbox b) 
      => M.MVector U.MVector (a :*: b) where

  basicLength :: forall s. MVector s (a :*: b) -> Int
basicLength (MV_Prod Int
n_ MVector s a
_as MVector s b
_bs) = Int
n_
  {-# INLINE basicLength  #-}

  basicUnsafeSlice :: forall s. Int -> Int -> MVector s (a :*: b) -> MVector s (a :*: b)
basicUnsafeSlice Int
i_ Int
m_ (MV_Prod Int
_n_ MVector s a
as MVector s b
bs)
   = Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
forall s a b.
Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
MV_Prod Int
m_ (Int -> Int -> MVector s a -> MVector s a
forall s. Int -> Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice Int
i_ Int
m_ MVector s a
as)
                (Int -> Int -> MVector s b -> MVector s b
forall s. Int -> Int -> MVector s b -> MVector s b
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
M.basicUnsafeSlice Int
i_ Int
m_ MVector s b
bs)
  {-# INLINE basicUnsafeSlice  #-}

  basicOverlaps :: forall s. MVector s (a :*: b) -> MVector s (a :*: b) -> Bool
basicOverlaps (MV_Prod Int
_n_1 MVector s a
as1 MVector s b
bs1) (MV_Prod Int
_n_2 MVector s a
as2 MVector s b
bs2)
   =  MVector s a -> MVector s a -> Bool
forall s. MVector s a -> MVector s a -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s a
as1 MVector s a
as2
   Bool -> Bool -> Bool
|| MVector s b -> MVector s b -> Bool
forall s. MVector s b -> MVector s b -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
M.basicOverlaps MVector s b
bs1 MVector s b
bs2
  {-# INLINE basicOverlaps  #-}

  basicUnsafeNew :: forall s. Int -> ST s (MVector s (a :*: b))
basicUnsafeNew Int
n_
   = do MVector s a
as <- Int -> ST s (MVector s a)
forall s. Int -> ST s (MVector s a)
forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a)
M.basicUnsafeNew Int
n_
        MVector s b
bs <- Int -> ST s (MVector s b)
forall s. Int -> ST s (MVector s b)
forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a)
M.basicUnsafeNew Int
n_
        MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector s (a :*: b) -> ST s (MVector s (a :*: b)))
-> MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a b. (a -> b) -> a -> b
$ Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
forall s a b.
Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
MV_Prod Int
n_ MVector s a
as MVector s b
bs
  {-# INLINE basicUnsafeNew  #-}

  basicInitialize :: forall s. MVector s (a :*: b) -> ST s ()
basicInitialize (MV_Prod Int
_ MVector s a
_as MVector s b
_bs)
      = do MVector s a -> ST s ()
forall s. MVector s a -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
M.basicInitialize MVector s a
_as
           MVector s b -> ST s ()
forall s. MVector s b -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
M.basicInitialize MVector s b
_bs 
  {-# INLINE basicInitialize  #-}

  basicUnsafeReplicate :: forall s. Int -> (a :*: b) -> ST s (MVector s (a :*: b))
basicUnsafeReplicate Int
n_ (a
a :*: b
b)
   = do MVector s a
as <- Int -> a -> ST s (MVector s a)
forall s. Int -> a -> ST s (MVector s a)
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> a -> ST s (v s a)
M.basicUnsafeReplicate Int
n_ a
a
        MVector s b
bs <- Int -> b -> ST s (MVector s b)
forall s. Int -> b -> ST s (MVector s b)
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> a -> ST s (v s a)
M.basicUnsafeReplicate Int
n_ b
b
        MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector s (a :*: b) -> ST s (MVector s (a :*: b)))
-> MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a b. (a -> b) -> a -> b
$ Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
forall s a b.
Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
MV_Prod Int
n_ MVector s a
as MVector s b
bs
  {-# INLINE basicUnsafeReplicate  #-}

  basicUnsafeRead :: forall s. MVector s (a :*: b) -> Int -> ST s (a :*: b)
basicUnsafeRead (MV_Prod Int
_n_ MVector s a
as MVector s b
bs) Int
i_
   = do a
a <- MVector s a -> Int -> ST s a
forall s. MVector s a -> Int -> ST s a
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s a
M.basicUnsafeRead MVector s a
as Int
i_
        b
b <- MVector s b -> Int -> ST s b
forall s. MVector s b -> Int -> ST s b
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s a
M.basicUnsafeRead MVector s b
bs Int
i_
        (a :*: b) -> ST s (a :*: b)
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a a -> b -> a :*: b
forall a b. a -> b -> a :*: b
:*: b
b)
  {-# INLINE basicUnsafeRead  #-}

  basicUnsafeWrite :: forall s. MVector s (a :*: b) -> Int -> (a :*: b) -> ST s ()
basicUnsafeWrite (MV_Prod Int
_n_ MVector s a
as MVector s b
bs) Int
i_ (a
a :*: b
b)
   = do MVector s a -> Int -> a -> ST s ()
forall s. MVector s a -> Int -> a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> a -> ST s ()
M.basicUnsafeWrite MVector s a
as Int
i_ a
a
        MVector s b -> Int -> b -> ST s ()
forall s. MVector s b -> Int -> b -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> a -> ST s ()
M.basicUnsafeWrite MVector s b
bs Int
i_ b
b
  {-# INLINE basicUnsafeWrite  #-}

  basicClear :: forall s. MVector s (a :*: b) -> ST s ()
basicClear (MV_Prod Int
_n_ MVector s a
as MVector s b
bs)
   = do MVector s a -> ST s ()
forall s. MVector s a -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
M.basicClear MVector s a
as
        MVector s b -> ST s ()
forall s. MVector s b -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
M.basicClear MVector s b
bs
  {-# INLINE basicClear  #-}

  basicSet :: forall s. MVector s (a :*: b) -> (a :*: b) -> ST s ()
basicSet (MV_Prod Int
_n_ MVector s a
as MVector s b
bs) (a
a :*: b
b)
   = do MVector s a -> a -> ST s ()
forall s. MVector s a -> a -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> a -> ST s ()
M.basicSet MVector s a
as a
a
        MVector s b -> b -> ST s ()
forall s. MVector s b -> b -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> a -> ST s ()
M.basicSet MVector s b
bs b
b
  {-# INLINE basicSet  #-}

  basicUnsafeCopy :: forall s. MVector s (a :*: b) -> MVector s (a :*: b) -> ST s ()
basicUnsafeCopy (MV_Prod Int
_n_1 MVector s a
as1 MVector s b
bs1) (MV_Prod Int
_n_2 MVector s a
as2 MVector s b
bs2)
   = do MVector s a -> MVector s a -> ST s ()
forall s. MVector s a -> MVector s a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
M.basicUnsafeCopy MVector s a
as1 MVector s a
as2
        MVector s b -> MVector s b -> ST s ()
forall s. MVector s b -> MVector s b -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
M.basicUnsafeCopy MVector s b
bs1 MVector s b
bs2
  {-# INLINE basicUnsafeCopy  #-}

  basicUnsafeMove :: forall s. MVector s (a :*: b) -> MVector s (a :*: b) -> ST s ()
basicUnsafeMove (MV_Prod Int
_n_1 MVector s a
as1 MVector s b
bs1) (MV_Prod Int
_n_2 MVector s a
as2 MVector s b
bs2)
   = do MVector s a -> MVector s a -> ST s ()
forall s. MVector s a -> MVector s a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
M.basicUnsafeMove MVector s a
as1 MVector s a
as2
        MVector s b -> MVector s b -> ST s ()
forall s. MVector s b -> MVector s b -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
M.basicUnsafeMove MVector s b
bs1 MVector s b
bs2
  {-# INLINE basicUnsafeMove  #-}

  basicUnsafeGrow :: forall s. MVector s (a :*: b) -> Int -> ST s (MVector s (a :*: b))
basicUnsafeGrow (MV_Prod Int
n_ MVector s a
as MVector s b
bs) Int
m_
   = do MVector s a
as' <- MVector s a -> Int -> ST s (MVector s a)
forall s. MVector s a -> Int -> ST s (MVector s a)
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s (v s a)
M.basicUnsafeGrow MVector s a
as Int
m_
        MVector s b
bs' <- MVector s b -> Int -> ST s (MVector s b)
forall s. MVector s b -> Int -> ST s (MVector s b)
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s (v s a)
M.basicUnsafeGrow MVector s b
bs Int
m_
        MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector s (a :*: b) -> ST s (MVector s (a :*: b)))
-> MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a b. (a -> b) -> a -> b
$ Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
forall s a b.
Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
MV_Prod (Int
m_ Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
n_) MVector s a
as' MVector s b
bs'
  {-# INLINE basicUnsafeGrow  #-}


instance  (U.Unbox a, U.Unbox b) 
        => G.Vector U.Vector (a :*: b) where
  basicUnsafeFreeze :: forall s. Mutable Vector s (a :*: b) -> ST s (Vector (a :*: b))
basicUnsafeFreeze (MV_Prod Int
n_ MVector s a
as MVector s b
bs)
   = do Vector a
as' <- Mutable Vector s a -> ST s (Vector a)
forall s. Mutable Vector s a -> ST s (Vector a)
forall (v :: * -> *) a s. Vector v a => Mutable v s a -> ST s (v a)
G.basicUnsafeFreeze Mutable Vector s a
MVector s a
as
        Vector b
bs' <- Mutable Vector s b -> ST s (Vector b)
forall s. Mutable Vector s b -> ST s (Vector b)
forall (v :: * -> *) a s. Vector v a => Mutable v s a -> ST s (v a)
G.basicUnsafeFreeze Mutable Vector s b
MVector s b
bs
        Vector (a :*: b) -> ST s (Vector (a :*: b))
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector (a :*: b) -> ST s (Vector (a :*: b)))
-> Vector (a :*: b) -> ST s (Vector (a :*: b))
forall a b. (a -> b) -> a -> b
$ Int -> Vector a -> Vector b -> Vector (a :*: b)
forall a b. Int -> Vector a -> Vector b -> Vector (a :*: b)
V_Prod Int
n_ Vector a
as' Vector b
bs'
  {-# INLINE basicUnsafeFreeze  #-}

  basicUnsafeThaw :: forall s. Vector (a :*: b) -> ST s (Mutable Vector s (a :*: b))
basicUnsafeThaw (V_Prod Int
n_ Vector a
as Vector b
bs)
   = do MVector s a
as' <- Vector a -> ST s (Mutable Vector s a)
forall s. Vector a -> ST s (Mutable Vector s a)
forall (v :: * -> *) a s. Vector v a => v a -> ST s (Mutable v s a)
G.basicUnsafeThaw Vector a
as
        MVector s b
bs' <- Vector b -> ST s (Mutable Vector s b)
forall s. Vector b -> ST s (Mutable Vector s b)
forall (v :: * -> *) a s. Vector v a => v a -> ST s (Mutable v s a)
G.basicUnsafeThaw Vector b
bs
        MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a. a -> ST s a
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector s (a :*: b) -> ST s (MVector s (a :*: b)))
-> MVector s (a :*: b) -> ST s (MVector s (a :*: b))
forall a b. (a -> b) -> a -> b
$ Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
forall s a b.
Int -> MVector s a -> MVector s b -> MVector s (a :*: b)
MV_Prod Int
n_ MVector s a
as' MVector s b
bs'
  {-# INLINE basicUnsafeThaw  #-}

  basicLength :: Vector (a :*: b) -> Int
basicLength (V_Prod Int
n_ Vector a
_as Vector b
_bs) 
   = Int
n_
  {-# INLINE basicLength  #-}

  basicUnsafeSlice :: Int -> Int -> Vector (a :*: b) -> Vector (a :*: b)
basicUnsafeSlice Int
i_ Int
m_ (V_Prod Int
_n_ Vector a
as Vector b
bs)
   = Int -> Vector a -> Vector b -> Vector (a :*: b)
forall a b. Int -> Vector a -> Vector b -> Vector (a :*: b)
V_Prod Int
m_ (Int -> Int -> Vector a -> Vector a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice Int
i_ Int
m_ Vector a
as)
               (Int -> Int -> Vector b -> Vector b
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice Int
i_ Int
m_ Vector b
bs)
  {-# INLINE basicUnsafeSlice  #-}

  basicUnsafeIndexM :: Vector (a :*: b) -> Int -> Box (a :*: b)
basicUnsafeIndexM (V_Prod Int
_n_ Vector a
as Vector b
bs) Int
i_
   = do a
a <- Vector a -> Int -> Box a
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
G.basicUnsafeIndexM Vector a
as Int
i_
        b
b <- Vector b -> Int -> Box b
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
G.basicUnsafeIndexM Vector b
bs Int
i_
        (a :*: b) -> Box (a :*: b)
forall a. a -> Box a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a a -> b -> a :*: b
forall a b. a -> b -> a :*: b
:*: b
b)
  {-# INLINE basicUnsafeIndexM  #-}

  basicUnsafeCopy :: forall s. Mutable Vector s (a :*: b) -> Vector (a :*: b) -> ST s ()
basicUnsafeCopy (MV_Prod Int
_n_1 MVector s a
as1 MVector s b
bs1) (V_Prod Int
_n_2 Vector a
as2 Vector b
bs2)
   = do Mutable Vector s a -> Vector a -> ST s ()
forall s. Mutable Vector s a -> Vector a -> ST s ()
forall (v :: * -> *) a s.
Vector v a =>
Mutable v s a -> v a -> ST s ()
G.basicUnsafeCopy Mutable Vector s a
MVector s a
as1 Vector a
as2
        Mutable Vector s b -> Vector b -> ST s ()
forall s. Mutable Vector s b -> Vector b -> ST s ()
forall (v :: * -> *) a s.
Vector v a =>
Mutable v s a -> v a -> ST s ()
G.basicUnsafeCopy Mutable Vector s b
MVector s b
bs1 Vector b
bs2
  {-# INLINE basicUnsafeCopy  #-}

  elemseq :: forall b. Vector (a :*: b) -> (a :*: b) -> b -> b
elemseq Vector (a :*: b)
_ (a
a :*: b
b)
      = Vector a -> a -> b -> b
forall b. Vector a -> a -> b -> b
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq (Vector a
forall a. HasCallStack => a
undefined :: U.Vector a) a
a
      (b -> b) -> (b -> b) -> b -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector b -> b -> b -> b
forall b. Vector b -> b -> b -> b
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq (Vector b
forall a. HasCallStack => a
undefined :: U.Vector b) b
b
  {-# INLINE elemseq  #-}