fixed-vector-hetero-0.5.0.0: Generic heterogeneous vectors

Safe HaskellNone
LanguageHaskell98

Data.Vector.HFixed.Cont

Contents

Description

CPS encoded heterogeneous vectors.

Synopsis

CPS-encoded vector

Type classes

type family Fn (f :: α -> *) (as :: [α]) b where ... Source #

Type family for N-ary function. Types of function parameters are encoded as the list of types.

Equations

Fn f '[] b = b 
Fn f (a ': as) b = f a -> Fn f as b 

type Fun = TFun Identity Source #

Newtype wrapper to work around of type families' lack of injectivity.

newtype TFun f as b Source #

Newtype wrapper for function where all type parameters have same type constructor. This type is required for writing function which works with monads, appicatives etc.

Constructors

TFun 

Fields

Instances

Arity α xs => Monad (TFun α f xs) Source # 

Methods

(>>=) :: TFun α f xs a -> (a -> TFun α f xs b) -> TFun α f xs b #

(>>) :: TFun α f xs a -> TFun α f xs b -> TFun α f xs b #

return :: a -> TFun α f xs a #

fail :: String -> TFun α f xs a #

Arity α xs => Functor (TFun α f xs) Source # 

Methods

fmap :: (a -> b) -> TFun α f xs a -> TFun α f xs b #

(<$) :: a -> TFun α f xs b -> TFun α f xs a #

Arity α xs => Applicative (TFun α f xs) Source # 

Methods

pure :: a -> TFun α f xs a #

(<*>) :: TFun α f xs (a -> b) -> TFun α f xs a -> TFun α f xs b #

liftA2 :: (a -> b -> c) -> TFun α f xs a -> TFun α f xs b -> TFun α f xs c #

(*>) :: TFun α f xs a -> TFun α f xs b -> TFun α f xs b #

(<*) :: TFun α f xs a -> TFun α f xs b -> TFun α f xs a #

class Arity (xs :: [α]) where Source #

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

Methods

accum Source #

Arguments

:: (forall a as. t (a ': as) -> f a -> t as)

Step function. Applies element to accumulator.

-> (t '[] -> b)

Extract value from accumulator.

-> t xs

Initial state.

-> TFun f xs b 

Fold over N elements exposed as N-ary function.

apply Source #

Arguments

:: (forall a as. t (a ': as) -> (f a, t as))

Extract value to be applied to function.

-> t xs

Initial state.

-> ContVecF xs f 

Apply values to N-ary function

arity :: p xs -> Int Source #

Size of type list as integer.

Instances

Arity α ([] α) Source # 

Methods

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

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

arity :: p xs -> Int Source #

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

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 Source #

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

arity :: p xs -> Int Source #

class Arity (Elems v) => HVector v where Source #

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 :: [*] Source #

Methods

construct :: Fun (Elems v) v Source #

Function for constructing vector

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

Function for constructing vector

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

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 Source #

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

Instances

HVector () Source #

Unit is empty heterogeneous vector

Associated Types

type Elems () :: [*] Source #

Methods

construct :: Fun (Elems ()) () Source #

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

HVector (Complex a) Source # 

Associated Types

type Elems (Complex a) :: [*] Source #

Methods

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

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

Arity * xs => HVector (VecList xs) Source # 

Associated Types

type Elems (VecList xs) :: [*] Source #

Methods

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

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

Arity * xs => HVector (HVec xs) Source # 

Associated Types

type Elems (HVec xs) :: [*] Source #

Methods

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

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

HVector (a, b) Source # 

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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

HVector (a, b, c) Source # 

Associated Types

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

Methods

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

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

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

Associated Types

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

HVector (a, b, c, d) Source # 

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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 Source #

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

Associated Types

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

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) Source #

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 Source #

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

Associated Types

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

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) Source #

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 Source #

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

Associated Types

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

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) Source #

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 Source #

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

Associated Types

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

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) Source #

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 Source #

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

Associated Types

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

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) Source #

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 Source #

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

Associated Types

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

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) Source #

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 Source #

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

Associated Types

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

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) Source #

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 Source #

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

Associated Types

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

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) Source #

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 Source #

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

Associated Types

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

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) Source #

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 Source #

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

Associated Types

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

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) Source #

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 Source #

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

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) :: [*] Source #

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) Source #

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 Source #

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

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) :: [*] Source #

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) Source #

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 Source #

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

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) :: [*] Source #

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) Source #

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 Source #

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) Source # 

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) :: [*] Source #

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) Source #

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 Source #

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) Source # 

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) :: [*] Source #

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) Source #

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 Source #

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) Source # 

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) :: [*] Source #

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) Source #

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 Source #

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') Source # 

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') :: [*] Source #

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') Source #

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 Source #

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') Source # 

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') :: [*] Source #

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') Source #

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 Source #

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') Source # 

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') :: [*] Source #

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') Source #

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 Source #

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') Source # 

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') :: [*] Source #

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') Source #

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 Source #

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') Source # 

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') :: [*] Source #

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') Source #

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 Source #

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') Source # 

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') :: [*] Source #

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') Source #

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 Source #

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

Number of elements in tuple

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

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 :: [α] Source #

Elements of the vector without type constructors

Methods

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

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

Instances

Arity * xs => HVectorF * (HVecF xs) Source # 

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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

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

Associated Types

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

Methods

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

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

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

Number of elements in tuple

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

Indexing of vectors

Minimal complete definition

getF, putF, lensF, lensChF

Associated Types

type ValueAt n xs :: * Source #

Type at position n

Instances

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

Associated Types

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

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

Methods

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

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

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

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

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

Associated Types

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

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

Methods

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

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

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

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) Source #

CPS-encoded vector

type ContVec xs = ContVecF xs Identity Source #

CPS-encoded heterogeneous vector.

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

CPS-encoded partially heterogeneous vector.

Constructors

ContVecF 

Fields

Instances

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

Associated Types

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

Methods

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

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

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

Associated Types

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

type ElemsF α (ContVecF α xs) Source # 
type ElemsF α (ContVecF α xs) = xs
type Elems (ContVecF * xs Identity) Source # 
type Elems (ContVecF * xs Identity) = xs

Other data types

data VecList :: [*] -> * where Source #

List like heterogeneous vector.

Constructors

Nil :: VecList '[] 
Cons :: x -> VecList xs -> VecList (x ': xs) 

Instances

Arity * xs => HVector (VecList xs) Source # 

Associated Types

type Elems (VecList xs) :: [*] Source #

Methods

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

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

type Elems (VecList xs) Source # 
type Elems (VecList xs) = xs

data VecListF (xs :: [α]) (f :: α -> *) where Source #

List-like vector

Constructors

NilF :: VecListF '[] f 
ConsF :: f x -> VecListF xs f -> VecListF (x ': xs) f 

Instances

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

Associated Types

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

Methods

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

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

type ElemsF α (VecListF α xs) Source # 
type ElemsF α (VecListF α xs) = xs

Conversion to/from vector

cvec :: (HVector v, Elems v ~ xs) => v -> ContVec xs Source #

Convert heterogeneous vector to CPS form

vector :: (HVector v, Elems v ~ xs) => ContVec xs -> v Source #

Convert CPS-vector to heterogeneous vector

cvecF :: HVectorF v => v f -> ContVecF (ElemsF v) f Source #

vectorF :: HVectorF v => ContVecF (ElemsF v) f -> v f Source #

Generic API for tuples

Position based functions

head :: Arity xs => ContVec (x ': xs) -> x Source #

Head of vector

tail :: ContVec (x ': xs) -> ContVec xs Source #

Tail of CPS-encoded vector

cons :: x -> ContVec xs -> ContVec (x ': xs) Source #

Cons element to the vector

consF :: f x -> ContVecF xs f -> ContVecF (x ': xs) f Source #

Cons element to the vector

concat :: Arity xs => ContVec xs -> ContVec ys -> ContVec (xs ++ ys) Source #

Concatenate two vectors

Indexing

index :: Index n xs => ContVec xs -> proxy n -> ValueAt n xs Source #

Get value at nth position.

set :: Index n xs => proxy n -> ValueAt n xs -> ContVec xs -> ContVec xs Source #

Set value on nth position.

Folds and unfolds

foldlF :: ArityC c xs => Proxy c -> (forall a. c a => b -> f a -> b) -> b -> ContVecF xs f -> b Source #

Left fold over vector

foldrF :: ArityC c xs => Proxy c -> (forall a. c a => f a -> b -> b) -> b -> ContVecF xs f -> b Source #

Right fold over vector

foldlNatF :: Arity xs => (forall a. b -> f a -> b) -> b -> ContVecF xs f -> b Source #

Left fold over vector

foldrNatF :: Arity xs => (forall a. f a -> b -> b) -> b -> ContVecF xs f -> b Source #

Right fold over vector

unfoldrF :: ArityC c xs => Proxy c -> (forall a. c a => b -> (f a, b)) -> b -> ContVecF xs f Source #

Unfold vector.

Replicate variants

replicateF :: ArityC c xs => Proxy c -> (forall a. c a => f a) -> ContVecF xs f Source #

replicateNatF :: Arity xs => (forall a. f a) -> ContVecF xs f Source #

Zip variants

zipWithF :: ArityC c xs => Proxy c -> (forall a. c a => f a -> g a -> h a) -> ContVecF xs f -> ContVecF xs g -> ContVecF xs h Source #

Zip two heterogeneous vectors

zipWithNatF :: Arity xs => (forall a. f a -> g a -> h a) -> ContVecF xs f -> ContVecF xs g -> ContVecF xs h Source #

Zip two heterogeneous vectors

zipFoldF :: forall xs c m f. (ArityC c xs, Monoid m) => Proxy c -> (forall a. c a => f a -> f a -> m) -> ContVecF xs f -> ContVecF xs f -> m Source #

Zip vector and fold result using monoid

Monomorphization of vectors

monomorphizeF :: forall c xs a f n. (ArityC c xs, Peano n ~ Len xs) => Proxy c -> (forall x. c x => f x -> a) -> ContVecF xs f -> ContVec n a Source #

Convert heterogeneous vector to homogeneous

Manipulation with type constructor

mapNat :: Arity xs => (forall a. f a -> g a) -> ContVecF xs f -> ContVecF xs g Source #

Apply natural transformation to every element of the tuple.

sequenceF :: (Arity xs, Applicative f) => ContVecF xs (f `Compose` g) -> f (ContVecF xs g) Source #

Apply sequence to outer level of parametrized tuple elements.

distributeF :: forall f g xs. (Arity xs, Functor f) => f (ContVecF xs g) -> ContVecF xs (f `Compose` g) Source #