{-# LANGUAGE CPP                   #-}
{-# LANGUAGE DataKinds             #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PolyKinds             #-}
{-# LANGUAGE RankNTypes            #-}
{-# LANGUAGE ScopedTypeVariables   #-}
{-# LANGUAGE TypeFamilies          #-}
{-# LANGUAGE TypeOperators         #-}

{-|
This module re-exports the functionality in 'Data.Vector.Generic.Mutable.Sized'
 specialized to 'Data.Vector.Unboxed.Mutable'.

Functions returning a vector determine the size from the type context unless
they have a @'@ suffix in which case they take an explicit 'Proxy' argument.

Functions where the resulting vector size is not known until runtime are
not exported.
-}

module Data.Vector.Unboxed.Mutable.Sized
 ( MVector
   -- * Accessors
   -- ** Length information
  , length
  , length'
  , null
   -- ** Extracting subvectors
  , slice
  , slice'
  , init
  , tail
  , take
  , take'
  , drop
  , drop'
  , splitAt
  , splitAt'
  -- ** Overlaps
  , overlaps
  -- * Construction
  -- ** Initialisation
  , new
  , unsafeNew
  , replicate
  , replicate'
  , replicateM
  , replicateM'
  , clone
  -- ** Growing
  , grow
  , growFront
  -- ** Restricting memory usage
  , clear
  -- * Accessing individual elements
  , read
  , read'
  , write
  , write'
  , modify
  , modify'
  , swap
  , exchange
  , exchange'
  , unsafeRead
  , unsafeWrite
  , unsafeModify
  , unsafeSwap
  , unsafeExchange
#if MIN_VERSION_vector(0,12,0)
  -- * Modifying vectors
  , nextPermutation
#endif
  -- ** Filling and copying
  , set
  , copy
  , move
  , unsafeCopy
    -- * Conversions
    -- ** Unsized Mutable Vectors
  , toSized
  , withSized
  , fromSized
    -- * Unbox
  , Unbox
  ) where

import Data.Vector.Generic.Sized.Internal (Vector(..))
import qualified Data.Vector.Generic as V
import qualified Data.Vector.Generic.Mutable as VM
import qualified Data.Vector.Generic.Sized as VG
import qualified Data.Vector.Generic.Mutable.Sized as VGM
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM
import Data.Vector.Unboxed (Unbox)
import GHC.TypeLits
import Data.Finite
import Data.Proxy
import Control.Monad.Primitive
import Prelude hiding ( length, null, replicate, init,
                        tail, take, drop, splitAt, read )


-- | 'Data.Vector.Generic.Mutable.Sized.Vector' specialized to use
-- 'Data.Vector.Unbox.Mutable'.
type MVector = VGM.MVector VUM.MVector

-- * Accessors

-- ** Length information

-- | /O(1)/ Yield the length of the mutable vector as an 'Int'.
length :: forall n s a. (KnownNat n)
       => MVector n s a -> Int
length :: MVector n s a -> Int
length = MVector n s a -> Int
forall (v :: * -> * -> *) (n :: Nat) s a.
KnownNat n =>
MVector v n s a -> Int
VGM.length
{-# inline length #-}

-- | /O(1)/ Yield the length of the mutable vector as a 'Proxy'.
length' :: forall n s a. ()
        => MVector n s a -> Proxy n
length' :: MVector n s a -> Proxy n
length' = MVector n s a -> Proxy n
forall (v :: * -> * -> *) (n :: Nat) s a.
MVector v n s a -> Proxy n
VGM.length'
{-# inline length' #-}

-- | /O(1)/ Check whether the mutable vector is empty.
null :: forall n s a. (KnownNat n)
       => MVector n s a -> Bool
null :: MVector n s a -> Bool
null = MVector n s a -> Bool
forall (v :: * -> * -> *) (n :: Nat) s a.
KnownNat n =>
MVector v n s a -> Bool
VGM.null
{-# inline null #-}

-- ** Extracting subvectors

-- | /O(1)/ Yield a slice of the mutable vector without copying it with an
-- inferred length argument.
slice :: forall i n k s a p. (KnownNat i, KnownNat n, Unbox a)
      => p i -- ^ starting index
      -> MVector (i+n+k) s a
      -> MVector n s a
slice :: p i -> MVector ((i + n) + k) s a -> MVector n s a
slice = p i -> MVector ((i + n) + k) s a -> MVector n s a
forall (v :: * -> * -> *) (i :: Nat) (n :: Nat) (k :: Nat) s a
       (p :: Nat -> *).
(KnownNat i, KnownNat n, MVector v a) =>
p i -> MVector v ((i + n) + k) s a -> MVector v n s a
VGM.slice
{-# inline slice #-}

-- | /O(1)/ Yield a slice of the mutable vector without copying it with an
-- explicit length argument.
slice' :: forall i n k s a p
        . (KnownNat i, KnownNat n, Unbox a)
       => p i -- ^ starting index
       -> p n -- ^ length
       -> MVector (i+n+k) s a
       -> MVector n s a
slice' :: p i -> p n -> MVector ((i + n) + k) s a -> MVector n s a
slice' = p i -> p n -> MVector ((i + n) + k) s a -> MVector n s a
forall (v :: * -> * -> *) (i :: Nat) (n :: Nat) (k :: Nat) s a
       (p :: Nat -> *).
(KnownNat i, KnownNat n, MVector v a) =>
p i -> p n -> MVector v ((i + n) + k) s a -> MVector v n s a
VGM.slice'
{-# inline slice' #-}

-- | /O(1)/ Yield all but the last element of a non-empty mutable vector
-- without copying.
init :: forall n s a. Unbox a
     => MVector (n+1) s a -> MVector n s a
init :: MVector (n + 1) s a -> MVector n s a
init = MVector (n + 1) s a -> MVector n s a
forall (v :: * -> * -> *) (n :: Nat) s a.
MVector v a =>
MVector v (n + 1) s a -> MVector v n s a
VGM.init
{-# inline init #-}

-- | /O(1)/ Yield all but the first element of a non-empty mutable vector
-- without copying.
tail :: forall n s a. Unbox a
     => MVector (1+n) s a -> MVector n s a
tail :: MVector (1 + n) s a -> MVector n s a
tail = MVector (1 + n) s a -> MVector n s a
forall (v :: * -> * -> *) (n :: Nat) s a.
MVector v a =>
MVector v (1 + n) s a -> MVector v n s a
VGM.tail
{-# inline tail #-}

-- | /O(1)/ Yield the first @n@ elements. The resulting vector always contains
-- this many elements. The length of the resulting vector is inferred from the
-- type.
take :: forall n k s a. (KnownNat n, Unbox a)
     => MVector (n+k) s a -> MVector n s a
take :: MVector (n + k) s a -> MVector n s a
take = MVector (n + k) s a -> MVector n s a
forall (v :: * -> * -> *) (n :: Nat) (k :: Nat) s a.
(KnownNat n, MVector v a) =>
MVector v (n + k) s a -> MVector v n s a
VGM.take
{-# inline take #-}

-- | /O(1)/ Yield the first @n@ elements. The resulting vector always contains
-- this many elements. The length of the resulting vector is given explicitly
-- as a 'Proxy' argument.
take' :: forall n k s a p. (KnownNat n, Unbox a)
      => p n -> MVector (n+k) s a -> MVector n s a
take' :: p n -> MVector (n + k) s a -> MVector n s a
take' = p n -> MVector (n + k) s a -> MVector n s a
forall (v :: * -> * -> *) (n :: Nat) (k :: Nat) s a
       (p :: Nat -> *).
(KnownNat n, MVector v a) =>
p n -> MVector v (n + k) s a -> MVector v n s a
VGM.take'
{-# inline take' #-}

-- | /O(1)/ Yield all but the the first @n@ elements. The given vector must
-- contain at least this many elements. The length of the resulting vector is
-- inferred from the type.
drop :: forall n k s a. (KnownNat n, Unbox a)
     => MVector (n+k) s a -> MVector k s a
drop :: MVector (n + k) s a -> MVector k s a
drop = MVector (n + k) s a -> MVector k s a
forall (v :: * -> * -> *) (n :: Nat) (k :: Nat) s a.
(KnownNat n, MVector v a) =>
MVector v (n + k) s a -> MVector v k s a
VGM.drop
{-# inline drop #-}

-- | /O(1)/ Yield all but the the first @n@ elements. The given vector must
-- contain at least this many elements. The length of the resulting vector is
-- givel explicitly as a 'Proxy' argument.
drop' :: forall n k s a p. (KnownNat n, Unbox a)
      => p n -> MVector (n+k) s a -> MVector k s a
drop' :: p n -> MVector (n + k) s a -> MVector k s a
drop' = p n -> MVector (n + k) s a -> MVector k s a
forall (v :: * -> * -> *) (n :: Nat) (k :: Nat) s a
       (p :: Nat -> *).
(KnownNat n, MVector v a) =>
p n -> MVector v (n + k) s a -> MVector v k s a
VGM.drop'
{-# inline drop' #-}

-- | /O(1)/ Yield the first @n@ elements, paired with the rest, without copying.
-- The lengths of the resulting vectors are inferred from the type.
splitAt :: forall n m s a. (KnownNat n, Unbox a)
        => MVector (n+m) s a -> (MVector n s a, MVector m s a)
splitAt :: MVector (n + m) s a -> (MVector n s a, MVector m s a)
splitAt = MVector (n + m) s a -> (MVector n s a, MVector m s a)
forall (v :: * -> * -> *) (n :: Nat) (m :: Nat) s a.
(KnownNat n, MVector v a) =>
MVector v (n + m) s a -> (MVector v n s a, MVector v m s a)
VGM.splitAt
{-# inline splitAt #-}

-- | /O(1)/ Yield the first @n@ elements, paired with the rest, without
-- copying.  The length of the first resulting vector is passed explicitly as a
-- 'Proxy' argument.
splitAt' :: forall n m s a p. (KnownNat n, Unbox a)
         => p n -> MVector (n+m) s a -> (MVector n s a, MVector m s a)
splitAt' :: p n -> MVector (n + m) s a -> (MVector n s a, MVector m s a)
splitAt' = p n -> MVector (n + m) s a -> (MVector n s a, MVector m s a)
forall (v :: * -> * -> *) (n :: Nat) (m :: Nat) s a
       (p :: Nat -> *).
(KnownNat n, MVector v a) =>
p n -> MVector v (n + m) s a -> (MVector v n s a, MVector v m s a)
VGM.splitAt'
{-# inline splitAt' #-}

-- ** Overlaps

-- | /O(1)/ Check if two vectors overlap. 
overlaps :: forall n k s a. Unbox a
         => MVector n s a
         -> MVector k s a
         -> Bool
overlaps :: MVector n s a -> MVector k s a -> Bool
overlaps = MVector n s a -> MVector k s a -> Bool
forall (v :: * -> * -> *) (n :: Nat) (k :: Nat) s a.
MVector v a =>
MVector v n s a -> MVector v k s a -> Bool
VGM.overlaps
{-# inline overlaps #-}

-- * Construction

-- ** Initialisation

-- | Create a mutable vector where the length is inferred from the type.
new :: forall n m a. (KnownNat n, PrimMonad m, Unbox a)
    => m (MVector n (PrimState m) a)
new :: m (MVector n (PrimState m) a)
new = m (MVector n (PrimState m) a)
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(KnownNat n, PrimMonad m, MVector v a) =>
m (MVector v n (PrimState m) a)
VGM.new
{-# inline new #-}

-- | Create a mutable vector where the length is inferred from the type.
-- The memory is not initialized.
unsafeNew :: forall n m a. (KnownNat n, PrimMonad m, Unbox a)
          => m (MVector n (PrimState m) a)
unsafeNew :: m (MVector n (PrimState m) a)
unsafeNew = m (MVector n (PrimState m) a)
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(KnownNat n, PrimMonad m, MVector v a) =>
m (MVector v n (PrimState m) a)
VGM.unsafeNew
{-# inline unsafeNew #-}

-- | Create a mutable vector where the length is inferred from the type and
-- fill it with an initial value.
replicate :: forall n m a. (KnownNat n, PrimMonad m, Unbox a)
          => a -> m (MVector n (PrimState m) a)
replicate :: a -> m (MVector n (PrimState m) a)
replicate = a -> m (MVector n (PrimState m) a)
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(KnownNat n, PrimMonad m, MVector v a) =>
a -> m (MVector v n (PrimState m) a)
VGM.replicate
{-# inline replicate #-}

-- | Create a mutable vector where the length is given explicitly as
-- a 'Proxy' argument and fill it with an initial value.
replicate' :: forall n m a p. (KnownNat n, PrimMonad m, Unbox a)
           => p n -> a -> m (MVector n (PrimState m) a)
replicate' :: p n -> a -> m (MVector n (PrimState m) a)
replicate' = p n -> a -> m (MVector n (PrimState m) a)
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a
       (p :: Nat -> *).
(KnownNat n, PrimMonad m, MVector v a) =>
p n -> a -> m (MVector v n (PrimState m) a)
VGM.replicate'
{-# inline replicate' #-}

-- | Create a mutable vector where the length is inferred from the type and
-- fill it with values produced by repeatedly executing the monadic action.
replicateM :: forall n m a. (KnownNat n, PrimMonad m, Unbox a)
           => m a -> m (MVector n (PrimState m) a)
replicateM :: m a -> m (MVector n (PrimState m) a)
replicateM = m a -> m (MVector n (PrimState m) a)
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(KnownNat n, PrimMonad m, MVector v a) =>
m a -> m (MVector v n (PrimState m) a)
VGM.replicateM
{-# inline replicateM #-}

-- | Create a mutable vector where the length is given explicitly as
-- a 'Proxy' argument and fill it with values produced by repeatedly
-- executing the monadic action.
replicateM' :: forall n m a p. (KnownNat n, PrimMonad m, Unbox a)
           => p n -> m a -> m (MVector n (PrimState m) a)
replicateM' :: p n -> m a -> m (MVector n (PrimState m) a)
replicateM' = p n -> m a -> m (MVector n (PrimState m) a)
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a
       (p :: Nat -> *).
(KnownNat n, PrimMonad m, MVector v a) =>
p n -> m a -> m (MVector v n (PrimState m) a)
VGM.replicateM'
{-# inline replicateM' #-}

-- | Create a copy of a mutable vector.
clone :: forall n m a. (PrimMonad m, Unbox a)
      => MVector n (PrimState m) a -> m (MVector n (PrimState m) a)
clone :: MVector n (PrimState m) a -> m (MVector n (PrimState m) a)
clone = MVector n (PrimState m) a -> m (MVector n (PrimState m) a)
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> m (MVector v n (PrimState m) a)
VGM.clone
{-# inline clone #-}

-- ** Growing

-- | Grow a mutable vector by an amount given explicitly as a 'Proxy'
-- argument.
grow :: forall n k m a p. (KnownNat k, PrimMonad m, Unbox a)
      => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)
grow :: p k
-> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)
grow = p k
-> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)
forall (v :: * -> * -> *) (n :: Nat) (k :: Nat) (m :: * -> *) a
       (p :: Nat -> *).
(KnownNat k, PrimMonad m, MVector v a) =>
p k
-> MVector v n (PrimState m) a
-> m (MVector v (n + k) (PrimState m) a)
VGM.grow
{-# inline grow #-}

-- | Grow a mutable vector (from the front) by an amount given explicitly
-- as a 'Proxy' argument.
growFront :: forall n k m a p. (KnownNat k, PrimMonad m, Unbox a)
      => p k -> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)
growFront :: p k
-> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)
growFront = p k
-> MVector n (PrimState m) a -> m (MVector (n + k) (PrimState m) a)
forall (v :: * -> * -> *) (n :: Nat) (k :: Nat) (m :: * -> *) a
       (p :: Nat -> *).
(KnownNat k, PrimMonad m, MVector v a) =>
p k
-> MVector v n (PrimState m) a
-> m (MVector v (n + k) (PrimState m) a)
VGM.growFront
{-# inline growFront #-}

-- ** Restricting memory usage

-- | Reset all elements of the vector to some undefined value, clearing all
-- references to external objects.
clear :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> m ()
clear :: MVector n (PrimState m) a -> m ()
clear = MVector n (PrimState m) a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a (n :: Nat).
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> m ()
VGM.clear
{-# inline clear #-}

-- * Accessing individual elements

-- | /O(1)/ Yield the element at a given type-safe position using 'Finite'.
read :: forall n m a. (PrimMonad m, Unbox a)
      => MVector n (PrimState m) a -> Finite n -> m a
read :: MVector n (PrimState m) a -> Finite n -> m a
read = MVector n (PrimState m) a -> Finite n -> m a
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> Finite n -> m a
VGM.read
{-# inline read #-}

-- | /O(1)/ Yield the element at a given type-safe position using 'Proxy'.
read' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a)
       => MVector (n+k+1) (PrimState m) a -> p k -> m a
read' :: MVector ((n + k) + 1) (PrimState m) a -> p k -> m a
read' = MVector ((n + k) + 1) (PrimState m) a -> p k -> m a
forall (v :: * -> * -> *) (n :: Nat) (k :: Nat) a (m :: * -> *)
       (p :: Nat -> *).
(KnownNat k, PrimMonad m, MVector v a) =>
MVector v ((n + k) + 1) (PrimState m) a -> p k -> m a
VGM.read'
{-# inline read' #-}

-- | /O(1)/ Yield the element at a given 'Int' position without bounds
-- checking.
unsafeRead :: forall n a m. (PrimMonad m, Unbox a)
           => MVector n (PrimState m) a -> Int -> m a
unsafeRead :: MVector n (PrimState m) a -> Int -> m a
unsafeRead = MVector n (PrimState m) a -> Int -> m a
forall (v :: * -> * -> *) (n :: Nat) a (m :: * -> *).
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> Int -> m a
VGM.unsafeRead
{-# inline unsafeRead #-}

-- | /O(1)/ Replace the element at a given type-safe position using 'Finite'.
write :: forall n m a. (PrimMonad m, Unbox a)
      => MVector n (PrimState m) a -> Finite n -> a -> m ()
write :: MVector n (PrimState m) a -> Finite n -> a -> m ()
write = MVector n (PrimState m) a -> Finite n -> a -> m ()
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> Finite n -> a -> m ()
VGM.write
{-# inline write #-}

-- | /O(1)/ Replace the element at a given type-safe position using 'Proxy'.
write' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a)
       => MVector (n+k+1) (PrimState m) a -> p k -> a -> m ()
write' :: MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m ()
write' = MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m ()
forall (v :: * -> * -> *) (n :: Nat) (k :: Nat) a (m :: * -> *)
       (p :: Nat -> *).
(KnownNat k, PrimMonad m, MVector v a) =>
MVector v ((n + k) + 1) (PrimState m) a -> p k -> a -> m ()
VGM.write'
{-# inline write' #-}

-- | /O(1)/ Replace the element at a given 'Int' position without bounds
-- checking.
unsafeWrite :: forall n m a. (PrimMonad m, Unbox a)
      => MVector n (PrimState m) a -> Int -> a -> m ()
unsafeWrite :: MVector n (PrimState m) a -> Int -> a -> m ()
unsafeWrite = MVector n (PrimState m) a -> Int -> a -> m ()
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> Int -> a -> m ()
VGM.unsafeWrite
{-# inline unsafeWrite #-}

-- | /O(1)/ Modify the element at a given type-safe position using 'Finite'.
modify :: forall n m a. (PrimMonad m, Unbox a)
       => MVector n (PrimState m) a -> (a -> a) -> Finite n -> m ()
modify :: MVector n (PrimState m) a -> (a -> a) -> Finite n -> m ()
modify = MVector n (PrimState m) a -> (a -> a) -> Finite n -> m ()
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> (a -> a) -> Finite n -> m ()
VGM.modify
{-# inline modify #-}

-- | /O(1)/ Modify the element at a given type-safe position using 'Proxy'.
modify' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a)
        => MVector (n+k+1) (PrimState m) a -> (a -> a) -> p k -> m ()
modify' :: MVector ((n + k) + 1) (PrimState m) a -> (a -> a) -> p k -> m ()
modify' = MVector ((n + k) + 1) (PrimState m) a -> (a -> a) -> p k -> m ()
forall (v :: * -> * -> *) (n :: Nat) (k :: Nat) a (m :: * -> *)
       (p :: Nat -> *).
(KnownNat k, PrimMonad m, MVector v a) =>
MVector v ((n + k) + 1) (PrimState m) a -> (a -> a) -> p k -> m ()
VGM.modify'
{-# inline modify' #-}

-- | /O(1)/ Modify the element at a given 'Int' position without bounds
-- checking.
unsafeModify :: forall n m a. (PrimMonad m, Unbox a)
       => MVector n (PrimState m) a -> (a -> a) -> Int -> m ()
unsafeModify :: MVector n (PrimState m) a -> (a -> a) -> Int -> m ()
unsafeModify = MVector n (PrimState m) a -> (a -> a) -> Int -> m ()
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> (a -> a) -> Int -> m ()
VGM.unsafeModify
{-# inline unsafeModify #-}

-- | /O(1)/ Swap the elements at the given type-safe positions using 'Finite's.
swap :: forall n m a. (PrimMonad m, Unbox a)
     => MVector n (PrimState m) a -> Finite n -> Finite n -> m ()
swap :: MVector n (PrimState m) a -> Finite n -> Finite n -> m ()
swap = MVector n (PrimState m) a -> Finite n -> Finite n -> m ()
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> Finite n -> Finite n -> m ()
VGM.swap
{-# inline swap #-}

-- | /O(1)/ Swap the elements at the given 'Int' positions without bounds
-- checking.
unsafeSwap :: forall n m a. (PrimMonad m, Unbox a)
           => MVector n (PrimState m) a -> Int -> Int -> m ()
unsafeSwap :: MVector n (PrimState m) a -> Int -> Int -> m ()
unsafeSwap = MVector n (PrimState m) a -> Int -> Int -> m ()
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> Int -> Int -> m ()
VGM.unsafeSwap
{-# inline unsafeSwap #-}

-- | /O(1)/ Replace the element at a given type-safe position and return
-- the old element, using 'Finite'.
exchange :: forall n m a. (PrimMonad m, Unbox a)
         => MVector n (PrimState m) a -> Finite n -> a -> m a
exchange :: MVector n (PrimState m) a -> Finite n -> a -> m a
exchange = MVector n (PrimState m) a -> Finite n -> a -> m a
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> Finite n -> a -> m a
VGM.exchange
{-# inline exchange #-}

-- | /O(1)/ Replace the element at a given type-safe position and return
-- the old element, using 'Finite'.
exchange' :: forall n k a m p. (KnownNat k, PrimMonad m, Unbox a)
          => MVector (n+k+1) (PrimState m) a -> p k -> a -> m a
exchange' :: MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m a
exchange' = MVector ((n + k) + 1) (PrimState m) a -> p k -> a -> m a
forall (v :: * -> * -> *) (n :: Nat) (k :: Nat) a (m :: * -> *)
       (p :: Nat -> *).
(KnownNat k, PrimMonad m, MVector v a) =>
MVector v ((n + k) + 1) (PrimState m) a -> p k -> a -> m a
VGM.exchange'
{-# inline exchange' #-}

-- | /O(1)/ Replace the element at a given 'Int' position and return
-- the old element. No bounds checks are performed.
unsafeExchange :: forall n m a. (PrimMonad m, Unbox a)
         => MVector n (PrimState m) a -> Int -> a -> m a
unsafeExchange :: MVector n (PrimState m) a -> Int -> a -> m a
unsafeExchange = MVector n (PrimState m) a -> Int -> a -> m a
forall (v :: * -> * -> *) (n :: Nat) (m :: * -> *) a.
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> Int -> a -> m a
VGM.unsafeExchange
{-# inline unsafeExchange #-}

#if MIN_VERSION_vector(0,12,0)
-- * Modifying vectors

-- | Compute the next permutation (lexicographically) of a given vector
-- in-place.  Returns 'False' when the input is the last permutation.
nextPermutation :: forall n e m. (Ord e, PrimMonad m, Unbox e)
                => MVector n (PrimState m) e -> m Bool
nextPermutation :: MVector n (PrimState m) e -> m Bool
nextPermutation = MVector n (PrimState m) e -> m Bool
forall (v :: * -> * -> *) (n :: Nat) e (m :: * -> *).
(Ord e, PrimMonad m, MVector v e) =>
MVector v n (PrimState m) e -> m Bool
VGM.nextPermutation
{-# inline nextPermutation #-}
#endif

-- ** Filling and copying

-- | Set all elements of the vector to the given value.
set :: (PrimMonad m, Unbox a) => MVector n (PrimState m) a -> a -> m ()
set :: MVector n (PrimState m) a -> a -> m ()
set = MVector n (PrimState m) a -> a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a (n :: Nat).
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> a -> m ()
VGM.set
{-# inline set #-}

-- | Copy a vector. The two vectors may not overlap.
copy :: (PrimMonad m, Unbox a)
     => MVector n (PrimState m) a       -- ^ target
     -> MVector n (PrimState m) a       -- ^ source
     -> m ()
copy :: MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()
copy = MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a (n :: Nat).
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> MVector v n (PrimState m) a -> m ()
VGM.copy
{-# inline copy #-}

-- * Conversions

-- ** Unsized Mutable Vectors

-- | Copy a vector. The two vectors may not overlap. This is not checked.
unsafeCopy :: (PrimMonad m, Unbox a)
           => MVector n (PrimState m) a       -- ^ target
           -> MVector n (PrimState m) a       -- ^ source
           -> m ()
unsafeCopy :: MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()
unsafeCopy = MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a (n :: Nat).
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> MVector v n (PrimState m) a -> m ()
VGM.unsafeCopy
{-# inline unsafeCopy #-}

-- | Move the contents of a vector.  If the two vectors do not overlap,
-- this is equivalent to 'copy'.  Otherwise, the copying is performed as if
-- the source vector were copied to a temporary vector and then the
-- temporary vector was copied to the target vector.
move :: (PrimMonad m, Unbox a)
     => MVector n (PrimState m) a       -- ^ target
     -> MVector n (PrimState m) a       -- ^ source
     -> m ()
move :: MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()
move = MVector n (PrimState m) a -> MVector n (PrimState m) a -> m ()
forall (m :: * -> *) (v :: * -> * -> *) a (n :: Nat).
(PrimMonad m, MVector v a) =>
MVector v n (PrimState m) a -> MVector v n (PrimState m) a -> m ()
VGM.move
{-# inline move #-}

-- | Convert a 'Data.Vector.Unbox.Mutable.MVector' into
-- a 'Data.Vector.Unbox.Mutable.Sized.MVector' if it has the correct
-- size, otherwise return Nothing.
--
-- Note that this does no copying; the returned 'MVector' is a reference to
-- the exact same vector in memory as the given one, and any modifications
-- to it are also reflected in the given
-- 'Data.Vector.Unbox.Mutable.MVector'.
toSized :: forall n a s. (KnownNat n, Unbox a)
        => VUM.MVector s a -> Maybe (MVector n s a)
toSized :: MVector s a -> Maybe (MVector n s a)
toSized = MVector s a -> Maybe (MVector n s a)
forall (v :: * -> * -> *) (n :: Nat) s a.
(MVector v a, KnownNat n) =>
v s a -> Maybe (MVector v n s a)
VGM.toSized
{-# inline toSized #-}

-- | Takes a 'Data.Vector.Unbox.Mutable.MVector' and returns
-- a continuation providing a 'Data.Vector.Unbox.Mutable.Sized.MVector'
-- with a size parameter @n@ that is determined at runtime based on the
-- length of the input vector.
--
-- Essentially converts a 'Data.Vector.Unbox.Mutable.MVector' into
-- a 'Data.Vector.Unbox.Sized.MVector' with the correct size parameter
-- @n@.
--
-- Note that this does no copying; the returned 'MVector' is a reference to
-- the exact same vector in memory as the given one, and any modifications
-- to it are also reflected in the given
-- 'Data.Vector.Unbox.Mutable.MVector'.
withSized :: forall s a r. Unbox a
          => VUM.MVector s a -> (forall n. KnownNat n => MVector n s a -> r) -> r
withSized :: MVector s a
-> (forall (n :: Nat). KnownNat n => MVector n s a -> r) -> r
withSized = MVector s a
-> (forall (n :: Nat). KnownNat n => MVector n s a -> r) -> r
forall (v :: * -> * -> *) s a r.
MVector v a =>
v s a
-> (forall (n :: Nat). KnownNat n => MVector v n s a -> r) -> r
VGM.withSized
{-# inline withSized #-}

-- | Convert a 'Data.Vector.Unbox.Mutable.Sized.MVector' into a
-- 'Data.Vector.Unbox.Mutable.MVector'.
--
-- Note that this does no copying; the returned
-- 'Data.Vector.Unbox.Mutable.MVector' is a reference to the exact same
-- vector in memory as the given one, and any modifications to it are also
-- reflected in the given 'MVector'.
fromSized :: MVector n s a -> VUM.MVector s a
fromSized :: MVector n s a -> MVector s a
fromSized = MVector n s a -> MVector s a
forall (v :: * -> * -> *) (n :: Nat) s a. MVector v n s a -> v s a
VGM.fromSized
{-# inline fromSized #-}


-- | This instance allows to define sized matrices and tensors
-- backed by continuous memory segments, which reduces memory allocations
-- and relaxes pressure on garbage collector.
instance (Unbox a, KnownNat n) => Unbox (VG.Vector VU.Vector n a)

newtype instance VUM.MVector s (VG.Vector VU.Vector n a) = MV_Sized (VUM.MVector s a)
newtype instance VU.Vector     (VG.Vector VU.Vector n a) = V_Sized  (VU.Vector     a)

instance (Unbox a, KnownNat n) => VM.MVector VUM.MVector (VG.Vector VU.Vector n a) where
  basicLength :: MVector s (Vector Vector n a) -> Int
basicLength vs :: MVector s (Vector Vector n a)
vs@(MV_Sized v) = MVector s a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
VM.basicLength MVector s a
v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` MVector s (Vector Vector n a) -> Int
forall s (n :: Nat) a.
KnownNat n =>
MVector s (Vector Vector n a) -> Int
intLenM MVector s (Vector Vector n a)
vs
  {-# inline basicLength #-}

  basicUnsafeSlice :: Int
-> Int
-> MVector s (Vector Vector n a)
-> MVector s (Vector Vector n a)
basicUnsafeSlice i :: Int
i n :: Int
n vs :: MVector s (Vector Vector n a)
vs@(MV_Sized v) = MVector s a -> MVector s (Vector Vector n a)
forall s (n :: Nat) a. MVector s a -> MVector s (Vector Vector n a)
MV_Sized (Int -> Int -> MVector s a -> MVector s a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
VM.basicUnsafeSlice (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* MVector s (Vector Vector n a) -> Int
forall s (n :: Nat) a.
KnownNat n =>
MVector s (Vector Vector n a) -> Int
intLenM MVector s (Vector Vector n a)
vs) (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* MVector s (Vector Vector n a) -> Int
forall s (n :: Nat) a.
KnownNat n =>
MVector s (Vector Vector n a) -> Int
intLenM MVector s (Vector Vector n a)
vs) MVector s a
v)
  {-# inline basicUnsafeSlice #-}

  basicOverlaps :: MVector s (Vector Vector n a)
-> MVector s (Vector Vector n a) -> Bool
basicOverlaps (MV_Sized v1) (MV_Sized v2) = MVector s a -> MVector s a -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
VM.basicOverlaps MVector s a
v1 MVector s a
v2
  {-# inline basicOverlaps #-}

  basicUnsafeNew :: Int -> m (MVector (PrimState m) (Vector Vector n a))
basicUnsafeNew n :: Int
n = MVector (PrimState m) a
-> MVector (PrimState m) (Vector Vector n a)
forall s (n :: Nat) a. MVector s a -> MVector s (Vector Vector n a)
MV_Sized (MVector (PrimState m) a
 -> MVector (PrimState m) (Vector Vector n a))
-> m (MVector (PrimState m) a)
-> m (MVector (PrimState m) (Vector Vector n a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> m (MVector (PrimState m) a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
Int -> m (v (PrimState m) a)
VM.basicUnsafeNew (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Proxy n -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy n
forall k (t :: k). Proxy t
Proxy :: Proxy n)))
  {-# inline basicUnsafeNew #-}

  basicInitialize :: MVector (PrimState m) (Vector Vector n a) -> m ()
basicInitialize (MV_Sized v) = MVector (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
VM.basicInitialize MVector (PrimState m) a
v
  {-# inline basicInitialize #-}

  basicClear :: MVector (PrimState m) (Vector Vector n a) -> m ()
basicClear (MV_Sized v) = MVector (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> m ()
VM.basicClear MVector (PrimState m) a
v
  {-# inline basicClear #-}

  basicUnsafeCopy :: MVector (PrimState m) (Vector Vector n a)
-> MVector (PrimState m) (Vector Vector n a) -> m ()
basicUnsafeCopy (MV_Sized v1) (MV_Sized v2) = MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
VM.basicUnsafeCopy MVector (PrimState m) a
v1 MVector (PrimState m) a
v2
  {-# inline basicUnsafeCopy #-}

  basicUnsafeMove :: MVector (PrimState m) (Vector Vector n a)
-> MVector (PrimState m) (Vector Vector n a) -> m ()
basicUnsafeMove (MV_Sized v1) (MV_Sized v2) = MVector (PrimState m) a -> MVector (PrimState m) a -> m ()
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> v (PrimState m) a -> m ()
VM.basicUnsafeMove MVector (PrimState m) a
v1 MVector (PrimState m) a
v2
  {-# inline basicUnsafeMove #-}

  basicUnsafeGrow :: MVector (PrimState m) (Vector Vector n a)
-> Int -> m (MVector (PrimState m) (Vector Vector n a))
basicUnsafeGrow vs :: MVector (PrimState m) (Vector Vector n a)
vs@(MV_Sized v) n :: Int
n = MVector (PrimState m) a
-> MVector (PrimState m) (Vector Vector n a)
forall s (n :: Nat) a. MVector s a -> MVector s (Vector Vector n a)
MV_Sized (MVector (PrimState m) a
 -> MVector (PrimState m) (Vector Vector n a))
-> m (MVector (PrimState m) a)
-> m (MVector (PrimState m) (Vector Vector n a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MVector (PrimState m) a -> Int -> m (MVector (PrimState m) a)
forall (v :: * -> * -> *) a (m :: * -> *).
(MVector v a, PrimMonad m) =>
v (PrimState m) a -> Int -> m (v (PrimState m) a)
VM.basicUnsafeGrow MVector (PrimState m) a
v (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* MVector (PrimState m) (Vector Vector n a) -> Int
forall s (n :: Nat) a.
KnownNat n =>
MVector s (Vector Vector n a) -> Int
intLenM MVector (PrimState m) (Vector Vector n a)
vs)
  {-# inline basicUnsafeGrow #-}

  basicUnsafeRead :: MVector (PrimState m) (Vector Vector n a)
-> Int -> m (Vector Vector n a)
basicUnsafeRead vs :: MVector (PrimState m) (Vector Vector n a)
vs@(MV_Sized v) i :: Int
i = Vector a -> Vector Vector n a
forall (v :: * -> *) (n :: Nat) a. v a -> Vector v n a
Vector (Vector a -> Vector Vector n a)
-> m (Vector a) -> m (Vector Vector n a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mutable Vector (PrimState m) a -> m (Vector a)
forall (m :: * -> *) (v :: * -> *) a.
(PrimMonad m, Vector v a) =>
Mutable v (PrimState m) a -> m (v a)
V.freeze (Int -> Int -> MVector (PrimState m) a -> MVector (PrimState m) a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
VM.basicUnsafeSlice (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* MVector (PrimState m) (Vector Vector n a) -> Int
forall s (n :: Nat) a.
KnownNat n =>
MVector s (Vector Vector n a) -> Int
intLenM MVector (PrimState m) (Vector Vector n a)
vs) (MVector (PrimState m) (Vector Vector n a) -> Int
forall s (n :: Nat) a.
KnownNat n =>
MVector s (Vector Vector n a) -> Int
intLenM MVector (PrimState m) (Vector Vector n a)
vs) MVector (PrimState m) a
v)
  {-# inline basicUnsafeRead #-}

  basicUnsafeWrite :: MVector (PrimState m) (Vector Vector n a)
-> Int -> Vector Vector n a -> m ()
basicUnsafeWrite vs :: MVector (PrimState m) (Vector Vector n a)
vs@(MV_Sized v) i :: Int
i (Vector x :: Vector a
x) = Mutable Vector (PrimState m) a -> Vector a -> m ()
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> v a -> m ()
V.basicUnsafeCopy (Int -> Int -> MVector (PrimState m) a -> MVector (PrimState m) a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
VM.basicUnsafeSlice (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* MVector (PrimState m) (Vector Vector n a) -> Int
forall s (n :: Nat) a.
KnownNat n =>
MVector s (Vector Vector n a) -> Int
intLenM MVector (PrimState m) (Vector Vector n a)
vs) (MVector (PrimState m) (Vector Vector n a) -> Int
forall s (n :: Nat) a.
KnownNat n =>
MVector s (Vector Vector n a) -> Int
intLenM MVector (PrimState m) (Vector Vector n a)
vs) MVector (PrimState m) a
v) Vector a
x
  {-# inline basicUnsafeWrite #-}


intLenM :: forall s n a. KnownNat n => VUM.MVector s (VG.Vector VU.Vector n a) -> Int
intLenM :: MVector s (Vector Vector n a) -> Int
intLenM _ = Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Proxy n -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy n
forall k (t :: k). Proxy t
Proxy :: Proxy n))

instance (Unbox a, KnownNat n) => V.Vector VU.Vector (VG.Vector VU.Vector n a) where
  basicUnsafeFreeze :: Mutable Vector (PrimState m) (Vector Vector n a)
-> m (Vector (Vector Vector n a))
basicUnsafeFreeze (MV_Sized v) = Vector a -> Vector (Vector Vector n a)
forall (n :: Nat) a. Vector a -> Vector (Vector Vector n a)
V_Sized (Vector a -> Vector (Vector Vector n a))
-> m (Vector a) -> m (Vector (Vector Vector n a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Mutable Vector (PrimState m) a -> m (Vector a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> m (v a)
V.basicUnsafeFreeze MVector (PrimState m) a
Mutable Vector (PrimState m) a
v
  {-# inline basicUnsafeFreeze #-}

  basicUnsafeThaw :: Vector (Vector Vector n a)
-> m (Mutable Vector (PrimState m) (Vector Vector n a))
basicUnsafeThaw (V_Sized v) = MVector (PrimState m) a
-> MVector (PrimState m) (Vector Vector n a)
forall s (n :: Nat) a. MVector s a -> MVector s (Vector Vector n a)
MV_Sized (MVector (PrimState m) a
 -> MVector (PrimState m) (Vector Vector n a))
-> m (MVector (PrimState m) a)
-> m (MVector (PrimState m) (Vector Vector n a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Vector a -> m (Mutable Vector (PrimState m) a)
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
v a -> m (Mutable v (PrimState m) a)
V.basicUnsafeThaw Vector a
v
  {-# inline basicUnsafeThaw #-}

  basicLength :: Vector (Vector Vector n a) -> Int
basicLength vs :: Vector (Vector Vector n a)
vs@(V_Sized v) = Vector a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
V.basicLength Vector a
v Int -> Int -> Int
forall a. Integral a => a -> a -> a
`quot` Vector (Vector Vector n a) -> Int
forall (n :: Nat) a.
KnownNat n =>
Vector (Vector Vector n a) -> Int
intLen Vector (Vector Vector n a)
vs
  {-# inline basicLength #-}

  basicUnsafeSlice :: Int
-> Int -> Vector (Vector Vector n a) -> Vector (Vector Vector n a)
basicUnsafeSlice i :: Int
i n :: Int
n vs :: Vector (Vector Vector n a)
vs@(V_Sized v) = Vector a -> Vector (Vector Vector n a)
forall (n :: Nat) a. Vector a -> Vector (Vector Vector n a)
V_Sized (Int -> Int -> Vector a -> Vector a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
V.basicUnsafeSlice (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* Vector (Vector Vector n a) -> Int
forall (n :: Nat) a.
KnownNat n =>
Vector (Vector Vector n a) -> Int
intLen Vector (Vector Vector n a)
vs) (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
* Vector (Vector Vector n a) -> Int
forall (n :: Nat) a.
KnownNat n =>
Vector (Vector Vector n a) -> Int
intLen Vector (Vector Vector n a)
vs) Vector a
v)
  {-# inline basicUnsafeSlice #-}

  basicUnsafeCopy :: Mutable Vector (PrimState m) (Vector Vector n a)
-> Vector (Vector Vector n a) -> m ()
basicUnsafeCopy (MV_Sized mv) (V_Sized v) = Mutable Vector (PrimState m) a -> Vector a -> m ()
forall (v :: * -> *) a (m :: * -> *).
(Vector v a, PrimMonad m) =>
Mutable v (PrimState m) a -> v a -> m ()
V.basicUnsafeCopy MVector (PrimState m) a
Mutable Vector (PrimState m) a
mv Vector a
v
  {-# inline basicUnsafeCopy #-}

  elemseq :: Vector (Vector Vector n a) -> Vector Vector n a -> b -> b
elemseq _ = Vector Vector n a -> b -> b
forall a b. a -> b -> b
seq
  {-# inline elemseq #-}

  basicUnsafeIndexM :: Vector (Vector Vector n a) -> Int -> m (Vector Vector n a)
basicUnsafeIndexM vs :: Vector (Vector Vector n a)
vs@(V_Sized v) i :: Int
i = Vector Vector n a -> m (Vector Vector n a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Vector Vector n a -> m (Vector Vector n a))
-> Vector Vector n a -> m (Vector Vector n a)
forall a b. (a -> b) -> a -> b
$! Vector a -> Vector Vector n a
forall (v :: * -> *) (n :: Nat) a. v a -> Vector v n a
Vector (Int -> Int -> Vector a -> Vector a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
V.basicUnsafeSlice (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* Vector (Vector Vector n a) -> Int
forall (n :: Nat) a.
KnownNat n =>
Vector (Vector Vector n a) -> Int
intLen Vector (Vector Vector n a)
vs) (Vector (Vector Vector n a) -> Int
forall (n :: Nat) a.
KnownNat n =>
Vector (Vector Vector n a) -> Int
intLen Vector (Vector Vector n a)
vs) Vector a
v)
  {-# inline basicUnsafeIndexM #-}

intLen :: forall n a. KnownNat n => VU.Vector (VG.Vector VU.Vector n a) -> Int
intLen :: Vector (Vector Vector n a) -> Int
intLen _ = Integer -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Proxy n -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal (Proxy n
forall k (t :: k). Proxy t
Proxy :: Proxy n))