fixed-vector-0.9.0.0: Generic vectors with statically known size.

Safe HaskellNone
LanguageHaskell98

Data.Vector.Fixed.Mutable

Contents

Description

Type classes for vectors which are implemented on top of the arrays and support in-place mutation. API is similar to one used in the vector package.

Synopsis

Mutable vectors

class Arity n where #

Type class for handling n-ary functions.

Minimal complete definition

accum, applyFun, applyFunM, arity, reverseF, uncurryMany, gunfoldF

Methods

arity :: n -> Int #

Arity of function.

Instances

Arity Z # 

Methods

accum :: (forall k. t (S k) -> a -> t k) -> (t Z -> b) -> t Z -> Fun Z a b #

applyFun :: (forall k. t (S k) -> (a, t k)) -> t Z -> Fn Z a b -> (b, t Z) #

applyFunM :: Monad m => (forall k. t (S k) -> m (a, t k)) -> t Z -> m (ContVec Z a, t Z) #

arity :: Z -> Int #

reverseF :: Fun Z a b -> Fun Z a b #

uncurryMany :: Fun (Add Z k) a b -> Fun Z a (Fun k a b) #

gunfoldF :: Data a => (forall b x. Data b => c (b -> x) -> c x) -> T_gunfold c r a Z -> c r #

Arity n => Arity (S n) # 

Methods

accum :: (forall k. t (S k) -> a -> t k) -> (t Z -> b) -> t (S n) -> Fun (S n) a b #

applyFun :: (forall k. t (S k) -> (a, t k)) -> t (S n) -> Fn (S n) a b -> (b, t Z) #

applyFunM :: Monad m => (forall k. t (S k) -> m (a, t k)) -> t (S n) -> m (ContVec (S n) a, t Z) #

arity :: S n -> Int #

reverseF :: Fun (S n) a b -> Fun (S n) a b #

uncurryMany :: Fun (Add (S n) k) a b -> Fun (S n) a (Fun k a b) #

gunfoldF :: Data a => (forall b x. Data b => c (b -> x) -> c x) -> T_gunfold c r a (S n) -> c r #

arity :: Arity n => n -> Int #

Arity of function.

type family Mutable (v :: * -> *) :: * -> * -> * #

Mutable counterpart of fixed-length vector.

Instances

type Mutable (Vec n) # 
type Mutable (Vec n) = MVec n
type Mutable (Vec n) # 
type Mutable (Vec n) = MVec n
type Mutable (Vec n) # 
type Mutable (Vec n) = MVec n
type Mutable (Vec n) # 
type Mutable (Vec n) = MVec n

type family DimM (v :: * -> * -> *) :: * #

Dimension for mutable vector.

Instances

type DimM (MVec n) # 
type DimM (MVec n) = n
type DimM (MVec n) # 
type DimM (MVec n) = n
type DimM (MVec n) # 
type DimM (MVec n) = n
type DimM (MVec n) # 
type DimM (MVec n) = n

class Arity (DimM v) => MVector v a where #

Type class for mutable vectors.

Minimal complete definition

overlaps, copy, move, new, unsafeRead, unsafeWrite

Methods

overlaps :: v s a -> v s a -> Bool #

Checks whether vectors' buffers overlaps

copy :: PrimMonad m => v (PrimState m) a -> v (PrimState m) a -> m () #

Copy vector. The two vectors may not overlap. Since vectors' length is encoded in the type there is no need in runtime checks.

move :: PrimMonad m => v (PrimState m) a -> v (PrimState m) a -> m () #

Copy vector. The two vectors may overlap. Since vectors' length is encoded in the type there is no need in runtime checks.

new :: PrimMonad m => m (v (PrimState m) a) #

Allocate new vector

unsafeRead :: PrimMonad m => v (PrimState m) a -> Int -> m a #

Read value at index without bound checks.

unsafeWrite :: PrimMonad m => v (PrimState m) a -> Int -> a -> m () #

Write value at index without bound checks.

Instances

Arity n => MVector (MVec n) a # 

Methods

overlaps :: MVec n s a -> MVec n s a -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) a -> MVec n (PrimState m) a -> m () #

move :: PrimMonad m => MVec n (PrimState m) a -> MVec n (PrimState m) a -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) a) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) a -> Int -> m a #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) a -> Int -> a -> m () #

(Arity n, Prim a) => MVector (MVec n) a # 

Methods

overlaps :: MVec n s a -> MVec n s a -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) a -> MVec n (PrimState m) a -> m () #

move :: PrimMonad m => MVec n (PrimState m) a -> MVec n (PrimState m) a -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) a) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) a -> Int -> m a #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) a -> Int -> a -> m () #

(Arity n, Storable a) => MVector (MVec n) a # 

Methods

overlaps :: MVec n s a -> MVec n s a -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) a -> MVec n (PrimState m) a -> m () #

move :: PrimMonad m => MVec n (PrimState m) a -> MVec n (PrimState m) a -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) a) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) a -> Int -> m a #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) a -> Int -> a -> m () #

Arity n => MVector (MVec n) Double # 

Methods

overlaps :: MVec n s Double -> MVec n s Double -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Double -> MVec n (PrimState m) Double -> m () #

move :: PrimMonad m => MVec n (PrimState m) Double -> MVec n (PrimState m) Double -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Double) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Double -> Int -> m Double #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Double -> Int -> Double -> m () #

Arity n => MVector (MVec n) Float # 

Methods

overlaps :: MVec n s Float -> MVec n s Float -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Float -> MVec n (PrimState m) Float -> m () #

move :: PrimMonad m => MVec n (PrimState m) Float -> MVec n (PrimState m) Float -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Float) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Float -> Int -> m Float #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Float -> Int -> Float -> m () #

Arity n => MVector (MVec n) Char # 

Methods

overlaps :: MVec n s Char -> MVec n s Char -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Char -> MVec n (PrimState m) Char -> m () #

move :: PrimMonad m => MVec n (PrimState m) Char -> MVec n (PrimState m) Char -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Char) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Char -> Int -> m Char #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Char -> Int -> Char -> m () #

Arity n => MVector (MVec n) Word64 # 

Methods

overlaps :: MVec n s Word64 -> MVec n s Word64 -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Word64 -> MVec n (PrimState m) Word64 -> m () #

move :: PrimMonad m => MVec n (PrimState m) Word64 -> MVec n (PrimState m) Word64 -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Word64) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Word64 -> Int -> m Word64 #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Word64 -> Int -> Word64 -> m () #

Arity n => MVector (MVec n) Word32 # 

Methods

overlaps :: MVec n s Word32 -> MVec n s Word32 -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Word32 -> MVec n (PrimState m) Word32 -> m () #

move :: PrimMonad m => MVec n (PrimState m) Word32 -> MVec n (PrimState m) Word32 -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Word32) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Word32 -> Int -> m Word32 #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Word32 -> Int -> Word32 -> m () #

Arity n => MVector (MVec n) Word16 # 

Methods

overlaps :: MVec n s Word16 -> MVec n s Word16 -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Word16 -> MVec n (PrimState m) Word16 -> m () #

move :: PrimMonad m => MVec n (PrimState m) Word16 -> MVec n (PrimState m) Word16 -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Word16) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Word16 -> Int -> m Word16 #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Word16 -> Int -> Word16 -> m () #

Arity n => MVector (MVec n) Word8 # 

Methods

overlaps :: MVec n s Word8 -> MVec n s Word8 -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Word8 -> MVec n (PrimState m) Word8 -> m () #

move :: PrimMonad m => MVec n (PrimState m) Word8 -> MVec n (PrimState m) Word8 -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Word8) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Word8 -> Int -> m Word8 #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Word8 -> Int -> Word8 -> m () #

Arity n => MVector (MVec n) Word # 

Methods

overlaps :: MVec n s Word -> MVec n s Word -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Word -> MVec n (PrimState m) Word -> m () #

move :: PrimMonad m => MVec n (PrimState m) Word -> MVec n (PrimState m) Word -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Word) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Word -> Int -> m Word #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Word -> Int -> Word -> m () #

Arity n => MVector (MVec n) Int64 # 

Methods

overlaps :: MVec n s Int64 -> MVec n s Int64 -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Int64 -> MVec n (PrimState m) Int64 -> m () #

move :: PrimMonad m => MVec n (PrimState m) Int64 -> MVec n (PrimState m) Int64 -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Int64) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Int64 -> Int -> m Int64 #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Int64 -> Int -> Int64 -> m () #

Arity n => MVector (MVec n) Int32 # 

Methods

overlaps :: MVec n s Int32 -> MVec n s Int32 -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Int32 -> MVec n (PrimState m) Int32 -> m () #

move :: PrimMonad m => MVec n (PrimState m) Int32 -> MVec n (PrimState m) Int32 -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Int32) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Int32 -> Int -> m Int32 #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Int32 -> Int -> Int32 -> m () #

Arity n => MVector (MVec n) Int16 # 

Methods

overlaps :: MVec n s Int16 -> MVec n s Int16 -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Int16 -> MVec n (PrimState m) Int16 -> m () #

move :: PrimMonad m => MVec n (PrimState m) Int16 -> MVec n (PrimState m) Int16 -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Int16) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Int16 -> Int -> m Int16 #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Int16 -> Int -> Int16 -> m () #

Arity n => MVector (MVec n) Int8 # 

Methods

overlaps :: MVec n s Int8 -> MVec n s Int8 -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Int8 -> MVec n (PrimState m) Int8 -> m () #

move :: PrimMonad m => MVec n (PrimState m) Int8 -> MVec n (PrimState m) Int8 -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Int8) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Int8 -> Int -> m Int8 #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Int8 -> Int -> Int8 -> m () #

Arity n => MVector (MVec n) Int # 

Methods

overlaps :: MVec n s Int -> MVec n s Int -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Int -> MVec n (PrimState m) Int -> m () #

move :: PrimMonad m => MVec n (PrimState m) Int -> MVec n (PrimState m) Int -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Int) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Int -> Int -> m Int #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Int -> Int -> Int -> m () #

Arity n => MVector (MVec n) Bool # 

Methods

overlaps :: MVec n s Bool -> MVec n s Bool -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) Bool -> MVec n (PrimState m) Bool -> m () #

move :: PrimMonad m => MVec n (PrimState m) Bool -> MVec n (PrimState m) Bool -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) Bool) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) Bool -> Int -> m Bool #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) Bool -> Int -> Bool -> m () #

Arity n => MVector (MVec n) () # 

Methods

overlaps :: MVec n s () -> MVec n s () -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) () -> MVec n (PrimState m) () -> m () #

move :: PrimMonad m => MVec n (PrimState m) () -> MVec n (PrimState m) () -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) ()) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) () -> Int -> m () #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) () -> Int -> () -> m () #

(Arity n, MVector (MVec n) a) => MVector (MVec n) (Complex a) # 

Methods

overlaps :: MVec n s (Complex a) -> MVec n s (Complex a) -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) (Complex a) -> MVec n (PrimState m) (Complex a) -> m () #

move :: PrimMonad m => MVec n (PrimState m) (Complex a) -> MVec n (PrimState m) (Complex a) -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) (Complex a)) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) (Complex a) -> Int -> m (Complex a) #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) (Complex a) -> Int -> Complex a -> m () #

(Arity n, MVector (MVec n) a, MVector (MVec n) b) => MVector (MVec n) (a, b) # 

Methods

overlaps :: MVec n s (a, b) -> MVec n s (a, b) -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) (a, b) -> MVec n (PrimState m) (a, b) -> m () #

move :: PrimMonad m => MVec n (PrimState m) (a, b) -> MVec n (PrimState m) (a, b) -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) (a, b)) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) (a, b) -> Int -> m (a, b) #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) (a, b) -> Int -> (a, b) -> m () #

(Arity n, MVector (MVec n) a, MVector (MVec n) b, MVector (MVec n) c) => MVector (MVec n) (a, b, c) # 

Methods

overlaps :: MVec n s (a, b, c) -> MVec n s (a, b, c) -> Bool #

copy :: PrimMonad m => MVec n (PrimState m) (a, b, c) -> MVec n (PrimState m) (a, b, c) -> m () #

move :: PrimMonad m => MVec n (PrimState m) (a, b, c) -> MVec n (PrimState m) (a, b, c) -> m () #

new :: PrimMonad m => m (MVec n (PrimState m) (a, b, c)) #

unsafeRead :: PrimMonad m => MVec n (PrimState m) (a, b, c) -> Int -> m (a, b, c) #

unsafeWrite :: PrimMonad m => MVec n (PrimState m) (a, b, c) -> Int -> (a, b, c) -> m () #

lengthM :: forall v s a. Arity (DimM v) => v s a -> Int #

Length of mutable vector. Function doesn't evaluate its argument.

read :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> m a #

Read value at index with bound checks.

write :: (PrimMonad m, MVector v a) => v (PrimState m) a -> Int -> a -> m () #

Write value at index with bound checks.

clone :: (PrimMonad m, MVector v a) => v (PrimState m) a -> m (v (PrimState m) a) #

Create copy of vector.

Immutable vectors

class (Dim v ~ DimM (Mutable v), MVector (Mutable v) a) => IVector v a where #

Type class for immutable vectors

Minimal complete definition

unsafeFreeze, unsafeThaw, unsafeIndex

Methods

unsafeFreeze :: PrimMonad m => Mutable v (PrimState m) a -> m (v a) #

Convert vector to immutable state. Mutable vector must not be modified afterwards.

unsafeThaw :: PrimMonad m => v a -> m (Mutable v (PrimState m) a) #

Convert immutable vector to mutable. Immutable vector must not be used afterwards.

unsafeIndex :: v a -> Int -> a #

Get element at specified index without bounds check.

Instances

Arity n => IVector (Vec n) a # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) a -> m (Vec n a) #

unsafeThaw :: PrimMonad m => Vec n a -> m (Mutable (Vec n) (PrimState m) a) #

unsafeIndex :: Vec n a -> Int -> a #

(Arity n, Prim a) => IVector (Vec n) a # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) a -> m (Vec n a) #

unsafeThaw :: PrimMonad m => Vec n a -> m (Mutable (Vec n) (PrimState m) a) #

unsafeIndex :: Vec n a -> Int -> a #

(Arity n, Storable a) => IVector (Vec n) a # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) a -> m (Vec n a) #

unsafeThaw :: PrimMonad m => Vec n a -> m (Mutable (Vec n) (PrimState m) a) #

unsafeIndex :: Vec n a -> Int -> a #

Arity n => IVector (Vec n) Double # 
Arity n => IVector (Vec n) Float # 
Arity n => IVector (Vec n) Char # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) Char -> m (Vec n Char) #

unsafeThaw :: PrimMonad m => Vec n Char -> m (Mutable (Vec n) (PrimState m) Char) #

unsafeIndex :: Vec n Char -> Int -> Char #

Arity n => IVector (Vec n) Word64 # 
Arity n => IVector (Vec n) Word32 # 
Arity n => IVector (Vec n) Word16 # 
Arity n => IVector (Vec n) Word8 # 
Arity n => IVector (Vec n) Word # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) Word -> m (Vec n Word) #

unsafeThaw :: PrimMonad m => Vec n Word -> m (Mutable (Vec n) (PrimState m) Word) #

unsafeIndex :: Vec n Word -> Int -> Word #

Arity n => IVector (Vec n) Int64 # 
Arity n => IVector (Vec n) Int32 # 
Arity n => IVector (Vec n) Int16 # 
Arity n => IVector (Vec n) Int8 # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) Int8 -> m (Vec n Int8) #

unsafeThaw :: PrimMonad m => Vec n Int8 -> m (Mutable (Vec n) (PrimState m) Int8) #

unsafeIndex :: Vec n Int8 -> Int -> Int8 #

Arity n => IVector (Vec n) Int # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) Int -> m (Vec n Int) #

unsafeThaw :: PrimMonad m => Vec n Int -> m (Mutable (Vec n) (PrimState m) Int) #

unsafeIndex :: Vec n Int -> Int -> Int #

Arity n => IVector (Vec n) Bool # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) Bool -> m (Vec n Bool) #

unsafeThaw :: PrimMonad m => Vec n Bool -> m (Mutable (Vec n) (PrimState m) Bool) #

unsafeIndex :: Vec n Bool -> Int -> Bool #

Arity n => IVector (Vec n) () # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) () -> m (Vec n ()) #

unsafeThaw :: PrimMonad m => Vec n () -> m (Mutable (Vec n) (PrimState m) ()) #

unsafeIndex :: Vec n () -> Int -> () #

(Arity n, IVector (Vec n) a) => IVector (Vec n) (Complex a) # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) (Complex a) -> m (Vec n (Complex a)) #

unsafeThaw :: PrimMonad m => Vec n (Complex a) -> m (Mutable (Vec n) (PrimState m) (Complex a)) #

unsafeIndex :: Vec n (Complex a) -> Int -> Complex a #

(Arity n, IVector (Vec n) a, IVector (Vec n) b) => IVector (Vec n) (a, b) # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) (a, b) -> m (Vec n (a, b)) #

unsafeThaw :: PrimMonad m => Vec n (a, b) -> m (Mutable (Vec n) (PrimState m) (a, b)) #

unsafeIndex :: Vec n (a, b) -> Int -> (a, b) #

(Arity n, Vector (Vec n) a, Vector (Vec n) b, Vector (Vec n) c, IVector (Vec n) a, IVector (Vec n) b, IVector (Vec n) c) => IVector (Vec n) (a, b, c) # 

Methods

unsafeFreeze :: PrimMonad m => Mutable (Vec n) (PrimState m) (a, b, c) -> m (Vec n (a, b, c)) #

unsafeThaw :: PrimMonad m => Vec n (a, b, c) -> m (Mutable (Vec n) (PrimState m) (a, b, c)) #

unsafeIndex :: Vec n (a, b, c) -> Int -> (a, b, c) #

index :: IVector v a => v a -> Int -> a #

lengthI :: IVector v a => v a -> Int #

Length of immutable vector. Function doesn't evaluate its argument.

freeze :: (PrimMonad m, IVector v a) => Mutable v (PrimState m) a -> m (v a) #

Safely convert mutable vector to immutable.

thaw :: (PrimMonad m, IVector v a) => v a -> m (Mutable v (PrimState m) a) #

Safely convert immutable vector to mutable.

Vector API

constructVec :: forall v a. (Arity (Dim v), IVector v a) => Fun (Dim v) a (v a) #

Generic construct implementation for array-based vectors.

inspectVec :: forall v a b. (Arity (Dim v), IVector v a) => v a -> Fun (Dim v) a b -> b #

Generic inspect implementation for array-based vectors.