Data.HList.HList

The HList library

(C) 2004, Oleg Kiselyov, Ralf Laemmel, Keean Schupke

Basic declarations for typeful heterogeneous lists.

Heterogeneous type sequences

There are three sensible ways to define HLists:

data HList (l::[*]) where
    HNil  :: HList '[]
    HCons :: e -> HList l -> HList (e ': l)

This ensures that sequences can only be formed with Nil and Cons. The argument to HList is a promoted lists (kind [*]), which has a more attractive syntax.

Earlier versions of HList used an algebraic data type:

data HCons a b = HCons a b
data HNil = HNil

Disadvantages:

• values with types like HCons Int Double to be created, which are nonsense to the functions in HList
• some recursive functions do not need a class with the GADT. For example:

   hInit :: HListGADT (x ': xs) -> HListGADT (HInit (x ': xs))
   hInit (HCons x xs@(HCons _ _)) = HCons x (hInit xs)
   hInit (HCons _ HNil) = HNil

   type family HInit (xs :: [k]) :: [k]
 

but without the GADT, hInit is written as in a class, which complicates inferred types

Advantages

• lazy pattern matches are allowed, so lazy pattern matching on a value undefined :: HList [a,b,c] can create the spine of the list. hProxies avoids the use of undefined, but a slightly more complicated class context has to be written or inferred.
• type inference is better if you want to directly pattern match see stackoverflow post here
• better pattern exhaustiveness checking (as of ghc-7.8)
• standalone deriving works
• Data.Coerce.coerce works because the parameters have role representational, not nominal as they are for the GADT and data family. Probably the GADT/type family actually do have a representational role: http://stackoverflow.com/questions/24222552/does-this-gadt-actually-have-type-role-representational

The data family version (currently used) gives the same type constructor HList :: [*] -> * as the GADT, while pattern matching behaves like the algebraic data type. Furthermore, nonsense values like HCons 1 2 :: HCons Int Int cannot be written with the data family.

A variation on the data family version is

data instance HList '[] = HNil
newtype instance HList (x ': xs) = HCons1 (x, HList xs)
pattern HCons x xs = HCons1 (x, xs)

This allows HList to have a nominal role, but on the other hand the PatternSynonym is not supported with ghc-7.6 and exhaustiveness checking is not as good (warnings for _ being unmatched)

data family HList (l :: [*])

Instances

(SameLengths * ((:) [*] x ((:) [*] y ((:) [*] xy ([] [*])))), HZipList x y xy) => HZip HList x y xy

Methods

hZip :: HList x -> HList y -> HList xy

(SameLengths * ((:) [*] x ((:) [*] y ((:) [*] xy ([] [*])))), HZipList x y xy) => HUnzip HList x y xy

Methods

hUnzip :: HList xy -> (HList x, HList y)

HMapAux HList f ([] *) ([] *)

Methods

hMapAux :: f -> HList [*] -> HList [*]

(HSpanEqBy t f a as fst snd, HGroupBy t f snd gs) => HGroupBy t f ((:) * a as) ((:) * (HList ((:) * a fst)) gs)

Methods

hGroupBy :: Proxy f ((* ': a) as) -> HList ((* ': HList ((* ': a) fst)) gs) -> HList gs

(ApplyAB f e e', HMapAux HList f l l', SameLength * * l l') => HMapAux HList f ((:) * e l) ((:) * e' l')

Methods

hMapAux :: f -> HList ((* ': e) l) -> HList ((* ': e') l')

HExtend e (HList l)

Associated Types

type HExtendR e (HList l) :: *

Methods

(.*.) :: e -> HList l -> HExtendR e (HList l)

HReverse l l' => HBuild' l (HList l')

Methods

hBuild' :: HList l -> HList l'

HInits1 a b => HInits a ((:) * (HList ([] *)) b)

Methods

hInits :: HList a -> HList ((* ': HList [*]) b)

(Bounded x, Bounded (HList xs)) => Bounded (HList ((:) * x xs))

Methods

minBound :: HList ((* ': x) xs)

maxBound :: HList ((* ': x) xs)

Bounded (HList ([] *))

Methods

minBound :: HList [*]

maxBound :: HList [*]

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

Methods

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

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

Eq (HList ([] *))

Methods

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

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

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

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

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 [*]

(HProxies l, Read e, HSequence ReadP ((:) * (ReadP e) readP_l) ((:) * e l), HMapCxt HList ReadElement (AddProxy [*] l) readP_l) => Read (HList ((:) * e l))

Methods

readsPrec :: Int -> ReadS (HList ((* ': e) l))

readList :: ReadS [HList ((* ': e) l)]

readPrec :: ReadPrec (HList ((* ': e) l))

readListPrec :: ReadPrec [HList ((* ': e) l)]

Read (HList ([] *))

Methods

readsPrec :: Int -> ReadS (HList [*])

readList :: ReadS [HList [*]]

readPrec :: ReadPrec (HList [*])

readListPrec :: ReadPrec [HList [*]]

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

Methods

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

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

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

Show (HList ([] *))

Methods

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

show :: HList [*] -> String

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

(Ix x, Ix (HList xs)) => Ix (HList ((:) * x xs))

Methods

range :: (HList ((* ': x) xs), HList ((* ': x) xs)) -> [HList ((* ': x) xs)]

index :: (HList ((* ': x) xs), HList ((* ': x) xs)) -> HList ((* ': x) xs) -> Int

unsafeIndex :: (HList ((* ': x) xs), HList ((* ': x) xs)) -> HList ((* ': x) xs) -> Int

inRange :: (HList ((* ': x) xs), HList ((* ': x) xs)) -> HList ((* ': x) xs) -> Bool

rangeSize :: (HList ((* ': x) xs), HList ((* ': x) xs)) -> Int

unsafeRangeSize :: (HList ((* ': x) xs), HList ((* ': x) xs)) -> Int

Ix (HList ([] *))

Methods

range :: (HList [*], HList [*]) -> [HList [*]]

index :: (HList [*], HList [*]) -> HList [*] -> Int

unsafeIndex :: (HList [*], HList [*]) -> HList [*] -> Int

inRange :: (HList [*], HList [*]) -> HList [*] -> Bool

rangeSize :: (HList [*], HList [*]) -> Int

unsafeRangeSize :: (HList [*], HList [*]) -> Int

(HZip HList a a aa, HMapCxt HList UncurryMappend aa a) => Semigroup (HList a)

Methods

(<>) :: HList a -> HList a -> HList a

sconcat :: NonEmpty (HList a) -> HList a

stimes :: Integral b => b -> HList a -> HList a

(HProxies a, HMapCxt HList ConstMempty (AddProxy [*] a) a, HZip HList a a aa, HMapCxt HList UncurryMappend aa a) => Monoid (HList a)

Analogous to the Monoid instance for tuples

>>> import Data.Monoid
>>> mempty :: HList '[(), All, [Int]]
H[(),All {getAll = True},[]]

>>> mappend (hBuild "a") (hBuild "b") :: HList '[String]
H["ab"]

Methods

mempty :: HList a

mappend :: HList a -> HList a -> HList a

mconcat :: [HList a] -> HList a

(TypeRepsList (HList xs), Typeable * x) => TypeRepsList (HList ((:) * x xs))

Methods

typeRepsList :: HList ((* ': x) xs) -> [TypeRep]

TypeRepsList (HList ([] *))

Methods

typeRepsList :: HList [*] -> [TypeRep]

HAppendList l1 l2 => HAppend (HList l1) (HList l2)

Methods

hAppend :: HList l1 -> HList l2 -> HAppendR * (HList l1) (HList l2)

ApplyAB f e e' => ApplyAB (MapCar f) (e, HList l) (HList ((:) * e' l))

Methods

applyAB :: MapCar f -> (e, HList l) -> HList ((* ': e') l)

HInits1 ([] *) ((:) * (HList ([] *)) ([] *))

Methods

hInits1 :: HList [*] -> HList ((* ': HList [*]) [*])

HTails ([] *) ((:) * (HList ([] *)) ([] *))

Methods

hTails :: HList [*] -> HList ((* ': HList [*]) [*])

Apply (FHUProj sel ns) (HList l, Proxy HNat (HSucc n)) => Apply (Proxy Bool False, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

Associated Types

type ApplyR (Proxy Bool False, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n) :: *

Methods

apply :: (Proxy Bool False, FHUProj sel ns) -> (HList ((* ': e) l), Proxy HNat n) -> ApplyR (Proxy Bool False, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n)

Apply (Proxy Bool True, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

Associated Types

type ApplyR (Proxy Bool True, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n) :: *

Methods

apply :: (Proxy Bool True, FHUProj sel ns) -> (HList ((* ': e) l), Proxy HNat n) -> ApplyR (Proxy Bool True, FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n)

((~) * ch (Proxy Bool (HBoolEQ sel (KMember n ns))), Apply (ch, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)) => Apply (FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

Associated Types

type ApplyR (FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n) :: *

Methods

apply :: FHUProj sel ns -> (HList ((* ': e) l), Proxy HNat n) -> ApplyR (FHUProj sel ns) (HList ((* ': e) l), Proxy HNat n)

Apply (FHUProj sel ns) (HList ([] *), n)

Associated Types

type ApplyR (FHUProj sel ns) (HList [*], n) :: *

Methods

apply :: FHUProj sel ns -> (HList [*], n) -> ApplyR (FHUProj sel ns) (HList [*], n)

(HConcatFD as bs, HAppendFD a bs cs) => HConcatFD ((:) * (HList a) as) cs

Methods

hConcatFD :: HList ((* ': HList a) as) -> HList cs

(HInits1 xs ys, HMapCxt HList (FHCons2 x) ys ys', (~) [*] (HMapCons x ys) ys', (~) [*] (HMapTail ys') ys) => HInits1 ((:) * x xs) ((:) * (HList ((:) * x ([] *))) ys')

Methods

hInits1 :: HList ((* ': x) xs) -> HList ((* ': HList ((* ': x) [*])) ys')

HTails xs ys => HTails ((:) * x xs) ((:) * (HList ((:) * x xs)) ys)

Methods

hTails :: HList ((* ': x) xs) -> HList ((* ': HList ((* ': x) xs)) ys)

HMapUnboxF xs us => HMapUnboxF ((:) * (HList x) xs) ((:) * (RecordU x) us)

((~) * (HList ((:) * x y)) z, HZip3 xs ys zs) => HZip3 ((:) * x xs) ((:) * (HList y) ys) ((:) * z zs)

Methods

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

type HExtendR e (HList l)

type HExtendR e (HList l) = HList ((:) * e l)

type HMapCons x ((:) * (HList a) b)

type HMapCons x ((:) * (HList a) b) = (:) * (HList ((:) * x a)) (HMapCons x b)

type UnHList (HList a)

type UnHList (HList a) = a

data HList ([] *)

data HList ([] *) = HNil

type HAppendR * (HList l1) (HList l2)

type HAppendR * (HList l1) (HList l2) = HList (HAppendListR * l1 l2)

type ApplyR (Proxy Bool False, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

type ApplyR (Proxy Bool False, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n) = ApplyR (FHUProj sel ns) (HList l, Proxy HNat (HSucc n))

type ApplyR (Proxy Bool True, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

type ApplyR (Proxy Bool True, FHUProj sel ns) (HList ((:) * e l), Proxy HNat n) = HJust (e, (HList l, Proxy HNat (HSucc n)))

type ApplyR (FHUProj sel ns) (HList ([] *), n)

type ApplyR (FHUProj sel ns) (HList ([] *), n) = HNothing

type ApplyR (FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

type ApplyR (FHUProj sel ns) (HList ((:) * e l), Proxy HNat n) = ApplyR (Proxy Bool (HBoolEQ sel (KMember n ns)), FHUProj sel ns) (HList ((:) * e l), Proxy HNat n)

type HMapTail ((:) * (HList ((:) * a as)) bs)

type HMapTail ((:) * (HList ((:) * a as)) bs) = (:) * (HList as) (HMapTail bs)

data HList ((:) * x xs)

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

class HProxiesFD (xs :: [*]) pxs | pxs -> xs, xs -> pxs where

creates a HList of Proxies

Minimal complete definition

hProxies

Methods

hProxies :: HList pxs

Instances

HProxiesFD ([] *) ([] *)

Methods

hProxies :: HList [*]

HProxiesFD xs pxs => HProxiesFD ((:) * x xs) ((:) * (Proxy * x) pxs)

Methods

hProxies :: HList ((* ': Proxy * x) pxs)

type HProxies xs = HProxiesFD xs (AddProxy xs)

type family AddProxy (xs :: k) :: k

Add Proxy to a type

>>> let x = undefined :: HList (AddProxy [Char,Int])
>>> :t x
x :: HList '[Proxy Char, Proxy Int]

Instances

type AddProxy * x

type AddProxy * x = Proxy * x

type AddProxy [k] ([] k)

type AddProxy [k] ([] k) = [] k

type AddProxy [a] ((:) a x xs)

type AddProxy [a] ((:) a x xs) = (:) a (AddProxy a x) (AddProxy [a] xs)

type family DropProxy (xs :: k) :: k

inverse of AddProxy

Instances

type DropProxy [k] ([] k)

type DropProxy [k] ([] k) = [] k

type DropProxy * (Proxy * x)

type DropProxy * (Proxy * x) = x

type DropProxy [a] ((:) a x xs)

type DropProxy [a] ((:) a x xs) = (:) a (DropProxy a x) (DropProxy [a] xs)

data ReadElement

Constructors

ReadElement

Instances

((~) * y (ReadP x), Read x) => ApplyAB ReadElement (Proxy * x) y

Methods

applyAB :: ReadElement -> Proxy * x -> y

Basic list functions

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

head

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

tail

hLast :: HRevApp l1 ([] *) ((:) * e l) => HList l1 -> e

last

class HInit xs where

Minimal complete definition

hInit

Associated Types

type HInitR xs :: [*]

Methods

hInit :: HList xs -> HList (HInitR xs)

Instances

HInit ((:) * b c) => HInit ((:) * a ((:) * b c))

Associated Types

type HInitR ((* ': a) ((* ': b) c) :: [*]) :: [*]

Methods

hInit :: HList ((* ': a) ((* ': b) c)) -> HList (HInitR ((* ': a) ((* ': b) c)))

HInit ((:) * x ([] *))

Associated Types

type HInitR ((* ': x) [*] :: [*]) :: [*]

Methods

hInit :: HList ((* ': x) [*]) -> HList (HInitR ((* ': x) [*]))

type family HLength (x :: [k]) :: HNat

Length, but see HLengthEq instead

Instances

type HLength k ([] k)

type HLength k ([] k) = HZero

type HLength k ((:) k x xs)

type HLength k ((:) k x xs) = HSucc (HLength k xs)

hLength :: HLengthEq l n => HList l -> Proxy n

Append

type family HAppendListR (l1 :: [k]) (l2 :: [k]) :: [k]

Instances

type HAppendListR k ([] k) l

type HAppendListR k ([] k) l = l

type HAppendListR k ((:) k e l) l'

type HAppendListR k ((:) k e l) l' = (:) k e (HAppendListR k l l')

class HAppendList l1 l2 where

Minimal complete definition

hAppendList

Methods

hAppendList :: HList l1 -> HList l2 -> HList (HAppendListR l1 l2)

the same as hAppend

Instances

HAppendList ([] *) l2

Methods

hAppendList :: HList [*] -> HList l2 -> HList (HAppendListR * [*] l2)

HAppendList l l' => HAppendList ((:) * x l) l'

Methods

hAppendList :: HList ((* ': x) l) -> HList l' -> HList (HAppendListR * ((* ': x) l) l')

Alternative append

append' :: [a] -> [a] -> [a]

hAppend' below is implemented using the same idea

hAppend' :: HFoldr FHCons v l r => HList l -> v -> r

Alternative implementation of hAppend. Demonstrates HFoldr

data FHCons

Constructors

FHCons

Instances

((~) * x (e, HList l), (~) * y (HList ((:) * e l))) => ApplyAB FHCons x y

Methods

applyAB :: FHCons -> x -> y

Historical append

The original HList code is included below. In both cases we had to program the algorithm twice, at the term and the type levels.

The class HAppend

class HAppend l l' l'' | l l' -> l''
 where
  hAppend :: l -> l' -> l''

The instance following the normal append

instance HList l => HAppend HNil l l
 where
  hAppend HNil l = l

instance (HList l, HAppend l l' l'')
      => HAppend (HCons x l) l' (HCons x l'')
 where
  hAppend (HCons x l) l' = HCons x (hAppend l l')

Reversing HLists

type family HRevAppR (l1 :: [k]) (l2 :: [k]) :: [k]

Instances

type HRevAppR k ([] k) l

type HRevAppR k ([] k) l = l

type HRevAppR a ((:) a e l) l'

type HRevAppR a ((:) a e l) l' = HRevAppR a l ((:) a e l')

class HRevApp l1 l2 l3 | l1 l2 -> l3 where

Minimal complete definition

hRevApp

Methods

hRevApp :: HList l1 -> HList l2 -> HList l3

Instances

HRevApp ([] *) l2 l2

Methods

hRevApp :: HList [*] -> HList l2 -> HList l2

HRevApp l ((:) * x l') z => HRevApp ((:) * x l) l' z

Methods

hRevApp :: HList ((* ': x) l) -> HList l' -> HList z

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

Methods

hReverse :: HList xs -> HList sx

hReverse_ :: HRevApp l1 ([] *) l3 => HList l1 -> HList l3

a version of hReverse that does not allow the type information to flow backwards

A nicer notation for lists

hEnd :: HList l -> HList l

Note:

x :: HList a

means: forall a. x :: HList a

hEnd x

means: exists a. x :: HList a

List termination

hBuild :: HBuild' '[] r => r

Building lists

class HBuild' l r where

Minimal complete definition

hBuild'

Methods

hBuild' :: HList l -> r

Instances

HReverse l l' => HBuild' l (HList l')

Methods

hBuild' :: HList l -> HList l'

(HReverse l lRev, HMapTaggedFn lRev l') => HBuild' l (Record l')

This instance allows creating a Record with

hBuild 3 a :: Record '[Tagged "x" Int, Tagged "y" Char]

Methods

hBuild' :: HList l -> Record l'

HBuild' ((:) * a l) r => HBuild' l (a -> r)

Methods

hBuild' :: HList l -> a -> r

examples

The classes above allow the third (shortest) way to make a list (containing a,b,c) in this case

list = a `HCons` b `HCons` c `HCons` HNil
list = a .*. b .*. c .*. HNil
list = hEnd $ hBuild a b c

>>> let x = hBuild True in hEnd x
H[True]

>>> let x = hBuild True 'a' in hEnd x
H[True,'a']

>>> let x = hBuild True 'a' "ok" in hEnd x
H[True,'a',"ok"]

hBuild can also produce a Record, such that

hBuild x y ^. from unlabeled

can also be produced using

hEndR $ hBuild x y

historical

the show instance has since changed, but these uses of 'hBuild'/'hEnd' still work

HList> let x = hBuild True in hEnd x
HCons True HNil

HList> let x = hBuild True 'a' in hEnd x
HCons True (HCons 'a' HNil)

HList> let x = hBuild True 'a' "ok" in hEnd x
HCons True (HCons 'a' (HCons "ok" HNil))

HList> hEnd (hBuild (Key 42) (Name "Angus") Cow (Price 75.5))
HCons (Key 42) (HCons (Name "Angus") (HCons Cow (HCons (Price 75.5) HNil)))

HList> hEnd (hBuild (Key 42) (Name "Angus") Cow (Price 75.5)) == angus
True

folds

foldr

Consume a heterogenous list.

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

Minimal complete definition

hFoldr

Methods

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

Instances

(~) * v v' => HFoldr f v ([] *) v'

Methods

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

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

uses ApplyAB not Apply

Methods

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

class HScanr f z ls rs where

Minimal complete definition

hScanr

Methods

hScanr :: f -> z -> HList ls -> HList rs

Instances

(~) [*] lz ((:) * z ([] *)) => HScanr f z ([] *) lz

Methods

hScanr :: f -> z -> HList [*] -> HList lz

(ApplyAB f (x, r) s, HScanr f z xs ((:) * r rs), (~) [*] srrs ((:) * s ((:) * r rs))) => HScanr f z ((:) * x xs) srrs

Methods

hScanr :: f -> z -> HList ((* ': x) xs) -> HList srrs

class HFoldr1 f (l :: [*]) r where

Minimal complete definition

hFoldr1

Methods

hFoldr1 :: f -> HList l -> r

Instances

(ApplyAB f (e, r) r', HFoldr1 f ((:) * e' l) r) => HFoldr1 f ((:) * e ((:) * e' l)) r'

uses ApplyAB not Apply

Methods

hFoldr1 :: f -> HList ((* ': e) ((* ': e') l)) -> r'

(~) * v v' => HFoldr1 f ((:) * v ([] *)) v'

Methods

hFoldr1 :: f -> HList ((* ': v) [*]) -> v'

foldl

class HFoldl f (z :: *) xs (r :: *) where

like foldl

>>> hFoldl (uncurry $ flip (:)) [] (1 `HCons` 2 `HCons` HNil)
[2,1]

Minimal complete definition

hFoldl

Methods

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

Instances

(~) * z z' => HFoldl f z ([] *) z'

Methods

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

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

Methods

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

unfolds

unfold

Produce a heterogenous list. Uses the more limited Apply instead of App since that's all that is needed for uses of this function downstream. Those could in principle be re-written.

hUnfold :: (Apply f a, HUnfoldFD f (ApplyR f a) z) => f -> a -> HList z

type HUnfold p s = HUnfoldR p (ApplyR p s)

type family HUnfoldR p res :: [*]

Instances

type HUnfoldR p HNothing

type HUnfoldR p HNothing = [] *

type HUnfoldR p (HJust (e, s))

type HUnfoldR p (HJust (e, s)) = (:) * e (HUnfoldR p (ApplyR p s))

type HUnfold' p res = HUnfoldFD p (ApplyR p res) (HUnfold p res)

class HUnfoldFD p res z | p res -> z where

Minimal complete definition

hUnfold'

Methods

hUnfold' :: p -> res -> HList z

Instances

HUnfoldFD p HNothing ([] *)

Methods

hUnfold' :: p -> HNothing -> HList [*]

(Apply p s, HUnfoldFD p (ApplyR p s) z) => HUnfoldFD p (HJust (e, s)) ((:) * e z)

Methods

hUnfold' :: p -> HJust (e, s) -> HList ((* ': e) z)

replicate

class HLengthEq es n => HReplicateFD (n :: HNat) e es | n e -> es, es -> n where

Sometimes the result type can fix the type of the first argument:

>>> hReplicate Proxy () :: HList '[ (), (), () ]
H[(),(),()]

However, with HReplicate all elements must have the same type, so it may be easier to use HList2List:

>>> list2HList (repeat 3) :: Maybe (HList [Int, Int, Int])
Just H[3,3,3]

Minimal complete definition

hReplicate

Methods

hReplicate :: Proxy n -> e -> HList es

Instances

HReplicateFD HZero e ([] *)

Methods

hReplicate :: Proxy HNat HZero -> e -> HList [*]

(HReplicateFD n e es, (~) * e e') => HReplicateFD (HSucc n) e ((:) * e' es)

Methods

hReplicate :: Proxy HNat (HSucc n) -> e -> HList ((* ': e') es)

type HReplicate n e = HReplicateFD n e (HReplicateR n e)

type family HReplicateR (n :: HNat) (e :: k) :: [k]

would be associated with HReplicate except we want it to work with e of any kind, not just * that you can put into a HList. An "inverse" of HLength

Instances

type HReplicateR k HZero e

type HReplicateR k HZero e = [] k

type HReplicateR k (HSucc n) e

type HReplicateR k (HSucc n) e = (:) k e (HReplicateR k n e)

class HLengthEq r n => HReplicateF (n :: HNat) f z r | r -> n where

HReplicate produces lists that can be converted to ordinary lists

>>> let two = hSucc (hSucc hZero)
>>> let f = Fun' fromInteger :: Fun' Num Integer

>>> :t applyAB f
applyAB f :: Num b => Integer -> b

>>> hReplicateF two f 3
H[3,3]

>>> hReplicateF Proxy f 3 :: HList [Int, Double, Integer]
H[3,3.0,3]

Minimal complete definition

hReplicateF

Methods

hReplicateF :: HLengthEq r n => Proxy n -> f -> z -> HList r

Instances

HReplicateF HZero f z ([] *)

Methods

hReplicateF :: Proxy HNat HZero -> f -> z -> HList [*]

(ApplyAB f z fz, HReplicateF n f z r') => HReplicateF (HSucc n) f z ((:) * fz r')

Methods

hReplicateF :: Proxy HNat (HSucc n) -> f -> z -> HList ((* ': fz) r')

iterate

class HLengthEq r n => HIterate n f z r where

This function behaves like iterate, with an extra argument to help figure out the result length

>>> let three = hSucc (hSucc (hSucc hZero))
>>> let f = Fun Just :: Fun '() Maybe

>>> :t applyAB f
applyAB f :: a -> Maybe a

f is applied to different types:

>>> hIterate three f ()
H[(),Just (),Just (Just ())]

It is also possible to specify the length later on, as done with Prelude.iterate

>>> let take3 x | _ <- hLength x `asTypeOf` three = x
>>> take3 $ hIterate Proxy f ()
H[(),Just (),Just (Just ())]

Minimal complete definition

hIterate

Methods

hIterate :: HLengthEq r n => Proxy n -> f -> z -> HList r

Instances

HIterate HZero f z ([] *)

Methods

hIterate :: Proxy HNat HZero -> f -> z -> HList [*]

(ApplyAB f z z', HIterate n f z' r', (~) * z z_) => HIterate (HSucc n) f z ((:) * z_ r')

Methods

hIterate :: Proxy HNat (HSucc n) -> f -> z -> HList ((* ': z_) r')

concat

type HConcat xs = HConcatFD xs (HConcatR xs)

Like concat but for HLists of HLists.

Works in ghci... puzzling as what is different in doctest (it isn't -XExtendedDefaultRules)

>>> let a = hEnd $ hBuild 1 2 3
>>> let b = hEnd $ hBuild 'a' "abc"
>>> hConcat $ hBuild a b
H[1,2,3,'a',"abc"]

hConcat :: HConcat xs => HList xs -> HList (HConcatR xs)

type family HConcatR (a :: [*]) :: [*]

Instances

type HConcatR ([] *)

type HConcatR ([] *) = [] *

type HConcatR ((:) * x xs)

type HConcatR ((:) * x xs) = HAppendListR * (UnHList x) (HConcatR xs)

type family UnHList a :: [*]

Instances

type UnHList (HList a)

type UnHList (HList a) = a

class HConcatFD xxs xs | xxs -> xs where

Minimal complete definition

hConcatFD

Methods

hConcatFD :: HList xxs -> HList xs

Instances

HConcatFD ([] *) ([] *)

Methods

hConcatFD :: HList [*] -> HList [*]

(HConcatFD as bs, HAppendFD a bs cs) => HConcatFD ((:) * (HList a) as) cs

Methods

hConcatFD :: HList ((* ': HList a) as) -> HList cs

class HAppendFD a b ab | a b -> ab where

Minimal complete definition

hAppendFD

Methods

hAppendFD :: HList a -> HList b -> HList ab

Instances

HAppendFD ([] *) b b

Methods

hAppendFD :: HList [*] -> HList b -> HList b

HAppendFD as bs cs => HAppendFD ((:) * a as) bs ((:) * a cs)

Methods

hAppendFD :: HList ((* ': a) as) -> HList bs -> HList ((* ': a) cs)

traversing HLists

producing HList

map

It could be implemented with hFoldr, as we show further below

newtype HMap f

hMap is written such that the length of the result list can be determined from the length of the argument list (and the other way around). Similarly, the type of the elements of the list is propagated in both directions too.

>>> :set -XNoMonomorphismRestriction
>>> let xs = 1 .*. 'c' .*. HNil
>>> :t hMap (HJust ()) xs
hMap (HJust ()) xs :: Num y => HList '[HJust y, HJust Char]

These 4 examples show that the constraint on the length (2 in this case) can be applied before or after the hMap. That inference is independent of the direction that type information is propagated for the individual elements.

>>> let asLen2 xs = xs `asTypeOf` (undefined :: HList '[a,b])

>>> let lr xs = asLen2 (applyAB (HMap HRead) xs)
>>> let ls xs = asLen2 (applyAB (HMap HShow) xs)
>>> let rl xs = applyAB (HMap HRead) (asLen2 xs)
>>> let sl xs = applyAB (HMap HShow) (asLen2 xs)

>>> :t lr
lr
  :: (Read ..., Read ...) => HList '[String, String] -> HList '[..., ...]

>>> :t rl
rl
  :: (Read ..., Read ...) => HList '[String, String] -> HList '[..., ...]

>>> :t ls
ls
  :: (Show ..., Show ...) => HList '[..., ...] -> HList '[String, String]

>>> :t sl
sl
  :: (Show ..., Show ...) => HList '[..., ...] -> HList '[String, String]

Constructors

HMap f

Instances

(HMapCxt r f a b, (~) * as (r a), (~) * bs (r b)) => ApplyAB (HMap f) as bs

Methods

applyAB :: HMap f -> as -> bs

hMap :: (HMapAux r f a b, SameLength' * * b a, SameLength' * * a b) => f -> r a -> r b

hMapL :: (HMapAux HList f a b, SameLength' * * b a, SameLength' * * a b) => f -> HList a -> HList b

hMap constrained to HList

newtype HMapL f

Constructors

HMapL f

Instances

(HMapCxt HList f a b, (~) * as (HList a), (~) * bs (HList b)) => ApplyAB (HMapL f) as bs

Methods

applyAB :: HMapL f -> as -> bs

class (SameLength a b, HMapAux r f a b) => HMapCxt r f a b

Instances

(SameLength * * a b, HMapAux r f a b) => HMapCxt r f a b

class HMapAux (r :: [*] -> *) f (x :: [*]) (y :: [*]) where

Minimal complete definition

hMapAux

Methods

hMapAux :: SameLength x y => f -> r x -> r y

Instances

HMapAux HList (HFmap f) x y => HMapAux Record f x y

Methods

hMapAux :: f -> Record x -> Record y

HMapAux Variant f xs ys => HMapAux TIC f xs ys

Methods

hMapAux :: f -> TIC xs -> TIC ys

(ApplyAB f (GetElemTy x) (GetElemTy y), IArray UArray (GetElemTy y), IArray UArray (GetElemTy x)) => HMapAux RecordU f x y

Methods

hMapAux :: f -> RecordU x -> RecordU y

HMapAux HList f ([] *) ([] *)

Methods

hMapAux :: f -> HList [*] -> HList [*]

(ApplyAB f e e', HMapAux HList f l l', SameLength * * l l') => HMapAux HList f ((:) * e l) ((:) * e' l')

Methods

hMapAux :: f -> HList ((* ': e) l) -> HList ((* ': e') l')

(ApplyAB f te te', HMapCxt Variant f ((:) * l ls) ((:) * l' ls')) => HMapAux Variant f ((:) * te ((:) * l ls)) ((:) * te' ((:) * l' ls'))

Methods

hMapAux :: f -> Variant ((* ': te) ((* ': l) ls)) -> Variant ((* ': te') ((* ': l') ls'))

ApplyAB f te te' => HMapAux Variant f ((:) * te ([] *)) ((:) * te' ([] *))

Methods

hMapAux :: f -> Variant ((* ': te) [*]) -> Variant ((* ': te') [*])

alternative implementation

currently broken

newtype MapCar f

Constructors

MapCar f

Instances

ApplyAB f e e' => ApplyAB (MapCar f) (e, HList l) (HList ((:) * e' l))

Methods

applyAB :: MapCar f -> (e, HList l) -> HList ((* ': e') l)

hMapMapCar :: HFoldr (MapCar f) (HList '[]) l l' => f -> HList l -> l'

Same as hMap only a different implementation.

appEndo . mconcat . map Endo

hComposeList :: HFoldr Comp (a -> a) l (t -> a) => HList l -> t -> a

>>> let xs = length .*. (+1) .*. (*2) .*. HNil
>>> hComposeList xs "abc"
8

sequence

class (Applicative m, SameLength a b) => HSequence m a b | a -> b, m b -> a where

A heterogeneous version of

sequenceA :: (Applicative m) => [m a] -> m [a]

Only now we operate on heterogeneous lists, where different elements may have different types a. In the argument list of monadic values (m a_i), although a_i may differ, the monad m must be the same for all elements. That's why we needed Data.HList.TypeCastGeneric2 (currently (~)). The typechecker will complain if we attempt to use hSequence on a HList of monadic values with different monads.

The hSequence problem was posed by Matthias Fischmann in his message on the Haskell-Cafe list on Oct 8, 2006

http://www.haskell.org/pipermail/haskell-cafe/2006-October/018708.html

http://www.haskell.org/pipermail/haskell-cafe/2006-October/018784.html

Maybe

>>> hSequence $ Just (1 :: Integer) `HCons` (Just 'c') `HCons` HNil
Just H[1,'c']

>>> hSequence $  return 1 `HCons` Just  'c' `HCons` HNil
Just H[1,'c']

List

>>> hSequence $ [1] `HCons` ['c'] `HCons` HNil
[H[1,'c']]

Minimal complete definition

hSequence

Methods

hSequence :: HList a -> m (HList b)

Instances

Applicative m => HSequence m ([] *) ([] *)

Methods

hSequence :: HList [*] -> m (HList [*])

((~) (* -> *) m1 m, Applicative m, HSequence m as bs) => HSequence m ((:) * (m1 a) as) ((:) * a bs)

Methods

hSequence :: HList ((* ': m1 a) as) -> m (HList ((* ': a) bs))

alternative implementation

hSequence2 :: (HFoldr (LiftA2 FHCons) (f (HList ([] *))) l (f a), Applicative f) => HList l -> f a

hSequence2 is not recommended over hSequence since it possibly doesn't allow inferring argument types from the result types. Otherwise this version should do exactly the same thing.

The DataKinds version needs a little help to find the type of the return HNil, unlike the original version, which worked just fine as

hSequence l = hFoldr ConsM (return HNil) l

producing homogenous lists

map (no sequencing)

This one we implement via hFoldr

newtype Mapcar f

Constructors

Mapcar f

Instances

((~) * l [e'], ApplyAB f e e', (~) * el (e, l)) => ApplyAB (Mapcar f) el l

Methods

applyAB :: Mapcar f -> el -> l

type HMapOut f l e = HFoldr (Mapcar f) [e] l [e]

hMapOut :: forall f e l. HMapOut f l e => f -> HList l -> [e]

compare hMapOut f with hList2List . hMap f

mapM

hMapM :: (Monad m, HMapOut f l (m e)) => f -> HList l -> [m e]

mapM :: forall b m a. (Monad m) => (a -> m b) -> [a] -> m [b]

Likewise for mapM_.

See hSequence if the result list should also be heterogenous.

hMapM_ :: (Monad m, HMapOut f l (m ())) => f -> HList l -> m ()

GHC doesn't like its own type.

hMapM_ :: forall m a f e. (Monad m, HMapOut f a (m e)) => f -> a -> m ()

Without explicit type signature, it's Ok. Sigh. Anyway, Hugs does insist on a better type. So we restrict as follows:

Ensure a list to contain HNats only

type family HNats (l :: [*]) :: [HNat]

We do so constructively, converting the HList whose elements are Proxy HNat to [HNat]. The latter kind is unpopulated and is present only at the type level.

Instances

type HNats ([] *)

type HNats ([] *) = [] HNat

type HNats ((:) * (Proxy HNat n) l)

type HNats ((:) * (Proxy HNat n) l) = (:) HNat n (HNats l)

hNats :: HList l -> Proxy (HNats l)

Membership tests

class HMember (e1 :: k) (l :: [k]) (b :: Bool) | e1 l -> b

Check to see if an HList contains an element with a given type This is a type-level only test

Instances

HMember k e1 ([] k) False

(HEq a e1 e b, HMember' a b e1 l br) => HMember a e1 ((:) a e l) br

class HMember' (b0 :: Bool) (e1 :: k) (l :: [k]) (b :: Bool) | b0 e1 l -> b

Instances

HMember k e1 l br => HMember' k False e1 l br

HMember' k True e1 l True

type family HMemberP pred e1 (l :: [*]) :: Bool

The following is a similar type-only membership test It uses the user-supplied curried type equality predicate pred

Instances

type HMemberP pred e1 ([] *)

type HMemberP pred e1 ([] *) = False

type HMemberP pred e1 ((:) * e l)

type HMemberP pred e1 ((:) * e l) = HMemberP' pred e1 l (ApplyR pred (e1, e))

type family HMemberP' pred e1 (l :: [*]) pb :: Bool

Instances

type HMemberP' pred e1 l (Proxy Bool False)

type HMemberP' pred e1 l (Proxy Bool False) = HMemberP pred e1 l

type HMemberP' pred e1 l (Proxy Bool True)

type HMemberP' pred e1 l (Proxy Bool True) = True

hMember :: HMember e l b => Proxy e -> Proxy l -> Proxy b

Another type-level membership test

class HMemberM (e1 :: k) (l :: [k]) (r :: Maybe [k]) | e1 l -> r

Check to see if an element e occurs in a list l If not, return 'Nothing If the element does occur, return 'Just l1 where l1 is a type-level list without e

Instances

HMemberM k e1 ([] k) (Nothing [k])

(HEq a e1 e b, HMemberM1 a b e1 ((:) a e l) res) => HMemberM a e1 ((:) a e l) res

class HMemberM1 (b :: Bool) (e1 :: k) (l :: [k]) (r :: Maybe [k]) | b e1 l -> r

Instances

(HMemberM a e1 l r, HMemberM2 a r e1 ((:) a e l) res) => HMemberM1 a False e1 ((:) a e l) res

HMemberM1 k True e1 ((:) k e l) (Just [k] l)

class HMemberM2 (b :: Maybe [k]) (e1 :: k) (l :: [k]) (r :: Maybe [k]) | b e1 l -> r

Instances

HMemberM2 k (Nothing [k]) e1 l (Nothing [k])

HMemberM2 a (Just [a] l1) e1 ((:) a e l) (Just [a] ((:) a e l1))

Staged equality for lists

removed. use Typeable instead

Find an element in a set based on HEq

class HFind1 e l l n => HFind (e :: k) (l :: [k]) (n :: HNat) | e l -> n

It is a pure type-level operation

Instances

HFind1 k e l l n => HFind k e l n

class HFind1 (e :: k) (l :: [k]) (l0 :: [k]) (n :: HNat) | e l -> n

Instances

Fail ErrorMessage (FieldNotFound k [k] e1 l0) => HFind1 k e1 ([] k) l0 HZero

(HEq a e1 e2 b, HFind2 a b e1 l l0 n) => HFind1 a e1 ((:) a e2 l) l0 n

class HFind2 (b :: Bool) (e :: k) (l :: [k]) (l0 :: [k]) (n :: HNat) | b e l -> n

Instances

HFind2 k True e l l0 HZero

HFind1 k e l l0 n => HFind2 k False e l l0 (HSucc n)

Membership test based on type equality

class HTMember e (l :: [*]) (b :: Bool) | e l -> b

could be an associated type if HEq had one

Instances

HTMember k e ([] *) False

(HEq * e e' b, HTMember * e l b', (~) Bool (HOr b b') b'') => HTMember * e ((:) * e' l) b''

hTMember :: HTMember e l b => e -> HList l -> Proxy b

Intersection based on HTMember

class HTIntersect l1 l2 l3 | l1 l2 -> l3 where

Minimal complete definition

hTIntersect

Methods

hTIntersect :: HList l1 -> HList l2 -> HList l3

Like intersect

Instances

HTIntersect ([] *) l ([] *)

Methods

hTIntersect :: HList [*] -> HList l -> HList [*]

(HTMember * h l1 b, HTIntersectBool b h t l1 l2) => HTIntersect ((:) * h t) l1 l2

Methods

hTIntersect :: HList ((* ': h) t) -> HList l1 -> HList l2

class HTIntersectBool (b :: Bool) h t l1 l2 | b h t l1 -> l2 where

Minimal complete definition

hTIntersectBool

Methods

hTIntersectBool :: Proxy b -> h -> HList t -> HList l1 -> HList l2

Instances

HTIntersect t l1 l2 => HTIntersectBool False h t l1 l2

Methods

hTIntersectBool :: Proxy Bool False -> h -> HList t -> HList l1 -> HList l2

HTIntersect t l1 l2 => HTIntersectBool True h t l1 ((:) * h l2)

Methods

hTIntersectBool :: Proxy Bool True -> h -> HList t -> HList l1 -> HList ((* ': h) l2)

Convert between heterogeneous lists and homogeneous ones

class HList2List l e | l -> e where

hMapOut id is similar, except this function is restricted to HLists that actually contain a value (so the list produced will be nonempty). This restriction allows adding a functional dependency, which means that less type annotations can be necessary.

Minimal complete definition

hList2List, list2HListSuffix

Methods

hList2List :: HList l -> [e]

list2HListSuffix :: [e] -> Maybe (HList l, [e])

Instances

HList2List ((:) * e' l) e => HList2List ((:) * e ((:) * e' l)) e

Methods

hList2List :: HList ((* ': e) ((* ': e') l)) -> [e]

list2HListSuffix :: [e] -> Maybe (HList ((* ': e) ((* ': e') l)), [e])

HList2List ((:) * e ([] *)) e

Methods

hList2List :: HList ((* ': e) [*]) -> [e]

list2HListSuffix :: [e] -> Maybe (HList ((* ': e) [*]), [e])

list2HList :: HList2List l e => [e] -> Maybe (HList l)

listAsHList :: (Applicative f, Choice p, HList2List l2 e2, HList2List l1 e1) => p (HList l2) (f (HList l1)) -> p [e2] (f [e1])

Prism [s] [t] (HList s) (HList t)

listAsHList' :: (HList2List l e, Choice p, Applicative f) => p (HList l) (f (HList l)) -> p [e] (f [e])

Prism' [a] (HList s)

where s ~ HReplicateR n a

With HMaybe

Turn list in a list of justs

class FromHJustR (ToHJustR l) ~ l => ToHJust l where

the same as map Just

>>> toHJust (2 .*. 'a' .*. HNil)
H[HJust 2,HJust 'a']

>>> toHJust2 (2 .*. 'a' .*. HNil)
H[HJust 2,HJust 'a']

Minimal complete definition

toHJust

Associated Types

type ToHJustR l :: [*]

Methods

toHJust :: HList l -> HList (ToHJustR l)

Instances

ToHJust ([] *)

Associated Types

type ToHJustR ([*] :: [*]) :: [*]

Methods

toHJust :: HList [*] -> HList (ToHJustR [*])

ToHJust l => ToHJust ((:) * e l)

Associated Types

type ToHJustR ((* ': e) l :: [*]) :: [*]

Methods

toHJust :: HList ((* ': e) l) -> HList (ToHJustR ((* ': e) l))

toHJust2 :: (HMapCxt r (HJust ()) a b, ToHJust a, b ~ ToHJustR a) => r a -> r b

alternative implementation. The Apply instance is in Data.HList.FakePrelude. A longer type could be inferred.

Extract justs from list of maybes

class FromHJustR (ToHJustR l) ~ l => FromHJust l where

Minimal complete definition

fromHJust

Associated Types

type FromHJustR l :: [*]

Methods

fromHJust :: HList l -> HList (FromHJustR l)

Instances

FromHJust ([] *)

Associated Types

type FromHJustR ([*] :: [*]) :: [*]

Methods

fromHJust :: HList [*] -> HList (FromHJustR [*])

FromHJust l => FromHJust ((:) * (HJust e) l)

Associated Types

type FromHJustR ((* ': HJust e) l :: [*]) :: [*]

Methods

fromHJust :: HList ((* ': HJust e) l) -> HList (FromHJustR ((* ': HJust e) l))

FromHJust l => FromHJust ((:) * HNothing l)

Associated Types

type FromHJustR ((* ': HNothing) l :: [*]) :: [*]

Methods

fromHJust :: HList ((* ': HNothing) l) -> HList (FromHJustR ((* ': HNothing) l))

alternative implementation

fromHJust2 :: HMapCxt r HFromJust a b => r a -> r b

This implementation is shorter.

data HFromJust

Constructors

HFromJust

Instances

(~) * hJustA (HJust a) => ApplyAB HFromJust hJustA a

Methods

applyAB :: HFromJust -> hJustA -> a

Annotated lists

data HAddTag t

Constructors

HAddTag t

Instances

(~) * et (e, t) => ApplyAB (HAddTag t) e et

Methods

applyAB :: HAddTag t -> e -> et

data HRmTag

Constructors

HRmTag

Instances

(~) * e' e => ApplyAB HRmTag (e, t) e'

Methods

applyAB :: HRmTag -> (e, t) -> e'

hAddTag :: (SameLength' * * a b, SameLength' * * b a, HMapAux r (HAddTag t) a b) => t -> r a -> r b

hRmTag :: (SameLength' * * a b, SameLength' * * b a, HMapAux r HRmTag a b) => r a -> r b

hFlag :: (HMapAux r (HAddTag (Proxy Bool True)) a b, SameLength' * * b a, SameLength' * * a b) => r a -> r b

Annotate list with a type-level Boolean

hFlag :: HMapCxt (HAddTag (Proxy True)) l r => HList l -> HList r

Splitting by HTrue and HFalse

class HSplit l where

Analogus to Data.List.partition snd. See also HPartition

>>> let (.=.) :: p x -> y -> Tagged x y; _ .=. y = Tagged y
>>> hSplit $ hTrue .=. 2 .*. hTrue .=. 3 .*. hFalse .=. 1 .*. HNil
(H[2,3],H[1])

it might make more sense to instead have LVPair Bool e instead of (e, Proxy Bool) since the former has the same runtime representation as e

Minimal complete definition

hSplit

Associated Types

type HSplitT l :: [*]

type HSplitF l :: [*]

Methods

hSplit :: HList l -> (HList (HSplitT l), HList (HSplitF l))

Instances

HSplit ([] *)

Associated Types

type HSplitT ([*] :: [*]) :: [*]

type HSplitF ([*] :: [*]) :: [*]

Methods

hSplit :: HList [*] -> (HList (HSplitT [*]), HList (HSplitF [*]))

HSplit l => HSplit ((:) * (e, Proxy Bool False) l)

Associated Types

type HSplitT ((* ': (e, Proxy Bool False)) l :: [*]) :: [*]

type HSplitF ((* ': (e, Proxy Bool False)) l :: [*]) :: [*]

Methods

hSplit :: HList ((* ': (e, Proxy Bool False)) l) -> (HList (HSplitT ((* ': (e, Proxy Bool False)) l)), HList (HSplitF ((* ': (e, Proxy Bool False)) l)))

HSplit l => HSplit ((:) * (e, Proxy Bool True) l)

Associated Types

type HSplitT ((* ': (e, Proxy Bool True)) l :: [*]) :: [*]

type HSplitF ((* ': (e, Proxy Bool True)) l :: [*]) :: [*]

Methods

hSplit :: HList ((* ': (e, Proxy Bool True)) l) -> (HList (HSplitT ((* ': (e, Proxy Bool True)) l)), HList (HSplitF ((* ': (e, Proxy Bool True)) l)))

HSplit l => HSplit ((:) * (Tagged Bool False e) l)

Associated Types

type HSplitT ((* ': Tagged Bool False e) l :: [*]) :: [*]

type HSplitF ((* ': Tagged Bool False e) l :: [*]) :: [*]

Methods

hSplit :: HList ((* ': Tagged Bool False e) l) -> (HList (HSplitT ((* ': Tagged Bool False e) l)), HList (HSplitF ((* ': Tagged Bool False e) l)))

HSplit l => HSplit ((:) * (Tagged Bool True e) l)

Associated Types

type HSplitT ((* ': Tagged Bool True e) l :: [*]) :: [*]

type HSplitF ((* ': Tagged Bool True e) l :: [*]) :: [*]

Methods

hSplit :: HList ((* ': Tagged Bool True e) l) -> (HList (HSplitT ((* ': Tagged Bool True e) l)), HList (HSplitF ((* ': Tagged Bool True e) l)))

Splitting by Length

class (HLengthEq xs n, HAppendList1 xs ys xsys) => HSplitAt (n :: HNat) xsys xs ys | n xsys -> xs ys, xs ys -> xsys, xs -> n where

splitAt

setup

>>> let two = hSucc (hSucc hZero)
>>> let xsys = hEnd $ hBuild 1 2 3 4

If a length is explicitly provided, the resulting lists are inferred

>>> hSplitAt two xsys
(H[1,2],H[3,4])

>>> let sameLength_ :: SameLength a b => r a -> r b -> r a; sameLength_ = const
>>> let len2 x = x `sameLength_` HCons () (HCons () HNil)

If the first chunk of the list (a) has to be a certain length, the type of the Proxy argument can be inferred.

>>> case hSplitAt Proxy xsys of (a,b) -> (len2 a, b)
(H[1,2],H[3,4])

Minimal complete definition

hSplitAt

Methods

hSplitAt :: Proxy n -> HList xsys -> (HList xs, HList ys)

Instances

(HSplitAt1 ([] *) n xsys xs ys, HAppendList1 * xs ys xsys, HLengthEq xs n) => HSplitAt n xsys xs ys

Methods

hSplitAt :: Proxy HNat n -> HList xsys -> (HList xs, HList ys)

class HSplitAt1 accum (n :: HNat) xsys xs ys | accum n xsys -> xs ys where

helper for HSplitAt

Minimal complete definition

hSplitAt1

Methods

hSplitAt1 :: HList accum -> Proxy n -> HList xsys -> (HList xs, HList ys)

Instances

HRevApp accum ([] *) xs => HSplitAt1 accum HZero ys xs ys

Methods

hSplitAt1 :: HList accum -> Proxy HNat HZero -> HList ys -> (HList xs, HList ys)

HSplitAt1 ((:) * b accum) n bs xs ys => HSplitAt1 accum (HSucc n) ((:) * b bs) xs ys

Methods

hSplitAt1 :: HList accum -> Proxy HNat (HSucc n) -> HList ((* ': b) bs) -> (HList xs, HList ys)

class (SameLength' (HReplicateR n ()) xs, HLengthEq1 xs n, HLengthEq2 xs n) => HLengthEq (xs :: [*]) (n :: HNat) | xs -> n

a better way to write HLength xs ~ n because:

1. it works properly with ghc-7.10 (probably another example of ghc bug #10009)
2. it works backwards a bit in that if n is known, then xs can be refined:

>>> undefined :: HLengthEq xs HZero => HList xs
H[]

Instances

(SameLength' * * (HReplicateR * n ()) xs, HLengthEq1 HNat xs n, HLengthEq2 HNat xs n) => HLengthEq xs n

class HLengthEq1 (xs :: [*]) n

Instances

(~) [*] xxs ([] *) => HLengthEq1 HNat xxs HZero

(HLengthEq xs n, (~) [*] xxs ((:) * x xs)) => HLengthEq1 HNat xxs (HSucc n)

class HLengthEq2 (xs :: [*]) n | xs -> n

Instances

(~) HNat zero HZero => HLengthEq2 HNat ([] *) zero

(HLengthEq xs n, (~) HNat sn (HSucc n)) => HLengthEq2 HNat ((:) * x xs) sn

class HLengthGe (xs :: [*]) (n :: HNat)

HLengthGe xs n says that HLength xs >= n.

unlike the expression with a type family HLength, ghc assumes xs ~ (aFresh ': bFresh) when given a constraint HLengthGe xs (HSucc HZero)

Instances

HLengthGe xxs HZero

(HLengthGe xs n, (~) [*] xxs ((:) * x xs)) => HLengthGe xxs (HSucc n)

class HStripPrefix xs xsys ys => HAppendList1 (xs :: [k]) (ys :: [k]) (xsys :: [k]) | xs ys -> xsys, xs xsys -> ys

HAppendList1 xs ys xsys is the type-level way of saying xs ++ ys == xsys

used by HSplitAt

Instances

HAppendList1 k ([] k) ys ys

HAppendList1 a xs ys zs => HAppendList1 a ((:) a x xs) ys ((:) a x zs)

class HStripPrefix xs xsys ys | xs xsys -> ys

analog of stripPrefix

Instances

HStripPrefix [k1] k2 k2 ([] k1) ys ys

((~) a x' x, HStripPrefix [a] [a] k xs xsys ys) => HStripPrefix [a] [a] k ((:) a x' xs) ((:) a x xsys) ys

take

class HTake (n :: HNat) xs ys | n xs -> ys where

Minimal complete definition

hTake

Methods

hTake :: (HLengthEq ys n, HLengthGe xs n) => Proxy n -> HList xs -> HList ys

Instances

HTake HZero xs ([] *)

Methods

hTake :: Proxy HNat HZero -> HList xs -> HList [*]

(HLengthEq ys n, HLengthGe xs n, HTake n xs ys) => HTake (HSucc n) ((:) * x xs) ((:) * x ys)

Methods

hTake :: Proxy HNat (HSucc n) -> HList ((* ': x) xs) -> HList ((* ': x) ys)

drop

class HDrop (n :: HNat) xs ys | n xs -> ys where

Minimal complete definition

hDrop

Methods

hDrop :: HLengthGe xs n => Proxy n -> HList xs -> HList ys

Instances

HDrop HZero xs xs

Methods

hDrop :: Proxy HNat HZero -> HList xs -> HList xs

(HLengthGe xs n, HDrop n xs ys) => HDrop (HSucc n) ((:) * x xs) ys

Methods

hDrop :: Proxy HNat (HSucc n) -> HList ((* ': x) xs) -> HList ys

Conversion to and from tuples

class HTuple v t | v -> t, t -> v where

Minimal complete definition

hToTuple, hFromTuple

Methods

hToTuple :: HList v -> t

alternatively: hUncurry (,,,)

hFromTuple :: t -> HList v

Instances

HTuple ([] *) ()

Methods

hToTuple :: HList [*] -> ()

hFromTuple :: () -> HList [*]

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

Methods

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

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

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

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)

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)

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)

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 :: (HTuple v2 t, HTuple v1 a, Functor f, Profunctor p) => p a (f t) -> p (HList v1) (f (HList v2))

Iso (HList v) (HList v') a b

hTuple' :: (Profunctor p, Functor f, HTuple v a) => p a (f a) -> p (HList v) (f (HList v))

Iso' (HList v) a

class HTails a b | a -> b, b -> a where

tails

Minimal complete definition

hTails

Methods

hTails :: HList a -> HList b

Instances

HTails ([] *) ((:) * (HList ([] *)) ([] *))

Methods

hTails :: HList [*] -> HList ((* ': HList [*]) [*])

HTails xs ys => HTails ((:) * x xs) ((:) * (HList ((:) * x xs)) ys)

Methods

hTails :: HList ((* ': x) xs) -> HList ((* ': HList ((* ': x) xs)) ys)

class HInits a b | a -> b, b -> a where

inits

Minimal complete definition

hInits

Methods

hInits :: HList a -> HList b

Instances

HInits1 a b => HInits a ((:) * (HList ([] *)) b)

Methods

hInits :: HList a -> HList ((* ': HList [*]) b)

class HInits1 a b | a -> b, b -> a where

behaves like tail . inits

Minimal complete definition

hInits1

Methods

hInits1 :: HList a -> HList b

Instances

HInits1 ([] *) ((:) * (HList ([] *)) ([] *))

Methods

hInits1 :: HList [*] -> HList ((* ': HList [*]) [*])

(HInits1 xs ys, HMapCxt HList (FHCons2 x) ys ys', (~) [*] (HMapCons x ys) ys', (~) [*] (HMapTail ys') ys) => HInits1 ((:) * x xs) ((:) * (HList ((:) * x ([] *))) ys')

Methods

hInits1 :: HList ((* ': x) xs) -> HList ((* ': HList ((* ': x) [*])) ys')

data FHCons2 x

similar to FHCons

Constructors

FHCons2 x

Instances

((~) * hxs (HList xs), (~) * hxxs (HList ((:) * x xs))) => ApplyAB (FHCons2 x) hxs hxxs

Methods

applyAB :: FHCons2 x -> hxs -> hxxs

type family HMapCons (x :: *) (xxs :: [*]) :: [*]

evidence to satisfy the fundeps in HInits

Instances

type HMapCons x ([] *)

type HMapCons x ([] *) = [] *

type HMapCons x ((:) * (HList a) b)

type HMapCons x ((:) * (HList a) b) = (:) * (HList ((:) * x a)) (HMapCons x b)

type family HMapTail (xxs :: [*]) :: [*]

evidence to satisfy the fundeps in HInits

Instances

type HMapTail ([] *)

type HMapTail ([] *) = [] *

type HMapTail ((:) * (HList ((:) * a as)) bs)

type HMapTail ((:) * (HList ((:) * a as)) bs) = (:) * (HList as) (HMapTail bs)

partition

class HPartitionEq f x1 xs xi xo | f x1 xs -> xi xo where

HPartitionEq f x1 xs xi xo is analogous to

(xi,xo) = partition (f x1) xs

where f is a "function" passed in using it's instance of HEqBy

Minimal complete definition

hPartitionEq

Methods

hPartitionEq :: Proxy f -> Proxy x1 -> HList xs -> (HList xi, HList xo)

Instances

HPartitionEq k2 k1 f x1 ([] *) ([] *) ([] *)

Methods

hPartitionEq :: Proxy f [*] -> Proxy x1 [*] -> HList [*] -> (HList xi, HList xo)

(HEqBy k * f x1 x b, HPartitionEq1 k * b f x1 x xs xi xo) => HPartitionEq k * f x1 ((:) * x xs) xi xo

Methods

hPartitionEq :: Proxy f ((* ': x) xs) -> Proxy x1 xi -> HList xo -> (HList xi, HList xo)

class HPartitionEq1 (b :: Bool) f x1 x xs xi xo | b f x1 x xs -> xi xo where

Minimal complete definition

hPartitionEq1

Methods

hPartitionEq1 :: Proxy b -> Proxy f -> Proxy x1 -> x -> HList xs -> (HList xi, HList xo)

Instances

HPartitionEq k2 k1 f x1 xs xi xo => HPartitionEq1 k2 k1 False f x1 x xs xi ((:) * x xo)

Methods

hPartitionEq1 :: Proxy Bool x1 -> Proxy False x -> Proxy f xs -> xi -> HList ((* ': x) xo) -> (HList xi, HList xo)

HPartitionEq k2 k1 f x1 xs xi xo => HPartitionEq1 k2 k1 True f x1 x xs ((:) * x xi) xo

Methods

hPartitionEq1 :: Proxy Bool x1 -> Proxy True x -> Proxy f xs -> (* ': x) xi -> HList xo -> (HList xi, HList xo)

groupBy

class HGroupBy (f :: t) (as :: [*]) (gs :: [*]) | f as -> gs, gs -> as where

HGroupBy f x y is analogous to y = groupBy f x

given that f is used by HEqBy

Minimal complete definition

hGroupBy

Methods

hGroupBy :: Proxy f -> HList as -> HList gs

Instances

HGroupBy t f ([] *) ([] *)

Methods

hGroupBy :: Proxy f [*] -> HList [*] -> HList gs

(HSpanEqBy t f a as fst snd, HGroupBy t f snd gs) => HGroupBy t f ((:) * a as) ((:) * (HList ((:) * a fst)) gs)

Methods

hGroupBy :: Proxy f ((* ': a) as) -> HList ((* ': HList ((* ': a) fst)) gs) -> HList gs

span

class HSpanEqBy (f :: t) (x :: *) (y :: [*]) (fst :: [*]) (snd :: [*]) | f x y -> fst snd, fst snd -> y where

HSpanEq x y fst snd is analogous to (fst,snd) = span (== x) y

Minimal complete definition

hSpanEqBy

Methods

hSpanEqBy :: Proxy f -> x -> HList y -> (HList fst, HList snd)

Instances

(HSpanEqBy1 t f x y fst snd, (~) [*] (HAppendListR * fst snd) y) => HSpanEqBy t f x y fst snd

Methods

hSpanEqBy :: Proxy f x -> y -> HList fst -> (HList snd, HList snd)

class HSpanEqBy1 (f :: t) (x :: *) (y :: [*]) (i :: [*]) (o :: [*]) | f x y -> i o where

Minimal complete definition

hSpanEqBy1

Methods

hSpanEqBy1 :: Proxy f -> x -> HList y -> (HList i, HList o)

Instances

HSpanEqBy1 t f x ([] *) ([] *) ([] *)

Methods

hSpanEqBy1 :: Proxy f x -> [*] -> HList [*] -> (HList [*], HList o)

(HEqBy t * f x y b, HSpanEqBy2 t b f x y ys i o) => HSpanEqBy1 t f x ((:) * y ys) i o

Methods

hSpanEqBy1 :: Proxy f x -> (* ': y) ys -> HList i -> (HList o, HList o)

class HSpanEqBy2 (b :: Bool) (f :: t) (x :: *) (y :: *) (ys :: [*]) (i :: [*]) (o :: [*]) | b f x y ys -> i o where

Minimal complete definition

hSpanEqBy2

Methods

hSpanEqBy2 :: Proxy b -> Proxy f -> x -> y -> HList ys -> (HList i, HList o)

Instances

HSpanEqBy2 t False f x y ys ([] *) ((:) * y ys)

Methods

hSpanEqBy2 :: Proxy Bool f -> Proxy False x -> y -> ys -> HList [*] -> (HList ((* ': y) ys), HList o)

HSpanEqBy1 t f x zs i o => HSpanEqBy2 t True f x y zs ((:) * y i) o

Methods

hSpanEqBy2 :: Proxy Bool f -> Proxy True x -> y -> zs -> HList ((* ': y) i) -> (HList o, HList o)

zip

see alternative implementations in Data.HList.HZip

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

Minimal complete definition

hZipList, hUnzipList

Methods

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

hUnzipList :: HList l -> (HList x, HList y)

Instances

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

Methods

hZipList :: HList [*] -> HList [*] -> HList [*]

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

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

Methods

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

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

Monoid instance

helper functions

data ConstMempty

Constructors

ConstMempty

Instances

((~) * x (Proxy * y), Monoid y) => ApplyAB ConstMempty x y

Methods

applyAB :: ConstMempty -> x -> y

data UncurryMappend

Constructors

UncurryMappend

Instances

((~) * aa (a, a), Monoid a) => ApplyAB UncurryMappend aa a

Methods

applyAB :: UncurryMappend -> aa -> a

data UncurrySappend

Constructors

UncurrySappend

Instances

((~) * aa (a, a), Semigroup a) => ApplyAB UncurrySappend aa a

Methods

applyAB :: UncurrySappend -> aa -> a