Haskus.Utils.HList

Heterogeneous list

Documentation

data family HList (l :: [Type]) infixr 2

Heterogeneous list

Instances

(Eq x, Eq (HList xs)) => Eq (HList (x ': xs))

Defined in Haskus.Utils.HList

Methods

(==) :: HList (x ': xs) -> HList (x ': xs) -> Bool

(/=) :: HList (x ': xs) -> HList (x ': xs) -> Bool

Eq (HList ('[] :: [Type]))

Defined in Haskus.Utils.HList

Methods

(==) :: HList '[] -> HList '[] -> Bool

(/=) :: HList '[] -> HList '[] -> Bool

(Ord x, Ord (HList xs)) => Ord (HList (x ': xs))

Defined in Haskus.Utils.HList

Methods

compare :: HList (x ': xs) -> HList (x ': xs) -> Ordering

(<) :: HList (x ': xs) -> HList (x ': xs) -> Bool

(<=) :: HList (x ': xs) -> HList (x ': xs) -> Bool

(>) :: HList (x ': xs) -> HList (x ': xs) -> Bool

(>=) :: HList (x ': xs) -> HList (x ': xs) -> Bool

max :: HList (x ': xs) -> HList (x ': xs) -> HList (x ': xs)

min :: HList (x ': xs) -> HList (x ': xs) -> HList (x ': xs)

Ord (HList ('[] :: [Type]))

Defined in Haskus.Utils.HList

Methods

compare :: HList '[] -> HList '[] -> Ordering

(<) :: HList '[] -> HList '[] -> Bool

(<=) :: HList '[] -> HList '[] -> Bool

(>) :: HList '[] -> HList '[] -> Bool

(>=) :: HList '[] -> HList '[] -> Bool

max :: HList '[] -> HList '[] -> HList '[]

min :: HList '[] -> HList '[] -> HList '[]

(Show e, Show (HList l)) => Show (HList (e ': l))

Defined in Haskus.Utils.HList

Methods

showsPrec :: Int -> HList (e ': l) -> ShowS

show :: HList (e ': l) -> String

showList :: [HList (e ': l)] -> ShowS

Show (HList ('[] :: [Type]))

Defined in Haskus.Utils.HList

Methods

showsPrec :: Int -> HList '[] -> ShowS

show :: HList '[] -> String

showList :: [HList '[]] -> ShowS

data HList ('[] :: [Type])

Defined in Haskus.Utils.HList

data HList ('[] :: [Type]) = HNil

data HList (x ': xs)

Defined in Haskus.Utils.HList

data HList (x ': xs) = x `HCons` (HList xs)

hHead :: HList (e ': l) -> e

Head

hTail :: HList (e ': l) -> HList l

Tail

hLength :: forall xs. KnownNat (Length xs) => HList xs -> Word

Length

hAppend :: HAppendList l1 l2 => HList l1 -> HList l2 -> HList (Concat l1 l2)

class HFoldr' f v (l :: [Type]) r where

Like HFoldr but only use types, not values!

It allows us to foldr over a list of types, without any associated hlist of values.

Methods

hFoldr' :: f -> v -> HList l -> r

Instances

v ~ v' => HFoldr' f v ('[] :: [Type]) v'

Defined in Haskus.Utils.HList

Methods

hFoldr' :: f -> v -> HList '[] -> v'

(Apply f (e, r) r', HFoldr' f v l r) => HFoldr' f v (e ': l) r'

Defined in Haskus.Utils.HList

Methods

hFoldr' :: f -> v -> HList (e ': l) -> r'

class HFoldl' f (z :: Type) xs (r :: Type) where

Like HFoldl but only use types, not values!

It allows us to foldl over a list of types, without any associated hlist of values.

Methods

hFoldl' :: f -> z -> HList xs -> r

Instances

z ~ z' => HFoldl' f z ('[] :: [Type]) z'

Defined in Haskus.Utils.HList

Methods

hFoldl' :: f -> z -> HList '[] -> z'

(zx ~ (z, x), Apply f zx z', HFoldl' f z' xs r) => HFoldl' f z (x ': xs) r

Defined in Haskus.Utils.HList

Methods

hFoldl' :: f -> z -> HList (x ': xs) -> r

class HTuple v where

Convert between hlists and tuples

Methods

hToTuple :: HList v -> Tuple v

Convert an heterogeneous list into a tuple

hFromTuple :: Tuple v -> HList v

Convert a tuple into an heterogeneous list

Instances

HTuple ('[] :: [Type])

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[] -> Tuple '[]

hFromTuple :: Tuple '[] -> HList '[]

HTuple '[a, b, c, d, e, f, g, h, i, j, k, l]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a, b, c, d, e, f, g, h, i, j, k, l] -> Tuple '[a, b, c, d, e, f, g, h, i, j, k, l]

hFromTuple :: Tuple '[a, b, c, d, e, f, g, h, i, j, k, l] -> HList '[a, b, c, d, e, f, g, h, i, j, k, l]

HTuple '[a, b, c, d, e, f, g, h, i, j, k]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a, b, c, d, e, f, g, h, i, j, k] -> Tuple '[a, b, c, d, e, f, g, h, i, j, k]

hFromTuple :: Tuple '[a, b, c, d, e, f, g, h, i, j, k] -> HList '[a, b, c, d, e, f, g, h, i, j, k]

HTuple '[a, b, c, d, e, f, g, h, i, j]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a, b, c, d, e, f, g, h, i, j] -> Tuple '[a, b, c, d, e, f, g, h, i, j]

hFromTuple :: Tuple '[a, b, c, d, e, f, g, h, i, j] -> HList '[a, b, c, d, e, f, g, h, i, j]

HTuple '[a, b, c, d, e, f, g, h, i]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a, b, c, d, e, f, g, h, i] -> Tuple '[a, b, c, d, e, f, g, h, i]

hFromTuple :: Tuple '[a, b, c, d, e, f, g, h, i] -> HList '[a, b, c, d, e, f, g, h, i]

HTuple '[a, b, c, d, e, f, g, h]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a, b, c, d, e, f, g, h] -> Tuple '[a, b, c, d, e, f, g, h]

hFromTuple :: Tuple '[a, b, c, d, e, f, g, h] -> HList '[a, b, c, d, e, f, g, h]

HTuple '[a, b, c, d, e, f, g]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a, b, c, d, e, f, g] -> Tuple '[a, b, c, d, e, f, g]

hFromTuple :: Tuple '[a, b, c, d, e, f, g] -> HList '[a, b, c, d, e, f, g]

HTuple '[a, b, c, d, e, f]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a, b, c, d, e, f] -> Tuple '[a, b, c, d, e, f]

hFromTuple :: Tuple '[a, b, c, d, e, f] -> HList '[a, b, c, d, e, f]

HTuple '[a, b, c, d, e]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a, b, c, d, e] -> Tuple '[a, b, c, d, e]

hFromTuple :: Tuple '[a, b, c, d, e] -> HList '[a, b, c, d, e]

HTuple '[a, b, c, d]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a, b, c, d] -> Tuple '[a, b, c, d]

hFromTuple :: Tuple '[a, b, c, d] -> HList '[a, b, c, d]

HTuple '[a, b, c]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a, b, c] -> Tuple '[a, b, c]

hFromTuple :: Tuple '[a, b, c] -> HList '[a, b, c]

HTuple '[a, b]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a, b] -> Tuple '[a, b]

hFromTuple :: Tuple '[a, b] -> HList '[a, b]

HTuple '[a]

Defined in Haskus.Utils.HList

Methods

hToTuple :: HList '[a] -> Tuple '[a]

hFromTuple :: Tuple '[a] -> HList '[a]

class Apply f a b where

Apply the function identified by the data type f from type a to type b.

Methods

apply :: f -> a -> b

class HZipList x y l | x y -> l, l -> x y

Minimal complete definition

hZipList, hUnzipList

Instances

HZipList ('[] :: [Type]) ('[] :: [Type]) ('[] :: [Type])

Defined in Haskus.Utils.HList

Methods

hZipList :: HList '[] -> HList '[] -> HList '[]

hUnzipList :: HList '[] -> (HList '[], HList '[])

((x, y) ~ z, HZipList xs ys zs) => HZipList (x ': xs) (y ': ys) (z ': zs)

Defined in Haskus.Utils.HList

Methods

hZipList :: HList (x ': xs) -> HList (y ': ys) -> HList (z ': zs)

hUnzipList :: HList (z ': zs) -> (HList (x ': xs), HList (y ': ys))

hZipList :: HZipList x y l => HList x -> HList y -> HList l

class HFoldr f v (l :: [Type]) r

Minimal complete definition

hFoldr

Instances

v ~ v' => HFoldr f v ('[] :: [Type]) v'

Defined in Haskus.Utils.HList

Methods

hFoldr :: f -> v -> HList '[] -> v'

(Apply f (e, r) r', HFoldr f v l r) => HFoldr f v (e ': l) r'

Defined in Haskus.Utils.HList

Methods

hFoldr :: f -> v -> HList (e ': l) -> r'

hFoldr :: HFoldr f v l r => f -> v -> HList l -> r

class HFoldl f (z :: Type) xs (r :: Type)

Minimal complete definition

hFoldl

Instances

z ~ z' => HFoldl f z ('[] :: [Type]) z'

Defined in Haskus.Utils.HList

Methods

hFoldl :: f -> z -> HList '[] -> z'

(zx ~ (z, x), Apply f zx z', HFoldl f z' xs r) => HFoldl f z (x ': xs) r

Defined in Haskus.Utils.HList

Methods

hFoldl :: f -> z -> HList (x ': xs) -> r

hFoldl :: HFoldl f z xs r => f -> z -> HList xs -> r

class HReverse xs sx | xs -> sx, sx -> xs where

Methods

hReverse :: HList xs -> HList sx

Instances

(HRevApp xs ('[] :: [Type]) sx, HRevApp sx ('[] :: [Type]) xs) => HReverse xs sx

Defined in Haskus.Utils.HList

Methods

hReverse :: HList xs -> HList sx