Haskus.Utils.HList

Heterogeneous list utils

Documentation

data family HList (l :: [*]) 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 ([] :: [*]))

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

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

Defined in Haskus.Utils.HList

Methods

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

show :: HList [] -> String

showList :: [HList []] -> ShowS

data HList ([] :: [*])

Defined in Haskus.Utils.HList

data HList ([] :: [*]) = 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 :: [*]) 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.

Minimal complete definition

hFoldr'

Methods

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

Instances

v ~ v' => HFoldr' f v ([] :: [*]) 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 :: *) xs (r :: *) where

Like HFoldl but only use types, not values!

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

Minimal complete definition

hFoldl'

Methods

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

Instances

z ~ z' => HFoldl' f z ([] :: [*]) 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 t | v -> t, t -> v where

Convert between hlists and tuples

Minimal complete definition

hToTuple', hFromTuple'

Methods

hToTuple' :: HList v -> t

Convert an heterogeneous list into a tuple

hFromTuple' :: t -> HList v

Convert a tuple into an heterogeneous list

Instances

HTuple' ([] :: [*]) ()

Defined in Haskus.Utils.HList

Methods

hToTuple' :: HList [] -> ()

hFromTuple' :: () -> HList []

HTuple' (a ': ([] :: [*])) (Single a)

Defined in Haskus.Utils.HList

Methods

hToTuple' :: HList (a ': []) -> Single a

hFromTuple' :: Single a -> HList (a ': [])

HTuple' (a ': (b ': ([] :: [*]))) (a, b)

Defined in Haskus.Utils.HList

Methods

hToTuple' :: HList (a ': (b ': [])) -> (a, b)

hFromTuple' :: (a, b) -> HList (a ': (b ': []))

HTuple' (a ': (b ': (c ': ([] :: [*])))) (a, b, c)

Defined in Haskus.Utils.HList

Methods

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

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

HTuple' (a ': (b ': (c ': (d ': ([] :: [*]))))) (a, b, c, d)

Defined in Haskus.Utils.HList

Methods

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

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

HTuple' (a ': (b ': (c ': (d ': (e ': ([] :: [*])))))) (a, b, c, d, e)

Defined in Haskus.Utils.HList

Methods

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

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

HTuple' (a ': (b ': (c ': (d ': (e ': (f ': ([] :: [*]))))))) (a, b, c, d, e, f)

Defined in Haskus.Utils.HList

Methods

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

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

HTuple' (a ': (b ': (c ': (d ': (e ': (f ': (g ': ([] :: [*])))))))) (a, b, c, d, e, f, g)

Defined in Haskus.Utils.HList

Methods

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

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

HTuple' (a ': (b ': (c ': (d ': (e ': (f ': (g ': (h ': ([] :: [*]))))))))) (a, b, c, d, e, f, g, h)

Defined in Haskus.Utils.HList

Methods

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

hFromTuple' :: (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 ': (h ': (i ': ([] :: [*])))))))))) (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 ': []))))))))) -> (a, b, c, d, e, f, g, h, i)

hFromTuple' :: (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 ': (i ': (j ': ([] :: [*]))))))))))) (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 ': [])))))))))) -> (a, b, c, d, e, f, g, h, i, j)

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

class Apply f a b where

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

Minimal complete definition

apply

Methods

apply :: f -> a -> b

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

Minimal complete definition

hZipList, hUnzipList

Instances

HZipList ([] :: [*]) ([] :: [*]) ([] :: [*])

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

Minimal complete definition

hFoldr

Instances

v ~ v' => HFoldr f v ([] :: [*]) 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 :: *) xs (r :: *)

Minimal complete definition

hFoldl

Instances

z ~ z' => HFoldl f z ([] :: [*]) 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

Minimal complete definition

hReverse

Methods

hReverse :: HList xs -> HList sx

Instances

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

Defined in Haskus.Utils.HList

Methods

hReverse :: HList xs -> HList sx