Data.Vector.HFixed

Heterogeneous vectors.

HVector type classes

class Arity (xs :: [α])

Type class for dealing with N-ary function in generic way. Both accum and apply work with accumulator data types which are polymorphic. So it's only possible to write functions which rearrange elements in vector using plain ADT. It's possible to get around it by using GADT as accumulator (See ArityC and function which use it)

This is also somewhat a kitchen sink module. It contains witnesses which could be used to prove type equalities or to bring instance in scope.

Minimal complete definition

accum, apply, arity

Instances

Arity α ([] α)

Methods

accum :: (forall (a :: [α]) (as :: [[α]]). t (([α] ': a) as) -> f a -> t as) -> (t [[α]] -> b) -> t xs -> TFun [α] f xs b

apply :: (forall (a :: [α]) (as :: [[α]]). t (([α] ': a) as) -> (f a, t as)) -> t xs -> ContVecF [α] xs f

arity :: p xs -> Int

Arity α xs => Arity α ((:) α x xs)

Methods

accum :: (forall (a :: (α ': x) xs) (as :: [(α ': x) xs]). t (((α ': x) xs ': a) as) -> f a -> t as) -> (t [(α ': x) xs] -> b) -> t xs -> TFun ((α ': x) xs) f xs b

apply :: (forall (a :: (α ': x) xs) (as :: [(α ': x) xs]). t (((α ': x) xs ': a) as) -> (f a, t as)) -> t xs -> ContVecF ((α ': x) xs) xs f

arity :: p xs -> Int

class Arity xs => ArityC c xs

Minimal complete definition

accumC, applyC

Instances

ArityC α c ([] α)

Methods

accumC :: proxy [α] -> (forall (a :: c) (as :: [c]). [α] a => t ((c ': a) as) -> f a -> t as) -> (t [c] -> b) -> t xs -> TFun c f xs b

applyC :: proxy [α] -> (forall (a :: c) (as :: [c]). [α] a => t ((c ': a) as) -> (f a, t as)) -> t xs -> ContVecF c xs f

(c x, ArityC a c xs) => ArityC a c ((:) a x xs)

Methods

accumC :: proxy ((a ': x) xs) -> (forall (b :: c) (as :: [c]). (a ': x) xs b => t ((c ': b) as) -> f b -> t as) -> (t [c] -> b) -> t xs -> TFun c f xs b

applyC :: proxy ((a ': x) xs) -> (forall (b :: c) (as :: [c]). (a ': x) xs b => t ((c ': b) as) -> (f b, t as)) -> t xs -> ContVecF c xs f

class Arity (Elems v) => HVector v where

Type class for heterogeneous vectors. Instance should specify way to construct and deconstruct itself

Note that this type class is extremely generic. Almost any single constructor data type could be made instance. It could be monomorphic, it could be polymorphic in some or all fields it doesn't matter. Only law instance should obey is:

inspect v construct = v

Default implementation which uses Generic is provided.

Associated Types

type Elems v :: [*]

Methods

construct :: Fun (Elems v) v

Function for constructing vector

construct :: (Generic v, GHVector (Rep v), GElems (Rep v) ~ Elems v) => Fun (Elems v) v

Function for constructing vector

inspect :: v -> Fun (Elems v) a -> a

Function for deconstruction of vector. It applies vector's elements to N-ary function.

inspect :: (Generic v, GHVector (Rep v), GElems (Rep v) ~ Elems v) => v -> Fun (Elems v) a -> a

Function for deconstruction of vector. It applies vector's elements to N-ary function.

Instances

HVector ()

Unit is empty heterogeneous vector

Associated Types

type Elems () :: [*]

Methods

construct :: Fun (Elems ()) ()

inspect :: () -> Fun (Elems ()) a -> a

HVector (Complex a)

Associated Types

type Elems (Complex a) :: [*]

Methods

construct :: Fun (Elems (Complex a)) (Complex a)

inspect :: Complex a -> Fun (Elems (Complex a)) a -> a

Arity * xs => HVector (VecList xs)

Associated Types

type Elems (VecList xs) :: [*]

Methods

construct :: Fun (Elems (VecList xs)) (VecList xs)

inspect :: VecList xs -> Fun (Elems (VecList xs)) a -> a

Arity * xs => HVector (HVec xs)

Associated Types

type Elems (HVec xs) :: [*]

Methods

construct :: Fun (Elems (HVec xs)) (HVec xs)

inspect :: HVec xs -> Fun (Elems (HVec xs)) a -> a

HVector (a, b)

Associated Types

type Elems (a, b) :: [*]

Methods

construct :: Fun (Elems (a, b)) (a, b)

inspect :: (a, b) -> Fun (Elems (a, b)) a -> a

(Unbox n a, HomArity (Peano n) a, KnownNat n, (~) PeanoNum (Peano ((+) n 1)) (S (Peano n))) => HVector (Vec n a)

Associated Types

type Elems (Vec n a) :: [*]

Methods

construct :: Fun (Elems (Vec n a)) (Vec n a)

inspect :: Vec n a -> Fun (Elems (Vec n a)) a -> a

(Storable a, HomArity (Peano n) a, KnownNat n, (~) PeanoNum (Peano ((+) n 1)) (S (Peano n))) => HVector (Vec n a)

Associated Types

type Elems (Vec n a) :: [*]

Methods

construct :: Fun (Elems (Vec n a)) (Vec n a)

inspect :: Vec n a -> Fun (Elems (Vec n a)) a -> a

(Prim a, HomArity (Peano n) a, KnownNat n, (~) PeanoNum (Peano ((+) n 1)) (S (Peano n))) => HVector (Vec n a)

Associated Types

type Elems (Vec n a) :: [*]

Methods

construct :: Fun (Elems (Vec n a)) (Vec n a)

inspect :: Vec n a -> Fun (Elems (Vec n a)) a -> a

(HomArity (Peano n) a, KnownNat n, (~) PeanoNum (Peano ((+) n 1)) (S (Peano n))) => HVector (Vec n a)

Associated Types

type Elems (Vec n a) :: [*]

Methods

construct :: Fun (Elems (Vec n a)) (Vec n a)

inspect :: Vec n a -> Fun (Elems (Vec n a)) a -> a

HVector (a, b, c)

Associated Types

type Elems (a, b, c) :: [*]

Methods

construct :: Fun (Elems (a, b, c)) (a, b, c)

inspect :: (a, b, c) -> Fun (Elems (a, b, c)) a -> a

Arity * xs => HVector (ContVecF * xs Identity)

Associated Types

type Elems (ContVecF * xs Identity) :: [*]

Methods

construct :: Fun (Elems (ContVecF * xs Identity)) (ContVecF * xs Identity)

inspect :: ContVecF * xs Identity -> Fun (Elems (ContVecF * xs Identity)) a -> a

HVector (a, b, c, d)

Associated Types

type Elems (a, b, c, d) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d)) (a, b, c, d)

inspect :: (a, b, c, d) -> Fun (Elems (a, b, c, d)) a -> a

HVector (a, b, c, d, e)

Associated Types

type Elems (a, b, c, d, e) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e)) (a, b, c, d, e)

inspect :: (a, b, c, d, e) -> Fun (Elems (a, b, c, d, e)) a -> a

HVector (a, b, c, d, e, f)

Associated Types

type Elems (a, b, c, d, e, f) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f)) (a, b, c, d, e, f)

inspect :: (a, b, c, d, e, f) -> Fun (Elems (a, b, c, d, e, f)) a -> a

HVector (a, b, c, d, e, f, g)

Associated Types

type Elems (a, b, c, d, e, f, g) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g)) (a, b, c, d, e, f, g)

inspect :: (a, b, c, d, e, f, g) -> Fun (Elems (a, b, c, d, e, f, g)) a -> a

HVector (a, b, c, d, e, f, g, h)

Associated Types

type Elems (a, b, c, d, e, f, g, h) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h)) (a, b, c, d, e, f, g, h)

inspect :: (a, b, c, d, e, f, g, h) -> Fun (Elems (a, b, c, d, e, f, g, h)) a -> a

HVector (a, b, c, d, e, f, g, h, i)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i)) (a, b, c, d, e, f, g, h, i)

inspect :: (a, b, c, d, e, f, g, h, i) -> Fun (Elems (a, b, c, d, e, f, g, h, i)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j)) (a, b, c, d, e, f, g, h, i, j)

inspect :: (a, b, c, d, e, f, g, h, i, j) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k)) (a, b, c, d, e, f, g, h, i, j, k)

inspect :: (a, b, c, d, e, f, g, h, i, j, k) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l)) (a, b, c, d, e, f, g, h, i, j, k, l)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m)) (a, b, c, d, e, f, g, h, i, j, k, l, m)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z) -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z)) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a')

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a') :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a')) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a')

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a') -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a')) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b')

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b') :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b')) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b')

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b') -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b')) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c')

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c') :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c')) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c')

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c') -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c')) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d')

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d') :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d')) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d')

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d') -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d')) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e')

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e') :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e')) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e')

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e') -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e')) a -> a

HVector (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e', f')

Associated Types

type Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e', f') :: [*]

Methods

construct :: Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e', f')) (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e', f')

inspect :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e', f') -> Fun (Elems (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, a', b', c', d', e', f')) a -> a

tupleSize :: forall v proxy. HVector v => proxy v -> Int

Number of elements in tuple

class Arity (ElemsF v) => HVectorF (v :: (α -> *) -> *) where

Type class for partially homogeneous vector where every element in the vector have same type constructor. Vector itself is parametrized by that constructor

Minimal complete definition

inspectF, constructF

Associated Types

type ElemsF v :: [α]

Elements of the vector without type constructors

Methods

inspectF :: v f -> TFun f (ElemsF v) a -> a

constructF :: TFun f (ElemsF v) (v f)

Instances

Arity * xs => HVectorF * (HVecF xs)

Associated Types

type ElemsF (HVecF xs) (v :: (HVecF xs -> *) -> *) :: [α]

Methods

inspectF :: v f -> TFun (HVecF xs) f (ElemsF (HVecF xs) v) a -> a

constructF :: TFun (HVecF xs) f (ElemsF (HVecF xs) v) (v f)

Arity α xs => HVectorF α (ContVecF α xs)

Associated Types

type ElemsF (ContVecF α xs) (v :: (ContVecF α xs -> *) -> *) :: [α]

Methods

inspectF :: v f -> TFun (ContVecF α xs) f (ElemsF (ContVecF α xs) v) a -> a

constructF :: TFun (ContVecF α xs) f (ElemsF (ContVecF α xs) v) (v f)

Arity α xs => HVectorF α (VecListF α xs)

Associated Types

type ElemsF (VecListF α xs) (v :: (VecListF α xs -> *) -> *) :: [α]

Methods

inspectF :: v f -> TFun (VecListF α xs) f (ElemsF (VecListF α xs) v) a -> a

constructF :: TFun (VecListF α xs) f (ElemsF (VecListF α xs) v) (v f)

tupleSizeF :: forall v f proxy. HVectorF v => proxy (v f) -> Int

Number of elements in tuple

data Proxy k (t :: k) :: forall k. k -> *

A concrete, poly-kinded proxy type

Constructors

Proxy

Instances

Generic1 k (Proxy k)

Associated Types

type Rep1 (Proxy k) (f :: Proxy k -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (Proxy k) f a

to1 :: Rep1 (Proxy k) f a -> f a

Monad (Proxy *)

Since: 4.7.0.0

Methods

(>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b

(>>) :: Proxy * a -> Proxy * b -> Proxy * b

return :: a -> Proxy * a

fail :: String -> Proxy * a

Functor (Proxy *)

Since: 4.7.0.0

Methods

fmap :: (a -> b) -> Proxy * a -> Proxy * b

(<$) :: a -> Proxy * b -> Proxy * a

Applicative (Proxy *)

Since: 4.7.0.0

Methods

pure :: a -> Proxy * a

(<*>) :: Proxy * (a -> b) -> Proxy * a -> Proxy * b

liftA2 :: (a -> b -> c) -> Proxy * a -> Proxy * b -> Proxy * c

(*>) :: Proxy * a -> Proxy * b -> Proxy * b

(<*) :: Proxy * a -> Proxy * b -> Proxy * a

Foldable (Proxy *)

Since: 4.7.0.0

Methods

fold :: Monoid m => Proxy * m -> m

foldMap :: Monoid m => (a -> m) -> Proxy * a -> m

foldr :: (a -> b -> b) -> b -> Proxy * a -> b

foldr' :: (a -> b -> b) -> b -> Proxy * a -> b

foldl :: (b -> a -> b) -> b -> Proxy * a -> b

foldl' :: (b -> a -> b) -> b -> Proxy * a -> b

foldr1 :: (a -> a -> a) -> Proxy * a -> a

foldl1 :: (a -> a -> a) -> Proxy * a -> a

toList :: Proxy * a -> [a]

null :: Proxy * a -> Bool

length :: Proxy * a -> Int

elem :: Eq a => a -> Proxy * a -> Bool

maximum :: Ord a => Proxy * a -> a

minimum :: Ord a => Proxy * a -> a

sum :: Num a => Proxy * a -> a

product :: Num a => Proxy * a -> a

Eq1 (Proxy *)

Since: 4.9.0.0

Methods

liftEq :: (a -> b -> Bool) -> Proxy * a -> Proxy * b -> Bool

Ord1 (Proxy *)

Since: 4.9.0.0

Methods

liftCompare :: (a -> b -> Ordering) -> Proxy * a -> Proxy * b -> Ordering

Read1 (Proxy *)

Since: 4.9.0.0

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Proxy * a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Proxy * a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Proxy * a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Proxy * a]

Show1 (Proxy *)

Since: 4.9.0.0

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Proxy * a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Proxy * a] -> ShowS

Alternative (Proxy *)

Since: 4.9.0.0

Methods

empty :: Proxy * a

(<|>) :: Proxy * a -> Proxy * a -> Proxy * a

some :: Proxy * a -> Proxy * [a]

many :: Proxy * a -> Proxy * [a]

MonadPlus (Proxy *)

Since: 4.9.0.0

Methods

mzero :: Proxy * a

mplus :: Proxy * a -> Proxy * a -> Proxy * a

NFData1 (Proxy *)

Since: 1.4.3.0

Methods

liftRnf :: (a -> ()) -> Proxy * a -> ()

Vector (Proxy *) a

Methods

construct :: Fun (Peano (Dim (Proxy *))) a (Proxy * a)

inspect :: Proxy * a -> Fun (Peano (Dim (Proxy *))) a b -> b

basicIndex :: Proxy * a -> Int -> a

Bounded (Proxy k t)

Methods

minBound :: Proxy k t

maxBound :: Proxy k t

Enum (Proxy k s)

Since: 4.7.0.0

Methods

succ :: Proxy k s -> Proxy k s

pred :: Proxy k s -> Proxy k s

toEnum :: Int -> Proxy k s

fromEnum :: Proxy k s -> Int

enumFrom :: Proxy k s -> [Proxy k s]

enumFromThen :: Proxy k s -> Proxy k s -> [Proxy k s]

enumFromTo :: Proxy k s -> Proxy k s -> [Proxy k s]

enumFromThenTo :: Proxy k s -> Proxy k s -> Proxy k s -> [Proxy k s]

Eq (Proxy k s)

Since: 4.7.0.0

Methods

(==) :: Proxy k s -> Proxy k s -> Bool

(/=) :: Proxy k s -> Proxy k s -> Bool

Ord (Proxy k s)

Since: 4.7.0.0

Methods

compare :: Proxy k s -> Proxy k s -> Ordering

(<) :: Proxy k s -> Proxy k s -> Bool

(<=) :: Proxy k s -> Proxy k s -> Bool

(>) :: Proxy k s -> Proxy k s -> Bool

(>=) :: Proxy k s -> Proxy k s -> Bool

max :: Proxy k s -> Proxy k s -> Proxy k s

min :: Proxy k s -> Proxy k s -> Proxy k s

Read (Proxy k s)

Since: 4.7.0.0

Methods

readsPrec :: Int -> ReadS (Proxy k s)

readList :: ReadS [Proxy k s]

readPrec :: ReadPrec (Proxy k s)

readListPrec :: ReadPrec [Proxy k s]

Show (Proxy k s)

Since: 4.7.0.0

Methods

showsPrec :: Int -> Proxy k s -> ShowS

show :: Proxy k s -> String

showList :: [Proxy k s] -> ShowS

Ix (Proxy k s)

Since: 4.7.0.0

Methods

range :: (Proxy k s, Proxy k s) -> [Proxy k s]

index :: (Proxy k s, Proxy k s) -> Proxy k s -> Int

unsafeIndex :: (Proxy k s, Proxy k s) -> Proxy k s -> Int

inRange :: (Proxy k s, Proxy k s) -> Proxy k s -> Bool

rangeSize :: (Proxy k s, Proxy k s) -> Int

unsafeRangeSize :: (Proxy k s, Proxy k s) -> Int

Generic (Proxy k t)

Associated Types

type Rep (Proxy k t) :: * -> *

Methods

from :: Proxy k t -> Rep (Proxy k t) x

to :: Rep (Proxy k t) x -> Proxy k t

Semigroup (Proxy k s)

Since: 4.9.0.0

Methods

(<>) :: Proxy k s -> Proxy k s -> Proxy k s

sconcat :: NonEmpty (Proxy k s) -> Proxy k s

stimes :: Integral b => b -> Proxy k s -> Proxy k s

Monoid (Proxy k s)

Since: 4.7.0.0

Methods

mempty :: Proxy k s

mappend :: Proxy k s -> Proxy k s -> Proxy k s

mconcat :: [Proxy k s] -> Proxy k s

NFData (Proxy k a)

Since: 1.4.0.0

Methods

rnf :: Proxy k a -> ()

type Rep1 k (Proxy k)

type Rep1 k (Proxy k) = D1 k (MetaData "Proxy" "Data.Proxy" "base" False) (C1 k (MetaCons "Proxy" PrefixI False) (U1 k))

type Dim (Proxy *)

type Dim (Proxy *) = 0

type Rep (Proxy k t)

type Rep (Proxy k t) = D1 * (MetaData "Proxy" "Data.Proxy" "base" False) (C1 * (MetaCons "Proxy" PrefixI False) (U1 *))

type ContVec xs = ContVecF xs Identity

CPS-encoded heterogeneous vector.

newtype ContVecF (xs :: [α]) (f :: α -> *)

CPS-encoded partially heterogeneous vector.

Constructors

ContVecF

Fields

• runContVecF :: forall r. TFun f xs r -> r

Instances

Arity α xs => HVectorF α (ContVecF α xs)

Associated Types

type ElemsF (ContVecF α xs) (v :: (ContVecF α xs -> *) -> *) :: [α]

Methods

inspectF :: v f -> TFun (ContVecF α xs) f (ElemsF (ContVecF α xs) v) a -> a

constructF :: TFun (ContVecF α xs) f (ElemsF (ContVecF α xs) v) (v f)

Arity * xs => HVector (ContVecF * xs Identity)

Associated Types

type Elems (ContVecF * xs Identity) :: [*]

Methods

construct :: Fun (Elems (ContVecF * xs Identity)) (ContVecF * xs Identity)

inspect :: ContVecF * xs Identity -> Fun (Elems (ContVecF * xs Identity)) a -> a

type ElemsF α (ContVecF α xs)

type ElemsF α (ContVecF α xs) = xs

type Elems (ContVecF * xs Identity)

type Elems (ContVecF * xs Identity) = xs

asCVec :: ContVec xs -> ContVec xs

Restrict type of vector to ContVec. This function is useful for resolving type ambiguity when composing functions. For example following code would not compile because intermediate type is ambiguous:

cons 'a' . tail

GHC cannot guess what type should be produced by tail. However we can fix type of intermediate vector with asCVec, so code below will work just fine:

cons 'a' . asCVec . tail

asCVecF :: ContVecF f xs -> ContVecF f xs

Position based functions

convert :: (HVector v, HVector w, Elems v ~ Elems w) => v -> w

We can convert between any two vector which have same structure but different representations.

head :: (HVector v, Elems v ~ (a ': as), Arity as) => v -> a

Head of the vector

tail :: (HVector v, HVector w, (a ': Elems w) ~ Elems v) => v -> w

Tail of the vector

>>> case tail ('a',"aa",()) of x@(_,_) -> x
("aa",())

cons :: (HVector v, HVector w, Elems w ~ (a ': Elems v)) => a -> v -> w

Prepend element to the list. Note that it changes type of vector so it either must be known from context of specified explicitly

concat :: (HVector v, HVector u, HVector w, Elems w ~ (Elems v ++ Elems u)) => v -> u -> w

Concatenate two vectors

Indexing

class ArityPeano n => Index (n :: PeanoNum) (xs :: [*])

Indexing of vectors

Minimal complete definition

getF, putF, lensF, lensChF

Associated Types

type ValueAt n xs :: *

Type at position n

Instances

Arity * xs => Index Z ((:) * x xs)

Associated Types

type ValueAt (Z :: PeanoNum) ((* ': x) xs :: [*]) :: *

type NewElems (Z :: PeanoNum) ((* ': x) xs :: [*]) a :: [*]

Methods

getF :: proxy Z -> Fun ((* ': x) xs) (ValueAt Z ((* ': x) xs))

putF :: proxy Z -> ValueAt Z ((* ': x) xs) -> Fun ((* ': x) xs) r -> Fun ((* ': x) xs) r

lensF :: (Functor f, (* ~ v) (ValueAt Z ((* ': x) xs))) => proxy Z -> (v -> f v) -> Fun ((* ': x) xs) r -> Fun ((* ': x) xs) (f r)

lensChF :: Functor f => proxy Z -> (ValueAt Z ((* ': x) xs) -> f a) -> Fun (NewElems Z ((* ': x) xs) a) r -> Fun ((* ': x) xs) (f r)

Index n xs => Index (S n) ((:) * x xs)

Associated Types

type ValueAt (S n :: PeanoNum) ((* ': x) xs :: [*]) :: *

type NewElems (S n :: PeanoNum) ((* ': x) xs :: [*]) a :: [*]

Methods

getF :: proxy (S n) -> Fun ((* ': x) xs) (ValueAt (S n) ((* ': x) xs))

putF :: proxy (S n) -> ValueAt (S n) ((* ': x) xs) -> Fun ((* ': x) xs) r -> Fun ((* ': x) xs) r

lensF :: (Functor f, (* ~ v) (ValueAt (S n) ((* ': x) xs))) => proxy (S n) -> (v -> f v) -> Fun ((* ': x) xs) r -> Fun ((* ': x) xs) (f r)

lensChF :: Functor f => proxy (S n) -> (ValueAt (S n) ((* ': x) xs) -> f a) -> Fun (NewElems (S n) ((* ': x) xs) a) r -> Fun ((* ': x) xs) (f r)

index :: (Index n (Elems v), HVector v) => v -> proxy n -> ValueAt n (Elems v)

Index heterogeneous vector

set :: (Index n (Elems v), HVector v) => proxy n -> ValueAt n (Elems v) -> v -> v

Set element in the vector

element :: forall n v a f proxy. (Index (Peano n) (Elems v), ValueAt (Peano n) (Elems v) ~ a, HVector v, Functor f) => proxy n -> (a -> f a) -> v -> f v

Twan van Laarhoven's lens for i'th element.

elementCh :: forall n v w a b f proxy. (Index (Peano n) (Elems v), ValueAt (Peano n) (Elems v) ~ a, HVector v, HVector w, Elems w ~ NewElems (Peano n) (Elems v) b, Functor f) => proxy n -> (a -> f b) -> v -> f w

Type changing Twan van Laarhoven's lens for i'th element.

Generic constructors

mk0 :: forall v. (HVector v, Elems v ~ '[]) => v

mk1 :: forall v a. (HVector v, Elems v ~ '[a]) => a -> v

mk2 :: forall v a b. (HVector v, Elems v ~ '[a, b]) => a -> b -> v

mk3 :: forall v a b c. (HVector v, Elems v ~ '[a, b, c]) => a -> b -> c -> v

mk4 :: forall v a b c d. (HVector v, Elems v ~ '[a, b, c, d]) => a -> b -> c -> d -> v

mk5 :: forall v a b c d e. (HVector v, Elems v ~ '[a, b, c, d, e]) => a -> b -> c -> d -> e -> v

Folds and unfolds

fold :: HVector v => v -> Fn Identity (Elems v) r -> r

Most generic form of fold which doesn't constrain elements id use of inspect. Or in more convenient form below:

>>> fold (12::Int,"Str") (\a s -> show a ++ s)
"12Str"

foldr :: (HVector v, ArityC c (Elems v)) => Proxy c -> (forall a. c a => a -> b -> b) -> b -> v -> b

Right fold over heterogeneous vector

foldl :: (HVector v, ArityC c (Elems v)) => Proxy c -> (forall a. c a => b -> a -> b) -> b -> v -> b

Left fold over heterogeneous vector

foldrF :: (HVectorF v, ArityC c (ElemsF v)) => Proxy c -> (forall a. c a => f a -> b -> b) -> b -> v f -> b

Right fold over heterogeneous vector

foldlF :: (HVectorF v, ArityC c (ElemsF v)) => Proxy c -> (forall a. c a => b -> f a -> b) -> b -> v f -> b

Left fold over heterogeneous vector

foldrNatF :: HVectorF v => (forall a. f a -> b -> b) -> b -> v f -> b

Right fold over heterogeneous vector

foldlNatF :: HVectorF v => (forall a. b -> f a -> b) -> b -> v f -> b

Left fold over heterogeneous vector

mapM_ :: (HVector v, ArityC c (Elems v), Applicative f) => Proxy c -> (forall a. c a => a -> f ()) -> v -> f ()

Apply monadic action to every element in the vector

unfoldr :: (HVector v, ArityC c (Elems v)) => Proxy c -> (forall a. c a => b -> (a, b)) -> b -> v

Unfold vector.

unfoldrF :: (HVectorF v, ArityC c (ElemsF v)) => Proxy c -> (forall a. c a => b -> (f a, b)) -> b -> v f

Unfold vector.

Replicate variants

replicate :: (HVector v, ArityC c (Elems v)) => Proxy c -> (forall x. c x => x) -> v

Replicate polymorphic value n times. Concrete instance for every element is determined by their respective types.

>>> import Data.Vector.HFixed as H
>>> H.replicate (Proxy :: Proxy Monoid) mempty :: ((),String)
((),"")

replicateM :: (HVector v, Applicative f, ArityC c (Elems v)) => Proxy c -> (forall a. c a => f a) -> f v

Replicate monadic action n times.

>>> import Data.Vector.HFixed as H
>>> H.replicateM (Proxy :: Proxy Read) (fmap read getLine) :: IO (Int,Char)
> 12
> 'a'
(12,'a')

replicateF :: (HVectorF v, ArityC c (ElemsF v)) => Proxy c -> (forall a. c a => f a) -> v f

replicateNatF :: (HVectorF v, Arity (ElemsF v)) => (forall a. f a) -> v f

Zip variants

zipWith :: (HVector v, ArityC c (Elems v)) => Proxy c -> (forall a. c a => a -> a -> a) -> v -> v -> v

Zip two heterogeneous vectors

zipWithF :: (HVectorF v, ArityC c (ElemsF v)) => Proxy c -> (forall a. c a => f a -> g a -> h a) -> v f -> v g -> v h

Zip two heterogeneous vectors

zipWithNatF :: HVectorF v => (forall a. f a -> g a -> h a) -> v f -> v g -> v h

Zip two heterogeneous vectors

zipFold :: (HVector v, ArityC c (Elems v), Monoid m) => Proxy c -> (forall a. c a => a -> a -> m) -> v -> v -> m

zipFoldF :: (HVectorF v, ArityC c (ElemsF v), Monoid m) => Proxy c -> (forall a. c a => f a -> f a -> m) -> v f -> v f -> m

monomorphize :: (HVector v, Peano n ~ Len (Elems v), ArityC c (Elems v)) => Proxy c -> (forall a. c a => a -> x) -> v -> ContVec n x

Convert heterogeneous vector to homogeneous

monomorphizeF :: (HVectorF v, Peano n ~ Len (ElemsF v), ArityC c (ElemsF v)) => Proxy c -> (forall a. c a => f a -> x) -> v f -> ContVec n x

Convert heterogeneous vector to homogeneous

Tuples parametrized with type constructor

mapNat :: HVectorF v => (forall a. f a -> g a) -> v f -> v g

Apply natural transformation to every element of the tuple.

sequence :: (Applicative f, HVectorF v, HVector w, ElemsF v ~ Elems w) => v f -> f w

Sequence effects for every element in the vector

sequence_ :: (Applicative f, HVectorF v) => v f -> f ()

Sequence effects for every element in the vector

sequenceF :: (Applicative f, HVectorF v) => v (f `Compose` g) -> f (v g)

Sequence effects for every element in the vector

wrap :: (HVector v, HVectorF w, Elems v ~ ElemsF w) => (forall a. a -> f a) -> v -> w f

Wrap every value in the vector into type constructor.

unwrap :: (HVectorF v, HVector w, ElemsF v ~ Elems w) => (forall a. f a -> a) -> v f -> w

Unwrap every value in the vector from the type constructor.

distribute :: (Functor f, HVector v, HVectorF w, Elems v ~ ElemsF w) => f v -> w f

Analog of distribute from Distributive type class.

distributeF :: (Functor f, HVectorF v) => f (v g) -> v (f `Compose` g)

Analog of distribute from Distributive type class.

Specialized operations

eq :: (HVector v, ArityC Eq (Elems v)) => v -> v -> Bool

Generic equality for heterogeneous vectors

compare :: (HVector v, ArityC Ord (Elems v)) => v -> v -> Ordering

Generic comparison for heterogeneous vectors

rnf :: (HVector v, ArityC NFData (Elems v)) => v -> ()

Reduce vector to normal form