Data.HList.HZip

The HList library

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

Zipping and unzipping for (conceptually) lists of pairs.

Provides two alternative implementations

zip

functional dependency

moved to Data.HList.HList to avoid an orphan instance

type family

hZip2 can be written as a standalone function, with an appropriate type family to calculate the result type. However, that does not seem to be the case for hUnzip2, so to re-use some type functions the two are in the same class.

class (HZipR (MapFst z) (MapSnd z) ~ z) => HUnZip z where

HZipR in the superclass constraint doesn't hurt, but it doesn't seem to be necessary

Associated Types

type MapFst z :: [*]

type MapSnd z :: [*]

Methods

hZip2 :: HList (MapFst z) -> HList (MapSnd z) -> HList z

hUnzip2 :: HList z -> (HList (MapFst z), HList (MapSnd z))

Instances

HUnZip ([] *)

((~) * z (x, y), HUnZip zs) => HUnZip ((:) * z zs)

type family HZipR x y :: [*]

calculates something like:

[a] -> [b] -> [(a,b)]

can be used to give another type for hZip2

hZip2 :: HList a -> HList b -> HList (HZipR a b)

Instances

type HZipR ([] *) ([] *) = [] *

type HZipR ((:) * x xs) ((:) * y ys) = (:) * (x, y) (HZipR xs ys)

utility type functions

do they belong somewhere else?

type family Fst a

Instances

type Fst (a, b) = a

type family Snd a

Instances

type Snd (a, b) = b

transpose

hTranspose :: (HZip3 a b c, HFoldr HZipF (HList es) l (HList b), HReplicateFD n (HList ([] *)) es, HLengthEq1 HNat a n, HLengthEq2 HNat a n, SameLength' * * (HReplicateR * n ()) a) => HList ((:) * (HList a) l) -> HList c

this transpose requires equal-length HLists inside a HList:

>>> import Data.HList.HListPrelude
>>> let ex = (1 .*. 2 .*. HNil) .*. ('a' .*. 'b' .*. HNil) .*. ( 3 .*. 5 .*. HNil) .*. HNil

The original list:

>>> ex
H[H[1,2],H['a','b'],H[3,5]]

And transposed:

>>> hTranspose ex
H[H[1,'a',3],H[2,'b',5]]

helpers

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

same as HZip but HCons the elements of x onto y. This might be doable as a hMap f (hZip x y), but that one doesn't propagate types as easily it seems.

Methods

hZip3 :: HList x -> HList y -> HList l

Instances

HZip3 ([] *) ([] *) ([] *)

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

data HZipF

Constructors

HZipF

Instances

(HZip3 a b c, (~) * x (HList a, HList b), (~) * y (HList c)) => ApplyAB HZipF x y