Copyright	(c) Andrey Mulik 2019
License	BSD-style
Maintainer	work.a.mulik@gmail.com
Portability	portable
Safe Haskell	Trustworthy
Language	Haskell2010

SDP.Vector.Unboxed

Contents

Exports
Vector
Orphan instances

Description

SDP.Vector.Unboxed provides Vector - immutable strict unboxed vector.

This module uses the Unbox and Unboxed classes. Looking at similar names and, in general, general purpose, they are fundamentally different:

Despite similar names, classes are very different: * Unboxed is a low-level interface that generalizes access to data. * Unbox is a service class that combines Vector and MVector.

Synopsis

module SDP.Indexed
module SDP.Unboxed
module SDP.Sort
module SDP.Scan
class (Vector Vector a, MVector MVector a) => Unbox a
data family Vector a

Exports

module SDP.Indexed

module SDP.Unboxed

module SDP.Sort

module SDP.Scan

Vector

class (Vector Vector a, MVector MVector a) => Unbox a #

Instances

Instances details

Unbox Bool
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Char
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Double
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Float
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int8
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int16
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int32
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Int64
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word8
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word16
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word32
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Word64
Instance details Defined in Data.Vector.Unboxed.Base
Unbox ()
Instance details Defined in Data.Vector.Unboxed.Base
Unbox All
Instance details Defined in Data.Vector.Unboxed.Base
Unbox Any
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Complex a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Min a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Max a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (First a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Last a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Product a)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Down a)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b) => Unbox (a, b)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b) => Unbox (Arg a b)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox a => Unbox (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox (f a) => Unbox (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Unbox (a, b, c, d, e)
Instance details Defined in Data.Vector.Unboxed.Base
Unbox (f (g a)) => Unbox (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Unbox (a, b, c, d, e, f)
Instance details Defined in Data.Vector.Unboxed.Base

data family Vector a #

Instances

Instances details

NFData1 Vector	Since: vector-0.12.1.0
Instance details Defined in Data.Vector.Unboxed.Base Methods liftRnf :: (a -> ()) -> Vector a -> () #
Vector Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Bool -> m (Vector Bool) # basicUnsafeThaw :: PrimMonad m => Vector Bool -> m (Mutable Vector (PrimState m) Bool) # basicLength :: Vector Bool -> Int # basicUnsafeSlice :: Int -> Int -> Vector Bool -> Vector Bool # basicUnsafeIndexM :: Monad m => Vector Bool -> Int -> m Bool # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Bool -> Vector Bool -> m () # elemseq :: Vector Bool -> Bool -> b -> b #
Vector Vector Char
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char) # basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char) # basicLength :: Vector Char -> Int # basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char # basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m () # elemseq :: Vector Char -> Char -> b -> b #
Vector Vector Double
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Double -> m (Vector Double) # basicUnsafeThaw :: PrimMonad m => Vector Double -> m (Mutable Vector (PrimState m) Double) # basicLength :: Vector Double -> Int # basicUnsafeSlice :: Int -> Int -> Vector Double -> Vector Double # basicUnsafeIndexM :: Monad m => Vector Double -> Int -> m Double # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Double -> Vector Double -> m () # elemseq :: Vector Double -> Double -> b -> b #
Vector Vector Float
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Float -> m (Vector Float) # basicUnsafeThaw :: PrimMonad m => Vector Float -> m (Mutable Vector (PrimState m) Float) # basicLength :: Vector Float -> Int # basicUnsafeSlice :: Int -> Int -> Vector Float -> Vector Float # basicUnsafeIndexM :: Monad m => Vector Float -> Int -> m Float # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Float -> Vector Float -> m () # elemseq :: Vector Float -> Float -> b -> b #
Vector Vector Int
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int -> m (Vector Int) # basicUnsafeThaw :: PrimMonad m => Vector Int -> m (Mutable Vector (PrimState m) Int) # basicLength :: Vector Int -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int -> Vector Int # basicUnsafeIndexM :: Monad m => Vector Int -> Int -> m Int # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int -> Vector Int -> m () # elemseq :: Vector Int -> Int -> b -> b #
Vector Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> m (Vector Int8) # basicUnsafeThaw :: PrimMonad m => Vector Int8 -> m (Mutable Vector (PrimState m) Int8) # basicLength :: Vector Int8 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int8 -> Vector Int8 # basicUnsafeIndexM :: Monad m => Vector Int8 -> Int -> m Int8 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int8 -> Vector Int8 -> m () # elemseq :: Vector Int8 -> Int8 -> b -> b #
Vector Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> m (Vector Int16) # basicUnsafeThaw :: PrimMonad m => Vector Int16 -> m (Mutable Vector (PrimState m) Int16) # basicLength :: Vector Int16 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int16 -> Vector Int16 # basicUnsafeIndexM :: Monad m => Vector Int16 -> Int -> m Int16 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int16 -> Vector Int16 -> m () # elemseq :: Vector Int16 -> Int16 -> b -> b #
Vector Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> m (Vector Int32) # basicUnsafeThaw :: PrimMonad m => Vector Int32 -> m (Mutable Vector (PrimState m) Int32) # basicLength :: Vector Int32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int32 -> Vector Int32 # basicUnsafeIndexM :: Monad m => Vector Int32 -> Int -> m Int32 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int32 -> Vector Int32 -> m () # elemseq :: Vector Int32 -> Int32 -> b -> b #
Vector Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> m (Vector Int64) # basicUnsafeThaw :: PrimMonad m => Vector Int64 -> m (Mutable Vector (PrimState m) Int64) # basicLength :: Vector Int64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Int64 -> Vector Int64 # basicUnsafeIndexM :: Monad m => Vector Int64 -> Int -> m Int64 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Int64 -> Vector Int64 -> m () # elemseq :: Vector Int64 -> Int64 -> b -> b #
Vector Vector Word
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word -> m (Vector Word) # basicUnsafeThaw :: PrimMonad m => Vector Word -> m (Mutable Vector (PrimState m) Word) # basicLength :: Vector Word -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word -> Vector Word # basicUnsafeIndexM :: Monad m => Vector Word -> Int -> m Word # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word -> Vector Word -> m () # elemseq :: Vector Word -> Word -> b -> b #
Vector Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> m (Vector Word8) # basicUnsafeThaw :: PrimMonad m => Vector Word8 -> m (Mutable Vector (PrimState m) Word8) # basicLength :: Vector Word8 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word8 -> Vector Word8 # basicUnsafeIndexM :: Monad m => Vector Word8 -> Int -> m Word8 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word8 -> Vector Word8 -> m () # elemseq :: Vector Word8 -> Word8 -> b -> b #
Vector Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> m (Vector Word16) # basicUnsafeThaw :: PrimMonad m => Vector Word16 -> m (Mutable Vector (PrimState m) Word16) # basicLength :: Vector Word16 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word16 -> Vector Word16 # basicUnsafeIndexM :: Monad m => Vector Word16 -> Int -> m Word16 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word16 -> Vector Word16 -> m () # elemseq :: Vector Word16 -> Word16 -> b -> b #
Vector Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> m (Vector Word32) # basicUnsafeThaw :: PrimMonad m => Vector Word32 -> m (Mutable Vector (PrimState m) Word32) # basicLength :: Vector Word32 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word32 -> Vector Word32 # basicUnsafeIndexM :: Monad m => Vector Word32 -> Int -> m Word32 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word32 -> Vector Word32 -> m () # elemseq :: Vector Word32 -> Word32 -> b -> b #
Vector Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> m (Vector Word64) # basicUnsafeThaw :: PrimMonad m => Vector Word64 -> m (Mutable Vector (PrimState m) Word64) # basicLength :: Vector Word64 -> Int # basicUnsafeSlice :: Int -> Int -> Vector Word64 -> Vector Word64 # basicUnsafeIndexM :: Monad m => Vector Word64 -> Int -> m Word64 # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Word64 -> Vector Word64 -> m () # elemseq :: Vector Word64 -> Word64 -> b -> b #
Vector Vector ()
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) () -> m (Vector ()) # basicUnsafeThaw :: PrimMonad m => Vector () -> m (Mutable Vector (PrimState m) ()) # basicLength :: Vector () -> Int # basicUnsafeSlice :: Int -> Int -> Vector () -> Vector () # basicUnsafeIndexM :: Monad m => Vector () -> Int -> m () # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) () -> Vector () -> m () # elemseq :: Vector () -> () -> b -> b #
Vector Vector All
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) All -> m (Vector All) # basicUnsafeThaw :: PrimMonad m => Vector All -> m (Mutable Vector (PrimState m) All) # basicLength :: Vector All -> Int # basicUnsafeSlice :: Int -> Int -> Vector All -> Vector All # basicUnsafeIndexM :: Monad m => Vector All -> Int -> m All # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) All -> Vector All -> m () # elemseq :: Vector All -> All -> b -> b #
Vector Vector Any
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Any -> m (Vector Any) # basicUnsafeThaw :: PrimMonad m => Vector Any -> m (Mutable Vector (PrimState m) Any) # basicLength :: Vector Any -> Int # basicUnsafeSlice :: Int -> Int -> Vector Any -> Vector Any # basicUnsafeIndexM :: Monad m => Vector Any -> Int -> m Any # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Any -> Vector Any -> m () # elemseq :: Vector Any -> Any -> b -> b #
Unbox a => Vector Vector (Complex a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> m (Vector (Complex a)) # basicUnsafeThaw :: PrimMonad m => Vector (Complex a) -> m (Mutable Vector (PrimState m) (Complex a)) # basicLength :: Vector (Complex a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a) # basicUnsafeIndexM :: Monad m => Vector (Complex a) -> Int -> m (Complex a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> Vector (Complex a) -> m () # elemseq :: Vector (Complex a) -> Complex a -> b -> b #
Unbox a => Vector Vector (Min a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Min a) -> m (Vector (Min a)) # basicUnsafeThaw :: PrimMonad m => Vector (Min a) -> m (Mutable Vector (PrimState m) (Min a)) # basicLength :: Vector (Min a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Min a) -> Vector (Min a) # basicUnsafeIndexM :: Monad m => Vector (Min a) -> Int -> m (Min a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Min a) -> Vector (Min a) -> m () # elemseq :: Vector (Min a) -> Min a -> b -> b #
Unbox a => Vector Vector (Max a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Max a) -> m (Vector (Max a)) # basicUnsafeThaw :: PrimMonad m => Vector (Max a) -> m (Mutable Vector (PrimState m) (Max a)) # basicLength :: Vector (Max a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Max a) -> Vector (Max a) # basicUnsafeIndexM :: Monad m => Vector (Max a) -> Int -> m (Max a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Max a) -> Vector (Max a) -> m () # elemseq :: Vector (Max a) -> Max a -> b -> b #
Unbox a => Vector Vector (First a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (First a) -> m (Vector (First a)) # basicUnsafeThaw :: PrimMonad m => Vector (First a) -> m (Mutable Vector (PrimState m) (First a)) # basicLength :: Vector (First a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (First a) -> Vector (First a) # basicUnsafeIndexM :: Monad m => Vector (First a) -> Int -> m (First a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (First a) -> Vector (First a) -> m () # elemseq :: Vector (First a) -> First a -> b -> b #
Unbox a => Vector Vector (Last a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Last a) -> m (Vector (Last a)) # basicUnsafeThaw :: PrimMonad m => Vector (Last a) -> m (Mutable Vector (PrimState m) (Last a)) # basicLength :: Vector (Last a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Last a) -> Vector (Last a) # basicUnsafeIndexM :: Monad m => Vector (Last a) -> Int -> m (Last a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Last a) -> Vector (Last a) -> m () # elemseq :: Vector (Last a) -> Last a -> b -> b #
Unbox a => Vector Vector (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (WrappedMonoid a) -> m (Vector (WrappedMonoid a)) # basicUnsafeThaw :: PrimMonad m => Vector (WrappedMonoid a) -> m (Mutable Vector (PrimState m) (WrappedMonoid a)) # basicLength :: Vector (WrappedMonoid a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (WrappedMonoid a) -> Vector (WrappedMonoid a) # basicUnsafeIndexM :: Monad m => Vector (WrappedMonoid a) -> Int -> m (WrappedMonoid a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (WrappedMonoid a) -> Vector (WrappedMonoid a) -> m () # elemseq :: Vector (WrappedMonoid a) -> WrappedMonoid a -> b -> b #
Unbox a => Vector Vector (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Identity a) -> m (Vector (Identity a)) # basicUnsafeThaw :: PrimMonad m => Vector (Identity a) -> m (Mutable Vector (PrimState m) (Identity a)) # basicLength :: Vector (Identity a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Identity a) -> Vector (Identity a) # basicUnsafeIndexM :: Monad m => Vector (Identity a) -> Int -> m (Identity a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Identity a) -> Vector (Identity a) -> m () # elemseq :: Vector (Identity a) -> Identity a -> b -> b #
Unbox a => Vector Vector (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Dual a) -> m (Vector (Dual a)) # basicUnsafeThaw :: PrimMonad m => Vector (Dual a) -> m (Mutable Vector (PrimState m) (Dual a)) # basicLength :: Vector (Dual a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Dual a) -> Vector (Dual a) # basicUnsafeIndexM :: Monad m => Vector (Dual a) -> Int -> m (Dual a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Dual a) -> Vector (Dual a) -> m () # elemseq :: Vector (Dual a) -> Dual a -> b -> b #
Unbox a => Vector Vector (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Sum a) -> m (Vector (Sum a)) # basicUnsafeThaw :: PrimMonad m => Vector (Sum a) -> m (Mutable Vector (PrimState m) (Sum a)) # basicLength :: Vector (Sum a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Sum a) -> Vector (Sum a) # basicUnsafeIndexM :: Monad m => Vector (Sum a) -> Int -> m (Sum a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Sum a) -> Vector (Sum a) -> m () # elemseq :: Vector (Sum a) -> Sum a -> b -> b #
Unbox a => Vector Vector (Product a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Product a) -> m (Vector (Product a)) # basicUnsafeThaw :: PrimMonad m => Vector (Product a) -> m (Mutable Vector (PrimState m) (Product a)) # basicLength :: Vector (Product a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Product a) -> Vector (Product a) # basicUnsafeIndexM :: Monad m => Vector (Product a) -> Int -> m (Product a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Product a) -> Vector (Product a) -> m () # elemseq :: Vector (Product a) -> Product a -> b -> b #
Unbox a => Vector Vector (Down a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Down a) -> m (Vector (Down a)) # basicUnsafeThaw :: PrimMonad m => Vector (Down a) -> m (Mutable Vector (PrimState m) (Down a)) # basicLength :: Vector (Down a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Down a) -> Vector (Down a) # basicUnsafeIndexM :: Monad m => Vector (Down a) -> Int -> m (Down a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Down a) -> Vector (Down a) -> m () # elemseq :: Vector (Down a) -> Down a -> b -> b #
(MonadIO io, Unboxed e, Unbox e) => Thaw io (Vector e) (MIOUblist io e) Source #
Instance details Defined in SDP.Vector.Unboxed Methods thaw :: Vector e -> io (MIOUblist io e) # unsafeThaw :: Vector e -> io (MIOUblist io e) #
(MonadIO io, Unboxed e, Unbox e) => Thaw io (Vector e) (MIOBytes# io e) Source #
Instance details Defined in SDP.Vector.Unboxed Methods thaw :: Vector e -> io (MIOBytes# io e) # unsafeThaw :: Vector e -> io (MIOBytes# io e) #
(Unbox a, Unbox b) => Vector Vector (a, b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> m (Vector (a, b)) # basicUnsafeThaw :: PrimMonad m => Vector (a, b) -> m (Mutable Vector (PrimState m) (a, b)) # basicLength :: Vector (a, b) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b) -> Vector (a, b) # basicUnsafeIndexM :: Monad m => Vector (a, b) -> Int -> m (a, b) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b) -> Vector (a, b) -> m () # elemseq :: Vector (a, b) -> (a, b) -> b0 -> b0 #
(Unbox a, Unbox b) => Vector Vector (Arg a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Arg a b) -> m (Vector (Arg a b)) # basicUnsafeThaw :: PrimMonad m => Vector (Arg a b) -> m (Mutable Vector (PrimState m) (Arg a b)) # basicLength :: Vector (Arg a b) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Arg a b) -> Vector (Arg a b) # basicUnsafeIndexM :: Monad m => Vector (Arg a b) -> Int -> m (Arg a b) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Arg a b) -> Vector (Arg a b) -> m () # elemseq :: Vector (Arg a b) -> Arg a b -> b0 -> b0 #
(MonadIO io, Unboxed e, Unbox e) => Freeze io (MIOUblist io e) (Vector e) Source #
Instance details Defined in SDP.Vector.Unboxed Methods freeze :: MIOUblist io e -> io (Vector e) # unsafeFreeze :: MIOUblist io e -> io (Vector e) #
(MonadIO io, Unboxed e, Unbox e) => Freeze io (MIOBytes# io e) (Vector e) Source #
Instance details Defined in SDP.Vector.Unboxed Methods freeze :: MIOBytes# io e -> io (Vector e) # unsafeFreeze :: MIOBytes# io e -> io (Vector e) #
(Unbox a, Unbox b, Unbox c) => Vector Vector (a, b, c)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> m (Vector (a, b, c)) # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c) -> m (Mutable Vector (PrimState m) (a, b, c)) # basicLength :: Vector (a, b, c) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c) -> Vector (a, b, c) # basicUnsafeIndexM :: Monad m => Vector (a, b, c) -> Int -> m (a, b, c) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c) -> Vector (a, b, c) -> m () # elemseq :: Vector (a, b, c) -> (a, b, c) -> b0 -> b0 #
Unbox a => Vector Vector (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> m (Vector (Const a b)) # basicUnsafeThaw :: PrimMonad m => Vector (Const a b) -> m (Mutable Vector (PrimState m) (Const a b)) # basicLength :: Vector (Const a b) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b) # basicUnsafeIndexM :: Monad m => Vector (Const a b) -> Int -> m (Const a b) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> Vector (Const a b) -> m () # elemseq :: Vector (Const a b) -> Const a b -> b0 -> b0 #
Unbox (f a) => Vector Vector (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Alt f a) -> m (Vector (Alt f a)) # basicUnsafeThaw :: PrimMonad m => Vector (Alt f a) -> m (Mutable Vector (PrimState m) (Alt f a)) # basicLength :: Vector (Alt f a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Alt f a) -> Vector (Alt f a) # basicUnsafeIndexM :: Monad m => Vector (Alt f a) -> Int -> m (Alt f a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Alt f a) -> Vector (Alt f a) -> m () # elemseq :: Vector (Alt f a) -> Alt f a -> b -> b #
(Unbox a, Unbox b, Unbox c, Unbox d) => Vector Vector (a, b, c, d)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> m (Vector (a, b, c, d)) # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d) -> m (Mutable Vector (PrimState m) (a, b, c, d)) # basicLength :: Vector (a, b, c, d) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d) -> Vector (a, b, c, d) # basicUnsafeIndexM :: Monad m => Vector (a, b, c, d) -> Int -> m (a, b, c, d) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d) -> Vector (a, b, c, d) -> m () # elemseq :: Vector (a, b, c, d) -> (a, b, c, d) -> b0 -> b0 #
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Vector Vector (a, b, c, d, e)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> m (Vector (a, b, c, d, e)) # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e) -> m (Mutable Vector (PrimState m) (a, b, c, d, e)) # basicLength :: Vector (a, b, c, d, e) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e) -> Vector (a, b, c, d, e) # basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e) -> Int -> m (a, b, c, d, e) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e) -> Vector (a, b, c, d, e) -> m () # elemseq :: Vector (a, b, c, d, e) -> (a, b, c, d, e) -> b0 -> b0 #
Unbox (f (g a)) => Vector Vector (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Compose f g a) -> m (Vector (Compose f g a)) # basicUnsafeThaw :: PrimMonad m => Vector (Compose f g a) -> m (Mutable Vector (PrimState m) (Compose f g a)) # basicLength :: Vector (Compose f g a) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (Compose f g a) -> Vector (Compose f g a) # basicUnsafeIndexM :: Monad m => Vector (Compose f g a) -> Int -> m (Compose f g a) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Compose f g a) -> Vector (Compose f g a) -> m () # elemseq :: Vector (Compose f g a) -> Compose f g a -> b -> b #
(Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Vector Vector (a, b, c, d, e, f)
Instance details Defined in Data.Vector.Unboxed.Base Methods basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> m (Vector (a, b, c, d, e, f)) # basicUnsafeThaw :: PrimMonad m => Vector (a, b, c, d, e, f) -> m (Mutable Vector (PrimState m) (a, b, c, d, e, f)) # basicLength :: Vector (a, b, c, d, e, f) -> Int # basicUnsafeSlice :: Int -> Int -> Vector (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) # basicUnsafeIndexM :: Monad m => Vector (a, b, c, d, e, f) -> Int -> m (a, b, c, d, e, f) # basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a, b, c, d, e, f) -> Vector (a, b, c, d, e, f) -> m () # elemseq :: Vector (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> b0 -> b0 #
(Data a, Unbox a) => Data (Vector a)
Instance details Defined in Data.Vector.Unboxed.Base Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vector a -> c (Vector a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vector a) # toConstr :: Vector a -> Constr # dataTypeOf :: Vector a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vector a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vector a)) # gmapT :: (forall b. Data b => b -> b) -> Vector a -> Vector a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vector a -> r # gmapQ :: (forall d. Data d => d -> u) -> Vector a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Vector a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vector a -> m (Vector a) #
NFData (Vector a)
Instance details Defined in Data.Vector.Unboxed.Base Methods rnf :: Vector a -> () #
Unbox e => Nullable (Vector e) Source #
Instance details Defined in SDP.Vector.Unboxed Methods lzero :: Vector e # isNull :: Vector e -> Bool #
Unbox e => Estimate (Vector e) Source #
Instance details Defined in SDP.Vector.Unboxed Methods (<.=>) :: Vector e -> Int -> Ordering # (<==>) :: Compare (Vector e) # (.==) :: Vector e -> Int -> Bool # (./=) :: Vector e -> Int -> Bool # (.<=) :: Vector e -> Int -> Bool # (.>=) :: Vector e -> Int -> Bool # (.<) :: Vector e -> Int -> Bool # (.>) :: Vector e -> Int -> Bool # (.<.) :: Vector e -> Vector e -> Bool # (.>.) :: Vector e -> Vector e -> Bool # (.<=.) :: Vector e -> Vector e -> Bool # (.>=.) :: Vector e -> Vector e -> Bool # (.==.) :: Vector e -> Vector e -> Bool # (./=.) :: Vector e -> Vector e -> Bool #
Unbox e => Scan (Vector e) e Source #
Instance details Defined in SDP.Vector.Unboxed Methods scanl :: (b -> e -> b) -> b -> Vector e -> [b] # scanl' :: (b -> e -> b) -> b -> Vector e -> [b] # scanr :: (e -> b -> b) -> b -> Vector e -> [b] # scanr' :: (e -> b -> b) -> b -> Vector e -> [b] # scanl1 :: (e -> e -> e) -> Vector e -> [e] # scanr1 :: (e -> e -> e) -> Vector e -> [e] #
Unbox e => Bordered (Vector e) Int Source #
Instance details Defined in SDP.Vector.Unboxed Methods bounds :: Vector e -> (Int, Int) # lower :: Vector e -> Int # upper :: Vector e -> Int # sizeOf :: Vector e -> Int # sizesOf :: Vector e -> [Int] # indexIn :: Vector e -> Int -> Bool # indices :: Vector e -> [Int] # indexOf :: Vector e -> Int -> Int # offsetOf :: Vector e -> Int -> Int #
Unbox e => Linear (Vector e) e Source #
Instance details Defined in SDP.Vector.Unboxed Methods uncons :: Vector e -> (e, Vector e) # uncons' :: Vector e -> Maybe (e, Vector e) # toHead :: e -> Vector e -> Vector e # head :: Vector e -> e # tail :: Vector e -> Vector e # unsnoc :: Vector e -> (Vector e, e) # unsnoc' :: Vector e -> Maybe (Vector e, e) # toLast :: Vector e -> e -> Vector e # init :: Vector e -> Vector e # last :: Vector e -> e # single :: e -> Vector e # (++) :: Vector e -> Vector e -> Vector e # replicate :: Int -> e -> Vector e # fromList :: [e] -> Vector e # fromListN :: Int -> [e] -> Vector e # listR :: Vector e -> [e] # listL :: Vector e -> [e] # fromFoldable :: Foldable f => f e -> Vector e # (!^) :: Vector e -> Int -> e # write :: Vector e -> Int -> e -> Vector e # concat :: Foldable f => f (Vector e) -> Vector e # concatMap :: Foldable f => (a -> Vector e) -> f a -> Vector e # intersperse :: e -> Vector e -> Vector e # filter :: (e -> Bool) -> Vector e -> Vector e # except :: (e -> Bool) -> Vector e -> Vector e # partition :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # partitions :: Foldable f => f (e -> Bool) -> Vector e -> [Vector e] # select :: (e -> Maybe a) -> Vector e -> [a] # select' :: (t e ~ Vector e, Linear1 t a) => (e -> Maybe a) -> Vector e -> t a # extract :: (e -> Maybe a) -> Vector e -> ([a], Vector e) # extract' :: (t e ~ Vector e, Linear1 t a) => (e -> Maybe a) -> Vector e -> (t a, Vector e) # selects :: Foldable f => f (e -> Maybe a) -> Vector e -> ([[a]], Vector e) # selects' :: (Foldable f, t e ~ Vector e, Linear1 t a) => f (e -> Maybe a) -> Vector e -> ([t a], Vector e) # isSubseqOf :: Vector e -> Vector e -> Bool # reverse :: Vector e -> Vector e # force :: Vector e -> Vector e # subsequences :: Vector e -> [Vector e] # iterate :: Int -> (e -> e) -> e -> Vector e # nub :: Vector e -> Vector e # nubBy :: Equal e -> Vector e -> Vector e # ofoldr :: (Int -> e -> b -> b) -> b -> Vector e -> b # ofoldl :: (Int -> b -> e -> b) -> b -> Vector e -> b # ofoldr' :: (Int -> e -> b -> b) -> b -> Vector e -> b # ofoldl' :: (Int -> b -> e -> b) -> b -> Vector e -> b # o_foldr :: (e -> b -> b) -> b -> Vector e -> b # o_foldl :: (b -> e -> b) -> b -> Vector e -> b # o_foldr' :: (e -> b -> b) -> b -> Vector e -> b # o_foldl' :: (b -> e -> b) -> b -> Vector e -> b #
Unbox e => Split (Vector e) e Source #
Instance details Defined in SDP.Vector.Unboxed Methods take :: Int -> Vector e -> Vector e # drop :: Int -> Vector e -> Vector e # keep :: Int -> Vector e -> Vector e # sans :: Int -> Vector e -> Vector e # save :: Int -> Vector e -> Vector e # skip :: Int -> Vector e -> Vector e # split :: Int -> Vector e -> (Vector e, Vector e) # divide :: Int -> Vector e -> (Vector e, Vector e) # splits :: Foldable f => f Int -> Vector e -> [Vector e] # divides :: Foldable f => f Int -> Vector e -> [Vector e] # parts :: Foldable f => f Int -> Vector e -> [Vector e] # chunks :: Int -> Vector e -> [Vector e] # splitBy :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # divideBy :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # splitsBy :: (e -> Bool) -> Vector e -> [Vector e] # splitsOn :: Vector e -> Vector e -> [Vector e] # replaceBy :: Vector e -> Vector e -> Vector e -> Vector e # removeAll :: Vector e -> Vector e -> Vector e # combo :: Equal e -> Vector e -> Int # justifyL :: Int -> e -> Vector e -> Vector e # justifyR :: Int -> e -> Vector e -> Vector e # each :: Int -> Vector e -> Vector e # eachFrom :: Int -> Int -> Vector e -> Vector e # isPrefixOf :: Vector e -> Vector e -> Bool # isSuffixOf :: Vector e -> Vector e -> Bool # isInfixOf :: Vector e -> Vector e -> Bool # prefix :: (e -> Bool) -> Vector e -> Int # suffix :: (e -> Bool) -> Vector e -> Int # infixes :: Vector e -> Vector e -> [Int] # dropSide :: (e -> Bool) -> Vector e -> Vector e # takeWhile :: (e -> Bool) -> Vector e -> Vector e # dropWhile :: (e -> Bool) -> Vector e -> Vector e # takeEnd :: (e -> Bool) -> Vector e -> Vector e # dropEnd :: (e -> Bool) -> Vector e -> Vector e # spanl :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # breakl :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # spanr :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # breakr :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # selectWhile :: (e -> Maybe a) -> Vector e -> [a] # selectEnd :: (e -> Maybe a) -> Vector e -> [a] # extractWhile :: (e -> Maybe a) -> Vector e -> ([a], Vector e) # extractEnd :: (e -> Maybe a) -> Vector e -> (Vector e, [a]) # selectWhile' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> t a # selectEnd' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> t a # extractWhile' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> (t a, Vector e) # extractEnd' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> (Vector e, t a) #
(Unboxed e, Unbox e) => Sort (Vector e) e Source #
Instance details Defined in SDP.Vector.Unboxed Methods sortedBy :: (e -> e -> Bool) -> Vector e -> Bool # sortBy :: Compare e -> Vector e -> Vector e #
(Unboxed e, Unbox e) => Indexed (Vector e) Int e Source #
Instance details Defined in SDP.Vector.Unboxed Methods assoc :: (Int, Int) -> [(Int, e)] -> Vector e # assoc' :: (Int, Int) -> e -> [(Int, e)] -> Vector e # fromIndexed :: Indexed m j e => m -> Vector e # write' :: Vector e -> Int -> e -> Vector e # accum :: (e -> e' -> e) -> Vector e -> [(Int, e')] -> Vector e # imap :: Map m j e => (Int, Int) -> m -> (Int -> j) -> Vector e # update' :: Vector e -> (e -> e) -> Int -> Vector e # updates' :: Vector e -> (Int -> e -> e) -> Vector e #
(Unboxed e, Unbox e) => Map (Vector e) Int e Source #
Instance details Defined in SDP.Vector.Unboxed Methods assocs :: Vector e -> [(Int, e)] # toMap :: [(Int, e)] -> Vector e # toMap' :: e -> [(Int, e)] -> Vector e # insert' :: Int -> e -> Vector e -> Vector e # delete' :: Int -> Vector e -> Vector e # member' :: Int -> Vector e -> Bool # (//) :: Vector e -> [(Int, e)] -> Vector e # (.!) :: Vector e -> Int -> e # (!) :: Vector e -> Int -> e # (!?) :: Vector e -> Int -> Maybe e # filter' :: (Int -> e -> Bool) -> Vector e -> Vector e # union' :: (e -> e -> e) -> Vector e -> Vector e -> Vector e # difference' :: (e -> e -> Maybe e) -> Vector e -> Vector e -> Vector e # intersection' :: (e -> e -> e) -> Vector e -> Vector e -> Vector e # update :: Vector e -> (Int -> e -> e) -> Vector e # lookupLT' :: Int -> Vector e -> Maybe (Int, e) # lookupGT' :: Int -> Vector e -> Maybe (Int, e) # lookupLE' :: Int -> Vector e -> Maybe (Int, e) # lookupGE' :: Int -> Vector e -> Maybe (Int, e) # keys :: Vector e -> [Int] # (.$) :: (e -> Bool) -> Vector e -> Maybe Int # (*$) :: (e -> Bool) -> Vector e -> [Int] # kfoldr :: (Int -> e -> b -> b) -> b -> Vector e -> b # kfoldl :: (Int -> b -> e -> b) -> b -> Vector e -> b # kfoldr' :: (Int -> e -> b -> b) -> b -> Vector e -> b # kfoldl' :: (Int -> b -> e -> b) -> b -> Vector e -> b #
(Unboxed e, Unbox e) => Thaw (ST s) (Vector e) (STUblist s e) Source #
Instance details Defined in SDP.Vector.Unboxed Methods thaw :: Vector e -> ST s (STUblist s e) # unsafeThaw :: Vector e -> ST s (STUblist s e) #
(Unboxed e, Unbox e) => Thaw (ST s) (Vector e) (STBytes# s e) Source #
Instance details Defined in SDP.Vector.Unboxed Methods thaw :: Vector e -> ST s (STBytes# s e) # unsafeThaw :: Vector e -> ST s (STBytes# s e) #
(Unboxed e, Unbox e) => Freeze (ST s) (STUblist s e) (Vector e) Source #
Instance details Defined in SDP.Vector.Unboxed Methods freeze :: STUblist s e -> ST s (Vector e) # unsafeFreeze :: STUblist s e -> ST s (Vector e) #
(Unboxed e, Unbox e) => Freeze (ST s) (STBytes# s e) (Vector e) Source #
Instance details Defined in SDP.Vector.Unboxed Methods freeze :: STBytes# s e -> ST s (Vector e) # unsafeFreeze :: STBytes# s e -> ST s (Vector e) #
newtype Vector Bool
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Bool = V_Bool (Vector Word8)
newtype Vector Char
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Char = V_Char (Vector Char)
newtype Vector Double
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Double = V_Double (Vector Double)
newtype Vector Float
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Float = V_Float (Vector Float)
newtype Vector Int
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int = V_Int (Vector Int)
newtype Vector Int8
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int8 = V_Int8 (Vector Int8)
newtype Vector Int16
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int16 = V_Int16 (Vector Int16)
newtype Vector Int32
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int32 = V_Int32 (Vector Int32)
newtype Vector Int64
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Int64 = V_Int64 (Vector Int64)
newtype Vector Word
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word = V_Word (Vector Word)
newtype Vector Word8
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word8 = V_Word8 (Vector Word8)
newtype Vector Word16
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word16 = V_Word16 (Vector Word16)
newtype Vector Word32
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word32 = V_Word32 (Vector Word32)
newtype Vector Word64
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Word64 = V_Word64 (Vector Word64)
newtype Vector ()
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector () = V_Unit Int
newtype Vector All
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector All = V_All (Vector Bool)
newtype Vector Any
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector Any = V_Any (Vector Bool)
type Mutable Vector
Instance details Defined in Data.Vector.Unboxed.Base type Mutable Vector = MVector
type Item (Vector e)
Instance details Defined in Data.Vector.Unboxed type Item (Vector e) = e
newtype Vector (Complex a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Complex a) = V_Complex (Vector (a, a))
newtype Vector (Min a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Min a) = V_Min (Vector a)
newtype Vector (Max a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Max a) = V_Max (Vector a)
newtype Vector (First a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (First a) = V_First (Vector a)
newtype Vector (Last a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Last a) = V_Last (Vector a)
newtype Vector (WrappedMonoid a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (WrappedMonoid a) = V_WrappedMonoid (Vector a)
newtype Vector (Identity a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Identity a) = V_Identity (Vector a)
newtype Vector (Dual a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Dual a) = V_Dual (Vector a)
newtype Vector (Sum a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Sum a) = V_Sum (Vector a)
newtype Vector (Product a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Product a) = V_Product (Vector a)
newtype Vector (Down a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Down a) = V_Down (Vector a)
data Vector (a, b)
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b) = V_2 !Int !(Vector a) !(Vector b)
newtype Vector (Arg a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Arg a b) = V_Arg (Vector (a, b))
data Vector (a, b, c)
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b, c) = V_3 !Int !(Vector a) !(Vector b) !(Vector c)
newtype Vector (Const a b)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Const a b) = V_Const (Vector a)
newtype Vector (Alt f a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Alt f a) = V_Alt (Vector (f a))
data Vector (a, b, c, d)
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b, c, d) = V_4 !Int !(Vector a) !(Vector b) !(Vector c) !(Vector d)
data Vector (a, b, c, d, e)
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b, c, d, e) = V_5 !Int !(Vector a) !(Vector b) !(Vector c) !(Vector d) !(Vector e)
newtype Vector (Compose f g a)
Instance details Defined in Data.Vector.Unboxed.Base newtype Vector (Compose f g a) = V_Compose (Vector (f (g a)))
data Vector (a, b, c, d, e, f)
Instance details Defined in Data.Vector.Unboxed.Base data Vector (a, b, c, d, e, f) = V_6 !Int !(Vector a) !(Vector b) !(Vector c) !(Vector d) !(Vector e) !(Vector f)

Orphan instances

(MonadIO io, Unboxed e, Unbox e) => Thaw io (Vector e) (MIOUblist io e) Source #
Instance details Methods thaw :: Vector e -> io (MIOUblist io e) # unsafeThaw :: Vector e -> io (MIOUblist io e) #
(MonadIO io, Unboxed e, Unbox e) => Thaw io (Vector e) (MIOBytes# io e) Source #
Instance details Methods thaw :: Vector e -> io (MIOBytes# io e) # unsafeThaw :: Vector e -> io (MIOBytes# io e) #
(MonadIO io, Unboxed e, Unbox e) => Freeze io (MIOUblist io e) (Vector e) Source #
Instance details Methods freeze :: MIOUblist io e -> io (Vector e) # unsafeFreeze :: MIOUblist io e -> io (Vector e) #
(MonadIO io, Unboxed e, Unbox e) => Freeze io (MIOBytes# io e) (Vector e) Source #
Instance details Methods freeze :: MIOBytes# io e -> io (Vector e) # unsafeFreeze :: MIOBytes# io e -> io (Vector e) #
Unbox e => Nullable (Vector e) Source #
Instance details Methods lzero :: Vector e # isNull :: Vector e -> Bool #
Unbox e => Estimate (Vector e) Source #
Instance details Methods (<.=>) :: Vector e -> Int -> Ordering # (<==>) :: Compare (Vector e) # (.==) :: Vector e -> Int -> Bool # (./=) :: Vector e -> Int -> Bool # (.<=) :: Vector e -> Int -> Bool # (.>=) :: Vector e -> Int -> Bool # (.<) :: Vector e -> Int -> Bool # (.>) :: Vector e -> Int -> Bool # (.<.) :: Vector e -> Vector e -> Bool # (.>.) :: Vector e -> Vector e -> Bool # (.<=.) :: Vector e -> Vector e -> Bool # (.>=.) :: Vector e -> Vector e -> Bool # (.==.) :: Vector e -> Vector e -> Bool # (./=.) :: Vector e -> Vector e -> Bool #
Unbox e => Scan (Vector e) e Source #
Instance details Methods scanl :: (b -> e -> b) -> b -> Vector e -> [b] # scanl' :: (b -> e -> b) -> b -> Vector e -> [b] # scanr :: (e -> b -> b) -> b -> Vector e -> [b] # scanr' :: (e -> b -> b) -> b -> Vector e -> [b] # scanl1 :: (e -> e -> e) -> Vector e -> [e] # scanr1 :: (e -> e -> e) -> Vector e -> [e] #
Unbox e => Bordered (Vector e) Int Source #
Instance details Methods bounds :: Vector e -> (Int, Int) # lower :: Vector e -> Int # upper :: Vector e -> Int # sizeOf :: Vector e -> Int # sizesOf :: Vector e -> [Int] # indexIn :: Vector e -> Int -> Bool # indices :: Vector e -> [Int] # indexOf :: Vector e -> Int -> Int # offsetOf :: Vector e -> Int -> Int #
Unbox e => Linear (Vector e) e Source #
Instance details Methods uncons :: Vector e -> (e, Vector e) # uncons' :: Vector e -> Maybe (e, Vector e) # toHead :: e -> Vector e -> Vector e # head :: Vector e -> e # tail :: Vector e -> Vector e # unsnoc :: Vector e -> (Vector e, e) # unsnoc' :: Vector e -> Maybe (Vector e, e) # toLast :: Vector e -> e -> Vector e # init :: Vector e -> Vector e # last :: Vector e -> e # single :: e -> Vector e # (++) :: Vector e -> Vector e -> Vector e # replicate :: Int -> e -> Vector e # fromList :: [e] -> Vector e # fromListN :: Int -> [e] -> Vector e # listR :: Vector e -> [e] # listL :: Vector e -> [e] # fromFoldable :: Foldable f => f e -> Vector e # (!^) :: Vector e -> Int -> e # write :: Vector e -> Int -> e -> Vector e # concat :: Foldable f => f (Vector e) -> Vector e # concatMap :: Foldable f => (a -> Vector e) -> f a -> Vector e # intersperse :: e -> Vector e -> Vector e # filter :: (e -> Bool) -> Vector e -> Vector e # except :: (e -> Bool) -> Vector e -> Vector e # partition :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # partitions :: Foldable f => f (e -> Bool) -> Vector e -> [Vector e] # select :: (e -> Maybe a) -> Vector e -> [a] # select' :: (t e ~ Vector e, Linear1 t a) => (e -> Maybe a) -> Vector e -> t a # extract :: (e -> Maybe a) -> Vector e -> ([a], Vector e) # extract' :: (t e ~ Vector e, Linear1 t a) => (e -> Maybe a) -> Vector e -> (t a, Vector e) # selects :: Foldable f => f (e -> Maybe a) -> Vector e -> ([[a]], Vector e) # selects' :: (Foldable f, t e ~ Vector e, Linear1 t a) => f (e -> Maybe a) -> Vector e -> ([t a], Vector e) # isSubseqOf :: Vector e -> Vector e -> Bool # reverse :: Vector e -> Vector e # force :: Vector e -> Vector e # subsequences :: Vector e -> [Vector e] # iterate :: Int -> (e -> e) -> e -> Vector e # nub :: Vector e -> Vector e # nubBy :: Equal e -> Vector e -> Vector e # ofoldr :: (Int -> e -> b -> b) -> b -> Vector e -> b # ofoldl :: (Int -> b -> e -> b) -> b -> Vector e -> b # ofoldr' :: (Int -> e -> b -> b) -> b -> Vector e -> b # ofoldl' :: (Int -> b -> e -> b) -> b -> Vector e -> b # o_foldr :: (e -> b -> b) -> b -> Vector e -> b # o_foldl :: (b -> e -> b) -> b -> Vector e -> b # o_foldr' :: (e -> b -> b) -> b -> Vector e -> b # o_foldl' :: (b -> e -> b) -> b -> Vector e -> b #
Unbox e => Split (Vector e) e Source #
Instance details Methods take :: Int -> Vector e -> Vector e # drop :: Int -> Vector e -> Vector e # keep :: Int -> Vector e -> Vector e # sans :: Int -> Vector e -> Vector e # save :: Int -> Vector e -> Vector e # skip :: Int -> Vector e -> Vector e # split :: Int -> Vector e -> (Vector e, Vector e) # divide :: Int -> Vector e -> (Vector e, Vector e) # splits :: Foldable f => f Int -> Vector e -> [Vector e] # divides :: Foldable f => f Int -> Vector e -> [Vector e] # parts :: Foldable f => f Int -> Vector e -> [Vector e] # chunks :: Int -> Vector e -> [Vector e] # splitBy :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # divideBy :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # splitsBy :: (e -> Bool) -> Vector e -> [Vector e] # splitsOn :: Vector e -> Vector e -> [Vector e] # replaceBy :: Vector e -> Vector e -> Vector e -> Vector e # removeAll :: Vector e -> Vector e -> Vector e # combo :: Equal e -> Vector e -> Int # justifyL :: Int -> e -> Vector e -> Vector e # justifyR :: Int -> e -> Vector e -> Vector e # each :: Int -> Vector e -> Vector e # eachFrom :: Int -> Int -> Vector e -> Vector e # isPrefixOf :: Vector e -> Vector e -> Bool # isSuffixOf :: Vector e -> Vector e -> Bool # isInfixOf :: Vector e -> Vector e -> Bool # prefix :: (e -> Bool) -> Vector e -> Int # suffix :: (e -> Bool) -> Vector e -> Int # infixes :: Vector e -> Vector e -> [Int] # dropSide :: (e -> Bool) -> Vector e -> Vector e # takeWhile :: (e -> Bool) -> Vector e -> Vector e # dropWhile :: (e -> Bool) -> Vector e -> Vector e # takeEnd :: (e -> Bool) -> Vector e -> Vector e # dropEnd :: (e -> Bool) -> Vector e -> Vector e # spanl :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # breakl :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # spanr :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # breakr :: (e -> Bool) -> Vector e -> (Vector e, Vector e) # selectWhile :: (e -> Maybe a) -> Vector e -> [a] # selectEnd :: (e -> Maybe a) -> Vector e -> [a] # extractWhile :: (e -> Maybe a) -> Vector e -> ([a], Vector e) # extractEnd :: (e -> Maybe a) -> Vector e -> (Vector e, [a]) # selectWhile' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> t a # selectEnd' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> t a # extractWhile' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> (t a, Vector e) # extractEnd' :: (t e ~ l, Split1 t a) => (e -> Maybe a) -> Vector e -> (Vector e, t a) #
(Unboxed e, Unbox e) => Sort (Vector e) e Source #
Instance details Methods sortedBy :: (e -> e -> Bool) -> Vector e -> Bool # sortBy :: Compare e -> Vector e -> Vector e #
(Unboxed e, Unbox e) => Indexed (Vector e) Int e Source #
Instance details Methods assoc :: (Int, Int) -> [(Int, e)] -> Vector e # assoc' :: (Int, Int) -> e -> [(Int, e)] -> Vector e # fromIndexed :: Indexed m j e => m -> Vector e # write' :: Vector e -> Int -> e -> Vector e # accum :: (e -> e' -> e) -> Vector e -> [(Int, e')] -> Vector e # imap :: Map m j e => (Int, Int) -> m -> (Int -> j) -> Vector e # update' :: Vector e -> (e -> e) -> Int -> Vector e # updates' :: Vector e -> (Int -> e -> e) -> Vector e #
(Unboxed e, Unbox e) => Map (Vector e) Int e Source #
Instance details Methods assocs :: Vector e -> [(Int, e)] # toMap :: [(Int, e)] -> Vector e # toMap' :: e -> [(Int, e)] -> Vector e # insert' :: Int -> e -> Vector e -> Vector e # delete' :: Int -> Vector e -> Vector e # member' :: Int -> Vector e -> Bool # (//) :: Vector e -> [(Int, e)] -> Vector e # (.!) :: Vector e -> Int -> e # (!) :: Vector e -> Int -> e # (!?) :: Vector e -> Int -> Maybe e # filter' :: (Int -> e -> Bool) -> Vector e -> Vector e # union' :: (e -> e -> e) -> Vector e -> Vector e -> Vector e # difference' :: (e -> e -> Maybe e) -> Vector e -> Vector e -> Vector e # intersection' :: (e -> e -> e) -> Vector e -> Vector e -> Vector e # update :: Vector e -> (Int -> e -> e) -> Vector e # lookupLT' :: Int -> Vector e -> Maybe (Int, e) # lookupGT' :: Int -> Vector e -> Maybe (Int, e) # lookupLE' :: Int -> Vector e -> Maybe (Int, e) # lookupGE' :: Int -> Vector e -> Maybe (Int, e) # keys :: Vector e -> [Int] # (.$) :: (e -> Bool) -> Vector e -> Maybe Int # (*$) :: (e -> Bool) -> Vector e -> [Int] # kfoldr :: (Int -> e -> b -> b) -> b -> Vector e -> b # kfoldl :: (Int -> b -> e -> b) -> b -> Vector e -> b # kfoldr' :: (Int -> e -> b -> b) -> b -> Vector e -> b # kfoldl' :: (Int -> b -> e -> b) -> b -> Vector e -> b #
(Unboxed e, Unbox e) => Thaw (ST s) (Vector e) (STUblist s e) Source #
Instance details Methods thaw :: Vector e -> ST s (STUblist s e) # unsafeThaw :: Vector e -> ST s (STUblist s e) #
(Unboxed e, Unbox e) => Thaw (ST s) (Vector e) (STBytes# s e) Source #
Instance details Methods thaw :: Vector e -> ST s (STBytes# s e) # unsafeThaw :: Vector e -> ST s (STBytes# s e) #
(Unboxed e, Unbox e) => Freeze (ST s) (STUblist s e) (Vector e) Source #
Instance details Methods freeze :: STUblist s e -> ST s (Vector e) # unsafeFreeze :: STUblist s e -> ST s (Vector e) #
(Unboxed e, Unbox e) => Freeze (ST s) (STBytes# s e) (Vector e) Source #
Instance details Methods freeze :: STBytes# s e -> ST s (Vector e) # unsafeFreeze :: STBytes# s e -> ST s (Vector e) #