bimaps-0.1.0.2: bijections with multiple implementations.

Safe HaskellNone
LanguageHaskell2010

Data.Bijection.Vector.Storable

Contents

Description

A bijection between boxed, immutable vectors.

Synopsis

Documentation

data Vector a :: * -> * #

Storable-based vectors

Instances

Storable a => Vector Vector a 

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) a -> m (Vector a) #

basicUnsafeThaw :: PrimMonad m => Vector a -> m (Mutable Vector (PrimState m) a) #

basicLength :: Vector a -> Int #

basicUnsafeSlice :: Int -> Int -> Vector a -> Vector a #

basicUnsafeIndexM :: Monad m => Vector a -> Int -> m a #

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) a -> Vector a -> m () #

elemseq :: Vector a -> a -> b -> b #

Storable a => IsList (Vector a) 

Associated Types

type Item (Vector a) :: * #

Methods

fromList :: [Item (Vector a)] -> Vector a #

fromListN :: Int -> [Item (Vector a)] -> Vector a #

toList :: Vector a -> [Item (Vector a)] #

(Storable a, Eq a) => Eq (Vector a) 

Methods

(==) :: Vector a -> Vector a -> Bool #

(/=) :: Vector a -> Vector a -> Bool #

(Data a, Storable a) => Data (Vector a) 

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 :: (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) #

(Storable a, Ord a) => Ord (Vector a) 

Methods

compare :: Vector a -> Vector a -> Ordering #

(<) :: Vector a -> Vector a -> Bool #

(<=) :: Vector a -> Vector a -> Bool #

(>) :: Vector a -> Vector a -> Bool #

(>=) :: Vector a -> Vector a -> Bool #

max :: Vector a -> Vector a -> Vector a #

min :: Vector a -> Vector a -> Vector a #

(Read a, Storable a) => Read (Vector a) 
(Show a, Storable a) => Show (Vector a) 

Methods

showsPrec :: Int -> Vector a -> ShowS #

show :: Vector a -> String #

showList :: [Vector a] -> ShowS #

Storable a => Semigroup (Vector a) 

Methods

(<>) :: Vector a -> Vector a -> Vector a #

sconcat :: NonEmpty (Vector a) -> Vector a #

stimes :: Integral b => b -> Vector a -> Vector a #

Storable a => Monoid (Vector a) 

Methods

mempty :: Vector a #

mappend :: Vector a -> Vector a -> Vector a #

mconcat :: [Vector a] -> Vector a #

(Storable a, ToJSON a) => ToJSON (Vector a) 
(Storable a, FromJSON a) => FromJSON (Vector a) 
NFData (Vector a) 

Methods

rnf :: Vector a -> () #

type Mutable Vector 
type Item (Vector a) 
type Item (Vector a) = a
type Dom (Vector c) Source # 
type Dom (Vector c) = Int
type Cod (Vector c) Source # 
type Cod (Vector c) = c

Orphan instances

Storable c => DomCod (Vector c) Source # 

Associated Types

type Dom (Vector c) :: * Source #

type Cod (Vector c) :: * Source #

Methods

member :: Vector c -> Dom (Vector c) -> Bool Source #

lookup :: Vector c -> Dom (Vector c) -> Maybe (Cod (Vector c)) Source #

deleteDC :: Vector c -> Dom (Vector c) -> Maybe (Cod (Vector c), Vector c) Source #

insertDC :: Vector c -> (Dom (Vector c), Cod (Vector c)) -> Vector c Source #

toListDC :: Vector c -> [(Dom (Vector c), Cod (Vector c))] Source #

nullDC :: Vector c -> Bool Source #

emptyDC :: Vector c Source #

sizeDC :: Vector c -> Int Source #

fromListDC :: [(Dom (Vector c), Cod (Vector c))] -> Vector c Source #