Data.Vector.HFixed.Class

Types and type classes

N-ary functions

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

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

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

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

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

Foldable (Proxy *)

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

Generic1 (Proxy *)

Associated Types

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

Methods

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

to1 :: Rep1 (Proxy *) a -> Proxy * 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]

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

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

inspect :: Proxy * a -> Fun (Peano (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 *) = 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 family (xs :: [α]) ++ (ys :: [α]) :: [α] where ...

Concaternation of type level lists.

Equations

'[] ++ ys = ys

(x ': xs) ++ ys = x ': (xs ++ ys)

type family Len (xs :: [α]) :: PeanoNum where ...

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

Equations

Len '[] = Z

Len (x ': xs) = S (Len xs)

type family HomList (n :: PeanoNum) (a :: α) :: [α] where ...

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

Equations

HomList Z a = '[]

HomList (S n) a = a ': HomList n a

Type classes

class 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, arity

Methods

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

Fold over N elements exposed as N-ary function.

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

Apply values to N-ary function

arity :: p xs -> Int

Size of type list as integer.

Instances

Arity ([] *)

Methods

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

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

arity :: p [*] -> Int

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

Methods

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

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

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

class Arity xs => ArityC c xs where

Minimal complete definition

accumC, applyC

Methods

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

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

Apply values to N-ary function

Instances

ArityC c ([] *)

Methods

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

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

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

Methods

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

applyC :: proxy c -> (forall a as. c a => t ((* ': a) as) -> (f a, t as)) -> t ((* ': x) xs) -> ContVecF ((* ': x) 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

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)

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

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

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

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

Number of elements in tuple

CPS-encoded vector

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

Methods

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

constructF :: TFun f (ElemsF (ContVecF xs)) (ContVecF xs 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

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 (ArityPeano 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 (Peano (Dim v)) a) => v a -> Fun (HomList (Peano (Dim v)) a) r -> r

Default implementation of inspect for homogeneous vector.

homConstruct :: forall v a. (Vector v a, HomArity (Peano (Dim v)) a) => Fun (HomList (Peano (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.

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

Conversion function

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.

Primitives for TFun

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

Add one parameter to function which is ignored.

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

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.

stepTFun :: (TFun f xs a -> TFun f ys b) -> TFun f (x ': xs) a -> TFun f (x ': ys) b

Transform function but leave outermost parameter untouched.

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.

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.

lensWorkerTF :: forall f g r x y xs. (Functor f, Arity xs) => (g x -> f (g y)) -> TFun g (y ': xs) r -> TFun g (x ': xs) (f r)

Helper for lens implementation.

class ArityPeano n => Index n xs where

Indexing of vectors

Minimal complete definition

getF, putF, lensF, lensChF

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 :: proxy n -> Fun xs (ValueAt n xs)

Getter function for vectors

putF :: proxy 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) => proxy n -> (v -> f v) -> Fun xs r -> Fun xs (f r)

Helper for implementation of lens

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

Helper for type-changing lens

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)