Data.HTree.List

implements a heterogeneous list to use for forests of heterogeneous trees

heterogeneous list

data HList (f :: k -> Type) (ts :: [k]) where

A heterogeneous list

>>> "bla" `HCons` 23 `HCons` HNil :: HList Identity '[ String, Int ]
HCons (Identity "bla") (HCons (Identity 23) HNil)

Constructors

HCons :: forall {k} (f :: k -> Type) (x :: k) (xs :: [k]). f x -> HList f xs -> HList f (x ': xs) infixr 5

HNil :: forall {k} (f :: k -> Type). HList f ('[] :: [k])

Bundled Patterns

pattern (:::) :: forall {a} f (x :: a) xs. f x -> HList f xs -> HList f (x ': xs) infixr 5

pattern synonym for HCons

>>> t = "bla" ::: 23 ::: HNil :: HList Identity '[ String, Int ]
>>> t
HCons (Identity "bla") (HCons (Identity 23) HNil)
>>> case t of (x ::: _) -> runIdentity x
"bla"

pattern HSing :: forall {k} f (a :: k). f a -> HList f '[a]

pattern that allows to construct a singleton HList

>>> HSing 42 :: HList Identity '[ Int ]
HCons (Identity 42) HNil

Instances

(forall x. Eq x => Eq (f x), Typeable f) => Eq (EList (Has (Both (Typeable :: Type -> Constraint) Eq) f))

Defined in Data.HTree.Existential

Methods

(==) :: EList (Has (Both (Typeable :: Type -> Constraint) Eq) f) -> EList (Has (Both (Typeable :: Type -> Constraint) Eq) f) -> Bool

(/=) :: EList (Has (Both (Typeable :: Type -> Constraint) Eq) f) -> EList (Has (Both (Typeable :: Type -> Constraint) Eq) f) -> Bool

Eq (f k2) => Eq (EList (HasIs k2 f))

Defined in Data.HTree.Existential

Methods

(==) :: EList (HasIs k2 f) -> EList (HasIs k2 f) -> Bool

(/=) :: EList (HasIs k2 f) -> EList (HasIs k2 f) -> Bool

(Show (f x), Show (HList f xs)) => Show (HList f (x ': xs))

Defined in Data.HTree.List

Methods

showsPrec :: Int -> HList f (x ': xs) -> ShowS

show :: HList f (x ': xs) -> String

showList :: [HList f (x ': xs)] -> ShowS

Show (HList f ('[] :: [k]))

Defined in Data.HTree.List

Methods

showsPrec :: Int -> HList f ('[] :: [k]) -> ShowS

show :: HList f ('[] :: [k]) -> String

showList :: [HList f ('[] :: [k])] -> ShowS

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

Defined in Data.HTree.List

Methods

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

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

Eq (HList f ('[] :: [k]))

Defined in Data.HTree.List

Methods

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

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

mapping

hcmap :: forall {k} f g (xs :: [k]). forall (c :: k -> Constraint) -> All c xs => (forall (a :: k). c a => f a -> g a) -> HList f xs -> HList g xs

map with a constraint that holds for all elements of the list

>>> import Data.Functor.Const
>>> hcmap @Show (Const . show . runIdentity) (42 `HCons` HSing "bla" :: HList Identity '[ Int, String ])
HCons (Const "42") (HCons (Const "\"bla\"") HNil)

hmap :: forall {k} f g (xs :: [k]). (forall (a :: k). f a -> g a) -> HList f xs -> HList g xs

map with a function that maps forall f a

traversing

htraverse :: forall {k} t f g (xs :: [k]). Applicative t => (forall (a :: k). f a -> t (g a)) -> HList f xs -> t (HList g xs)

traverse a structure with a function

hctraverse :: forall {k} t f g (xs :: [k]). forall (c :: k -> Constraint) -> (All c xs, Applicative t) => (forall (a :: k). c a => f a -> t (g a)) -> HList f xs -> t (HList g xs)

traverse a structure such that a constraint holds; this is the workhorse of mapping and traversing

>>> import Data.Functor.Const
>>> hctraverse @Show (Just . Const . show . runIdentity) (42 `HCons` HSing "bla" :: HList Identity '[ Int, String ])
Just (HCons (Const "42") (HCons (Const "\"bla\"") HNil))

folding

hcFold :: forall {k} f b (xs :: [k]). forall (c :: k -> Constraint) -> All c xs => (forall (a :: k). c a => f a -> b -> b) -> b -> HList f xs -> b

foldr for HLists.

helpers

allTopHList :: forall {k} (f :: k -> Type) (xs :: [k]). HList f xs -> Dict (All (Top :: k -> Constraint) xs)

witnesses that for all HLists, we can always derive the All Top constraint

hconcat :: forall {k} (f :: k -> Type) (xs :: [k]) (ys :: [k]). HList f xs -> HList f ys -> HList f (xs ++ ys) infixr 5

concats two heterogeneous lists