Data.Vector.HFixed.Cont

CPS encoded heterogeneous vectors.

CPS-encoded vector

Type classes

type family Fn as b

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

newtype Fun as b

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

Constructors

Fun

Fields

unFun :: Fn as b

Instances

Arity xs => Monad (Fun xs)

Arity xs => Functor (Fun xs)

Arity xs => Applicative (Fun xs)

newtype TFun f as b

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

unTFun :: Fn (Wrap f as) b

Instances

Arity xs => Monad (TFun * f xs)

Arity xs => Functor (TFun * f xs)

Arity xs => Applicative (TFun * f xs)

class Arity (Len xs) => Arity xs where

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.

Methods

accum

Arguments

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

Step function. Applies element to accumulator.

-> (t `[]` -> b)

Extract value from accumulator.

-> t xs

Initial state.

-> Fn xs b

Fold over N elements exposed as N-ary function.

apply

Arguments

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

Extract value to be applied to function.

-> t xs

Initial state.

-> ContVec xs

Apply values to N-ary function

applyM

Arguments

:: Monad m

=> (forall a as. t (a : as) -> m (a, t as))

Extract value to be applied to function

-> t xs

Initial state

-> m (ContVec xs)

Apply value to N-ary function using monadic actions

accumTy :: (forall a as. t (a : as) -> f a -> t as) -> (t `[]` -> b) -> t xs -> Fn (Wrap f xs) b

Analog of accum

applyTy :: (forall a as. t (a : as) -> (f a, t as)) -> t xs -> ContVecF xs f

Analog of apply which allows to works with vectors which elements are wrapped in the newtype constructor.

arity :: p xs -> Int

Size of type list as integer.

witWrapped :: WitWrapped f xs

witConcat :: Arity ys => WitConcat xs ys

witNestedFun :: WitNestedFun xs ys r

witLenWrap :: WitLenWrap f xs

Instances

Arity ([] *)

Arity xs => Arity (: * x xs)

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

inspect :: 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

HVector (Complex a)

Arity xs => HVector (ContVec xs)

Arity xs => HVector (VecList xs)

Arity xs => HVector (HVec xs)

HVector (a, b)

(Storable a, HomArity n a) => HVector (Vec n a)

(Unbox n a, HomArity n a) => HVector (Vec n a)

(Prim a, HomArity n a) => HVector (Vec n a)

HomArity n a => HVector (Vec n a)

(Arity (Wrap * * f xs), Arity xs) => HVector (HVecF xs f)

It's not possible to remove constrain Arity (Wrap f xs) because it's required by superclass and we cannot prove it for all f. witWrapped allow to generate proofs for terms

HVector (a, b, c)

HVector (a, b, c, d)

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

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

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

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

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 (VecListF xs)

Arity xs => HVectorF (HVecF xs)

Arity xs => HVectorF (ContVecF * xs)

class Arity n => Index n xs

Indexing of vectors

Associated Types

type ValueAt n xs :: *

Type at position n

Instances

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

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

type family Wrap f a :: [β]

Wrap every element of list into type constructor

CPS-encoded vector

newtype ContVec xs

CPS-encoded heterogeneous vector.

Constructors

ContVec

Fields

runContVec :: forall r. Fun xs r -> r

Instances

Arity xs => HVector (ContVec xs)

newtype ContVecF xs f

CPS-encoded partially heterogeneous vector.

Constructors

ContVecF (forall r. TFun f xs r -> r)

Instances

Arity xs => HVectorF (ContVecF * xs)

toContVec :: ContVecF xs f -> ContVec (Wrap f xs)

toContVecF :: ContVec (Wrap f xs) -> ContVecF xs f

Other data types

data VecList where

List like heterogeneous vector.

Constructors

Nil :: VecList `[]`

Cons :: x -> VecList xs -> VecList (x : xs)

Instances

Arity xs => HVector (VecList xs)

data VecListF xs f where

List-like vector

Constructors

NilF :: VecListF `[]` f

ConsF :: f x -> VecListF xs f -> VecListF (x : xs) f

Instances

Arity xs => HVectorF (VecListF xs)

Conversion to/from vector

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

Convert heterogeneous vector to CPS form

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

Convert CPS-vector to heterogeneous vector

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

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

Position based functions

head :: forall x xs. Arity xs => ContVec (x : xs) -> x

Head of vector

tail :: ContVec (x : xs) -> ContVec xs

Tail of CPS-encoded vector

cons :: x -> ContVec xs -> ContVec (x : xs)

Cons element to the vector

consF :: f x -> ContVecF xs f -> ContVecF (x : xs) f

Cons element to the vector

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

Concatenate two vectors

Indexing

index :: Index n xs => ContVec xs -> n -> ValueAt n xs

Get value at nth position.

set :: Index n xs => n -> ValueAt n xs -> ContVec xs -> ContVec xs

Set value on nth position.

Constructors

mk0 :: ContVec `[]`

mk1 :: a -> ContVec `[a]`

mk2 :: a -> b -> ContVec `[a, b]`

mk3 :: a -> b -> c -> ContVec `[a, b, c]`

mk4 :: a -> b -> c -> d -> ContVec `[a, b, c, d]`

mk5 :: a -> b -> c -> d -> e -> ContVec `[a, b, c, d, e]`

Folds and unfolds

foldl :: forall xs c b. ArityC c xs => Proxy c -> (forall a. c a => b -> a -> b) -> b -> ContVec xs -> b

Left fold over vector

foldr :: forall xs c b. ArityC c xs => Proxy c -> (forall a. c a => a -> b -> b) -> b -> ContVec xs -> b

Right fold over vector

unfoldr :: forall xs c b. ArityC c xs => Proxy c -> (forall a. c a => b -> (a, b)) -> b -> ContVec xs

Unfold vector.

Polymorphic values

replicate :: forall xs c. ArityC c xs => Proxy c -> (forall x. c x => x) -> ContVec xs

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

replicateM :: forall xs c m. (ArityC c xs, Monad m) => Proxy c -> (forall x. c x => m x) -> m (ContVec xs)

Replicate monadic action n times.

zipMono :: forall xs c. ArityC c xs => Proxy c -> (forall a. c a => a -> a -> a) -> ContVec xs -> ContVec xs -> ContVec xs

Zip two heterogeneous vectors

zipMonoF :: forall xs f c. ArityC c xs => Proxy c -> (forall a. c a => f a -> f a -> f a) -> ContVecF xs f -> ContVecF xs f -> ContVecF xs f

Zip two heterogeneous vectors

zipFold :: forall xs c m. (ArityC c xs, Monoid m) => Proxy c -> (forall a. c a => a -> a -> m) -> ContVec xs -> ContVec xs -> m

Zip vector and fold result using monoid

monomorphize :: forall c xs a. ArityC c xs => Proxy c -> (forall x. c x => x -> a) -> ContVec xs -> ContVec (Len xs) a

Convert heterogeneous vector to homogeneous

monomorphizeF :: forall c xs a f. ArityC c xs => Proxy c -> (forall x. c x => f x -> a) -> ContVecF xs f -> ContVec (Len xs) a

Convert heterogeneous vector to homogeneous

Vector parametrized with type constructor

mapFunctor :: Arity xs => (forall a. f a -> g a) -> ContVecF xs f -> ContVecF xs g

Map functor.

sequence :: (Arity xs, Monad m) => ContVecF xs m -> m (ContVec xs)

Sequence vector's elements

sequenceA :: (Arity xs, Applicative f) => ContVecF xs f -> f (ContVec xs)

Sequence vector's elements

sequenceF :: (Arity xs, Monad m) => ContVecF xs (m `Compose` f) -> m (ContVecF xs f)

Sequence vector's elements

sequenceAF :: (Arity xs, Applicative f) => ContVecF xs (f `Compose` g) -> f (ContVecF xs g)

Sequence vector's elements

distribute :: forall f xs. (Arity xs, Functor f) => f (ContVec xs) -> ContVecF xs f

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

wrap :: Arity xs => (forall a. a -> f a) -> ContVec xs -> ContVecF xs f

Wrap every value in the vector into type constructor.

unwrap :: Arity xs => (forall a. f a -> a) -> ContVecF xs f -> ContVec xs

Unwrap every value in the vector from the type constructor.