Data.Vector.Fixed.Monomorphic

Wrapper function for working with monomorphic vectors. Standard API require vector to be parametric in their element type making it impossible to work with vectors like

data Vec3 = Vec3 Double Double Double

This module provides newtype wrapper which allows use of functions from Data.Vector.Fixed with such data types and function which works with such vectors.

Functions have same meaning as ones from Data.Vector.Fixed and documented there.

Vector type class

Vector size

type family DimMono v :: *

Dimensions of monomorphic vector.

data Z

Type level zero

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

NatIso Z 0

Arity n => Index Z (S n)

Methods

getF :: Z -> Fun (S n) a a

putF :: Z -> a -> Fun (S n) a r -> Fun (S n) a r

lensF :: Functor f => Z -> (a -> f a) -> Fun (S n) a r -> Fun (S n) a (f r)

type Add Z n

type Add Z n = n

type Fn Z a b

type Fn Z a b = b

data S n

Successor of n

Instances

Arity n => Index Z (S n)

Methods

getF :: Z -> Fun (S n) a a

putF :: Z -> a -> Fun (S n) a r -> Fun (S n) a r

lensF :: Functor f => Z -> (a -> f a) -> Fun (S n) a r -> Fun (S n) a (f 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

(NatIso k ((-) n 1), (~) * (ToPeano ((-) n 1)) k, (~) * (ToPeano n) (S k), (~) Nat n ((+) 1 ((-) n 1))) => NatIso (S k) n

Index k n => Index (S k) (S n)

Methods

getF :: S k -> Fun (S n) a a

putF :: S k -> a -> Fun (S n) a r -> Fun (S n) a r

lensF :: Functor f => S k -> (a -> f a) -> Fun (S n) a r -> Fun (S n) a (f r)

type Add (S n) k

type Add (S n) k = S (Add n k)

type Fn (S n) a b

type Fn (S n) a b = a -> Fn n a b

Synonyms for small numerals

type N1 = S Z

type N2 = S N1

type N3 = S N2

type N4 = S N3

type N5 = S N4

type N6 = S N5

Type class

class Arity (DimMono v) => VectorMono v where

Counterpart of Vector type class for monomorphic vectors.

Minimal complete definition

construct, inspect

Associated Types

type VectorElm v :: *

Type of vector elements.

Methods

construct :: Fun (DimMono v) (VectorElm v) v

Construct vector

inspect :: v -> Fun (DimMono v) (VectorElm v) r -> r

Inspect vector

basicIndex :: v -> Int -> VectorElm v

Optional more efficient implementation of indexing

class Arity n

Type class for handling n-ary functions.

Minimal complete definition

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

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

newtype Fun n a b

Newtype wrapper which is used to make Fn injective. It's also a reader monad.

Constructors

Fun

Fields

• unFun :: Fn n a b

Instances

Arity n => Monad (Fun n a)

Methods

(>>=) :: Fun n a a -> (a -> Fun n a b) -> Fun n a b

(>>) :: Fun n a a -> Fun n a b -> Fun n a b

return :: a -> Fun n a a

fail :: String -> Fun n a a

Arity n => Functor (Fun n a)

Methods

fmap :: (a -> b) -> Fun n a a -> Fun n a b

(<$) :: a -> Fun n a b -> Fun n a a

Arity n => Applicative (Fun n a)

Methods

pure :: a -> Fun n a a

(<*>) :: Fun n a (a -> b) -> Fun n a a -> Fun n a b

(*>) :: Fun n a a -> Fun n a b -> Fun n a b

(<*) :: Fun n a a -> Fun n a b -> Fun n a a

length :: Arity (DimMono v) => v -> Int

Length of vector

Constructors

mk1 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ N1) => a -> v

mk2 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ N2) => a -> a -> v

mk3 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ N3) => a -> a -> a -> v

mk4 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ N4) => a -> a -> a -> a -> v

mk5 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ N5) => a -> a -> a -> a -> a -> v

Functions

replicate :: (VectorMono v, VectorElm v ~ a) => a -> v

replicateM :: (VectorMono v, VectorElm v ~ a, Monad m) => m a -> m v

generate :: (VectorMono v, VectorElm v ~ a) => (Int -> a) -> v

generateM :: (Monad m, VectorMono v, VectorElm v ~ a) => (Int -> m a) -> m v

unfoldr :: (VectorMono v, VectorElm v ~ a) => (b -> (a, b)) -> b -> v

basis :: (VectorMono v, VectorElm v ~ a, Num a) => Int -> v

Modifying vectors

Transformations

head :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n) => v -> a

tail :: (VectorMono v, VectorElm v ~ a, VectorMono w, VectorElm w ~ a, DimMono v ~ S (DimMono w)) => v -> w

reverse :: VectorMono v => v -> v

(!) :: (VectorMono v, VectorElm v ~ a) => v -> Int -> a

Comparison

eq :: (VectorMono v, VectorElm v ~ a, Eq a) => v -> v -> Bool

Maps

map :: (VectorMono v, VectorElm v ~ a) => (a -> a) -> v -> v

mapM :: (VectorMono v, VectorElm v ~ a, Monad m) => (a -> m a) -> v -> m v

mapM_ :: (VectorMono v, VectorElm v ~ a, Monad m) => (a -> m b) -> v -> m ()

imap :: (VectorMono v, VectorElm v ~ a) => (Int -> a -> a) -> v -> v

imapM :: (VectorMono v, VectorElm v ~ a, Monad m) => (Int -> a -> m a) -> v -> m v

imapM_ :: (VectorMono v, VectorElm v ~ a, Monad m) => (Int -> a -> m b) -> v -> m ()

Folding

foldl :: (VectorMono v, VectorElm v ~ a) => (b -> a -> b) -> b -> v -> b

foldr :: (VectorMono v, VectorElm v ~ a) => (a -> b -> b) -> b -> v -> b

foldl1 :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n) => (a -> a -> a) -> v -> a

ifoldl :: (VectorMono v, VectorElm v ~ a) => (b -> Int -> a -> b) -> b -> v -> b

ifoldr :: (VectorMono v, VectorElm v ~ a) => (Int -> a -> b -> b) -> b -> v -> b

fold :: (VectorMono v, Monoid (VectorElm v)) => v -> VectorElm v

foldMap :: (VectorMono v, Monoid m) => (VectorElm v -> m) -> v -> m

foldM :: (VectorMono v, VectorElm v ~ a, Monad m) => (b -> a -> m b) -> b -> v -> m b

ifoldM :: (VectorMono v, VectorElm v ~ a, Monad m) => (b -> Int -> a -> m b) -> b -> v -> m b

Special folds

sum :: (VectorMono v, VectorElm v ~ a, Num a) => v -> a

maximum :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n, Ord a) => v -> a

minimum :: (VectorMono v, VectorElm v ~ a, DimMono v ~ S n, Ord a) => v -> a

and :: (VectorMono v, VectorElm v ~ Bool) => v -> Bool

or :: (VectorMono v, VectorElm v ~ Bool) => v -> Bool

all :: (VectorMono v, VectorElm v ~ a) => (a -> Bool) -> v -> Bool

any :: (VectorMono v, VectorElm v ~ a) => (a -> Bool) -> v -> Bool

find :: (VectorMono v, VectorElm v ~ a) => (a -> Bool) -> v -> Maybe a

Zips

zipWith :: (VectorMono v, VectorElm v ~ a) => (a -> a -> a) -> v -> v -> v

zipWithM :: (VectorMono v, VectorElm v ~ a, Monad m) => (a -> a -> m a) -> v -> v -> m v

izipWith :: (VectorMono v, VectorElm v ~ a) => (Int -> a -> a -> a) -> v -> v -> v

izipWithM :: (VectorMono v, VectorElm v ~ a, Monad m) => (Int -> a -> a -> m a) -> v -> v -> m v

Conversion

convert :: (VectorMono v, VectorMono w, VectorElm v ~ VectorElm w, DimMono v ~ DimMono w) => v -> w

toList :: (VectorMono v, VectorElm v ~ a) => v -> [a]

fromList :: (VectorMono v, VectorElm v ~ a) => [a] -> v