Data.Vector.HFixed.Class

Types and type classes

Peano numbers

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

HomArity n a => HomArity (S n) a

Methods

toHeterogeneous :: Fun (S n) a r -> Fun (HomList * (S n) a) r

toHomogeneous :: Fun (HomList * (S n) a) r -> Fun (S n) a r

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)

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

Associated Types

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

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

Methods

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

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

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

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

witWrapIndex :: WitWrapIndex f (S n) ((* ': x) xs)

type HomList α (S n) a

type HomList α (S n) a = (:) α a (HomList α n a)

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

type ValueAt (S n) ((:) * x xs)

type ValueAt (S n) ((:) * x xs) = ValueAt n xs

type NewElems (S n) ((:) * x xs) a

type NewElems (S n) ((:) * x xs) a = (:) * x (NewElems n xs a)

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

HomArity Z a

Methods

toHeterogeneous :: Fun Z a r -> Fun (HomList * Z a) r

toHomogeneous :: Fun (HomList * Z a) r -> Fun Z a r

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 xs => Index Z ((:) * x xs)

Associated Types

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

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

Methods

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

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

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

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

witWrapIndex :: WitWrapIndex f Z ((* ': x) xs)

type Add Z n

type Add Z n = n

type Fn Z a b

type Fn Z a b = b

type HomList α Z a

type HomList α Z a = [] α

type ValueAt Z ((:) * x xs)

type ValueAt Z ((:) * x xs) = x

type NewElems Z ((:) * x xs) a

type NewElems Z ((:) * x xs) a = (:) * a xs

Isomorphism between Peano numbers and Nats

class ((~) Nat (ToNat a) b, (~) * (ToPeano b) a) => NatIso a b

Isomorphism between two representations of natural numbers

Instances

NatIso Z 0

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

type family ToPeano (b :: Nat) :: * where ...

Convert Nat number to Peano represenation

Equations

ToPeano 0 = Z

ToPeano n = S (ToPeano ((-) n 1))

type family ToNat a :: Nat where ...

Convert Peano number to Nat

Equations

ToNat Z = 0

ToNat (S k) = (+) 1 (ToNat k)

N-ary functions

type family Fn (as :: [*]) b

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

Instances

type Fn ([] *) b

type Fn ([] *) b = b

type Fn ((:) * a as) b

type Fn ((:) * a as) b = a -> Fn as b

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)

Methods

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

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

return :: a -> Fun xs a

fail :: String -> Fun xs a

Arity xs => Functor (Fun xs)

Methods

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

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

Arity xs => Applicative (Fun xs)

Methods

pure :: a -> Fun xs a

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

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

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

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)

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)

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)

Methods

pure :: a -> TFun * f xs a

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

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

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

funToTFun :: Fun (Wrap f xs) b -> TFun f xs b

Cast Fun to equivalent TFun

tfunToFun :: TFun f xs b -> Fun (Wrap f xs) b

Cast TFun to equivalent Fun

Type functions

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

A concrete, poly-kinded proxy type

Constructors

Proxy

Instances

Monad (Proxy *)

Methods

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

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

return :: a -> Proxy * a

fail :: String -> Proxy * a

Functor (Proxy *)

Methods

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

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

Applicative (Proxy *)

Methods

pure :: a -> Proxy * a

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

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

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

Generic1 (Proxy *)

Associated Types

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

Methods

from1 :: Proxy * a -> Rep1 (Proxy *) a

to1 :: Rep1 (Proxy *) a -> Proxy * a

Alternative (Proxy *)

Methods

empty :: Proxy * a

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

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

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

MonadPlus (Proxy *)

Methods

mzero :: Proxy * a

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

Vector (Proxy *) a

Methods

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

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

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

Bounded (Proxy k s)

Methods

minBound :: Proxy k s

maxBound :: Proxy k s

Enum (Proxy k s)

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)

Methods

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

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

Ord (Proxy k s)

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)

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)

Methods

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

show :: Proxy k s -> String

showList :: [Proxy k s] -> ShowS

Ix (Proxy k s)

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)

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)

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 (Proxy *)

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

type Dim (Proxy *)

type Dim (Proxy *) = Z

type Rep (Proxy k t)

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

type family (xs :: [α]) ++ (ys :: [α]) :: [α]

Concaternation of type level lists.

Instances

type (++) α ([] α) ys

type (++) α ([] α) ys = ys

type (++) α ((:) α x xs) ys

type (++) α ((:) α x xs) ys = (:) α x ((++) α xs ys)

type family Len (xs :: [α]) :: *

Length of type list expressed as type level naturals from fixed-vector.

Instances

type Len α ([] α)

type Len α ([] α) = Z

type Len α ((:) α x xs)

type Len α ((:) α x xs) = S (Len α xs)

type family Wrap (f :: α -> β) (a :: [α]) :: [β]

Wrap every element of list into type constructor

Instances

type Wrap β α f ([] α)

type Wrap β α f ([] α) = [] β

type Wrap β α f ((:) α x xs)

type Wrap β α f ((:) α x xs) = (:) β (f x) (Wrap β α f xs)

type family HomList n (a :: α) :: [α]

Homogeneous type list with length n and element of type a. It uses type level natural defined in fixed-vector.

Instances

type HomList α Z a

type HomList α Z a = [] α

type HomList α (S n) a

type HomList α (S n) a = (:) α a (HomList α n a)

Type classes

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.

Minimal complete definition

accum, apply, applyM, accumTy, applyTy, arity, witWrapped, witConcat, witNestedFun, witLenWrap

Methods

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

Fold over N elements exposed as N-ary function.

apply :: (forall a as. t (a ': as) -> (a, t as)) -> t xs -> ContVec xs

Apply values to N-ary function

applyM :: Monad m => (forall a as. t (a ': as) -> m (a, t as)) -> t xs -> 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 ([] *)

Methods

accum :: (forall a as. t ((* ': a) as) -> a -> t as) -> (t [*] -> b) -> t [*] -> Fn [*] b

apply :: (forall a as. t ((* ': a) as) -> (a, t as)) -> t [*] -> ContVec [*]

applyM :: Monad m => (forall a as. t ((* ': a) as) -> m (a, t as)) -> t [*] -> m (ContVec [*])

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

applyTy :: (forall a as. t ((* ': a) as) -> (f a, t as)) -> t [*] -> ContVecF * [*] f

arity :: p [*] -> Int

witWrapped :: WitWrapped f [*]

witConcat :: Arity ys => WitConcat [*] ys

witNestedFun :: WitNestedFun [*] ys r

witLenWrap :: WitLenWrap f [*]

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

Methods

accum :: (forall a as. t ((* ': a) as) -> a -> t as) -> (t [*] -> b) -> t ((* ': x) xs) -> Fn ((* ': x) xs) b

apply :: (forall a as. t ((* ': a) as) -> (a, t as)) -> t ((* ': x) xs) -> ContVec ((* ': x) xs)

applyM :: Monad m => (forall a as. t ((* ': a) as) -> m (a, t as)) -> t ((* ': x) xs) -> m (ContVec ((* ': x) xs))

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

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

arity :: p ((* ': x) xs) -> Int

witWrapped :: WitWrapped f ((* ': x) xs)

witConcat :: Arity ys => WitConcat ((* ': x) xs) ys

witNestedFun :: WitNestedFun ((* ': x) xs) ys r

witLenWrap :: WitLenWrap f ((* ': x) xs)

class Arity xs => ArityC c xs where

Declares that every type in list satisfy constraint c

Minimal complete definition

witAllInstances

Methods

witAllInstances :: WitAllInstances c xs

Instances

ArityC c ([] *)

Methods

witAllInstances :: WitAllInstances * c [*]

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

Methods

witAllInstances :: WitAllInstances * c ((* ': 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

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

Associated Types

type Elems (ContVec xs) :: [*]

Methods

construct :: Fun (Elems (ContVec xs)) (ContVec xs)

inspect :: ContVec xs -> Fun (Elems (ContVec xs)) 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 n a) => 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 n a) => 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 n a) => 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 n a => 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

(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

Associated Types

type Elems (HVecF xs f) :: [*]

Methods

construct :: Fun (Elems (HVecF xs f)) (HVecF xs f)

inspect :: HVecF xs f -> Fun (Elems (HVecF xs f)) 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

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

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

Associated Types

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

Methods

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

constructF :: TFun * f (ElemsF (VecListF xs)) (VecListF xs f)

Arity xs => HVectorF (HVecF xs)

Associated Types

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

Methods

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

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

Arity xs => HVectorF (ContVecF * xs)

Associated Types

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

Methods

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

constructF :: TFun * f (ElemsF (ContVecF * xs)) (ContVecF * xs f)

Witnesses

data WitWrapped f xs where

Witness that observe fact that if we have instance Arity xs than we have instance Arity (Wrap f xs).

Constructors

WitWrapped :: Arity (Wrap f xs) => WitWrapped f xs

data WitConcat xs ys where

Witness that observe fact that (Arity xs, Arity ys) implies Arity (xs++ys)

Constructors

WitConcat :: Arity (xs ++ ys) => WitConcat xs ys

data WitNestedFun xs ys r where

Observes fact that Fn (xs++ys) r ~ Fn xs (Fn ys r)

Constructors

WitNestedFun :: Fn (xs ++ ys) r ~ Fn xs (Fn ys r) => WitNestedFun xs ys r

data WitLenWrap :: (* -> *) -> [*] -> * where

Observe fact than Len xs ~ Len (Wrap f xs)

Constructors

WitLenWrap :: Len xs ~ Len (Wrap f xs) => WitLenWrap f xs

data WitWrapIndex f n xs where

Proofs for the indexing of wrapped type lists.

Constructors

WitWrapIndex :: (ValueAt n (Wrap f xs) ~ f (ValueAt n xs), Index n (Wrap f xs), Arity (Wrap f xs)) => WitWrapIndex f n xs

data WitAllInstances c xs where

Witness that all elements of type list satisfy predicate c.

Constructors

WitAllInstancesNil :: WitAllInstances c '[]

WitAllInstancesCons :: c x => WitAllInstances c xs -> WitAllInstances c (x ': xs)

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)

Associated Types

type Elems (ContVec xs) :: [*]

Methods

construct :: Fun (Elems (ContVec xs)) (ContVec xs)

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

type Elems (ContVec xs)

type Elems (ContVec xs) = 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)

Associated Types

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

Methods

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

constructF :: TFun * f (ElemsF (ContVecF * xs)) (ContVecF * xs f)

type ElemsF (ContVecF * xs)

type ElemsF (ContVecF * xs) = xs

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

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

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

Interop with homogeneous vectors

class (Arity n, Arity (HomList n a)) => HomArity n a where

Conversion between homogeneous and heterogeneous N-ary functions.

Minimal complete definition

toHeterogeneous, toHomogeneous

Methods

toHeterogeneous :: Fun n a r -> Fun (HomList n a) r

Convert n-ary homogeneous function to heterogeneous.

toHomogeneous :: Fun (HomList n a) r -> Fun n a r

Convert heterogeneous n-ary function to homogeneous.

Instances

HomArity Z a

Methods

toHeterogeneous :: Fun Z a r -> Fun (HomList * Z a) r

toHomogeneous :: Fun (HomList * Z a) r -> Fun Z a r

HomArity n a => HomArity (S n) a

Methods

toHeterogeneous :: Fun (S n) a r -> Fun (HomList * (S n) a) r

toHomogeneous :: Fun (HomList * (S n) a) r -> Fun (S n) a r

homInspect :: (Vector v a, HomArity (Dim v) a) => v a -> Fun (HomList (Dim v) a) r -> r

Default implementation of inspect for homogeneous vector.

homConstruct :: forall v a. (Vector v a, HomArity (Dim v) a) => Fun (HomList (Dim v) a) (v a)

Default implementation of construct for homogeneous vector.

Operations of Fun

Primitives for Fun

curryFun :: Fun (x ': xs) r -> x -> Fun xs r

Apply single parameter to function

uncurryFun :: (x -> Fun xs r) -> Fun (x ': xs) r

Uncurry N-ary function.

uncurryFun2 :: Arity xs => (x -> y -> Fun xs (Fun ys r)) -> Fun (x ': xs) (Fun (y ': ys) r)

curryMany :: forall xs ys r. Arity xs => Fun (xs ++ ys) r -> Fun xs (Fun ys r)

Curry first n arguments of N-ary function.

constFun :: Fun xs r -> Fun (x ': xs) r

Add one parameter to function which is ignored.

stepFun :: (Fun xs a -> Fun ys b) -> Fun (x ': xs) a -> Fun (x ': ys) b

Transform function but leave outermost parameter untouched.

Primitives for TFun

curryTFun :: TFun f (x ': xs) r -> f x -> TFun f xs r

Apply single parameter to function

uncurryTFun :: (f x -> TFun f xs r) -> TFun f (x ': xs) r

Uncurry single parameter

uncurryTFun2 :: (Arity xs, Arity ys) => (f x -> f y -> TFun f xs (TFun f ys r)) -> TFun f (x ': xs) (TFun f (y ': ys) r)

Uncurry two parameters for nested TFun.

shuffleTF :: forall f x xs r. Arity xs => (x -> TFun f xs r) -> TFun f xs (x -> r)

Move first argument of function to its result. This function is useful for implementation of lens.

More complicated functions

concatF :: (Arity xs, Arity ys) => (a -> b -> c) -> Fun xs a -> Fun ys b -> Fun (xs ++ ys) c

Concatenate n-ary functions. This function combine results of both N-ary functions and merge their parameters into single list.

shuffleF :: forall x xs r. Arity xs => (x -> Fun xs r) -> Fun xs (x -> r)

Move first argument of function to its result. This function is useful for implementation of lens.

lensWorkerF :: forall f r x y xs. (Functor f, Arity xs) => (x -> f y) -> Fun (y ': xs) r -> Fun (x ': xs) (f r)

Helper for lens implementation.

class Arity n => Index n xs where

Indexing of vectors

Minimal complete definition

getF, putF, lensF, lensChF, witWrapIndex

Associated Types

type ValueAt n xs :: *

Type at position n

type NewElems n xs a :: [*]

List of types with n'th element replaced by a.

Methods

getF :: n -> Fun xs (ValueAt n xs)

Getter function for vectors

putF :: n -> ValueAt n xs -> Fun xs r -> Fun xs r

Putter function. It applies value x to nth parameter of function.

lensF :: (Functor f, v ~ ValueAt n xs) => n -> (v -> f v) -> Fun xs r -> Fun xs (f r)

Helper for implementation of lens

lensChF :: Functor f => n -> (ValueAt n xs -> f a) -> Fun (NewElems n xs a) r -> Fun xs (f r)

Helper for type-changing lens

witWrapIndex :: WitWrapIndex f n xs

Instances

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

Associated Types

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

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

Methods

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

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

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

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

witWrapIndex :: WitWrapIndex f Z ((* ': x) xs)

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

Associated Types

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

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

Methods

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

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

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

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

witWrapIndex :: WitWrapIndex f (S n) ((* ': x) xs)