Data.HList.TIP

The HList library

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

Type-indexed products. The public interface is described in CommonMain#TIP

Documentation

module Data.HList.TIPtuple

The newtype for type-indexed products

newtype TIP (l :: [*])

TIPs are like Record, except element "i" of the list "l" has type Tagged e_i e_i

Constructors

TIP

Fields

• unTIP :: HList l

Instances

TypeIndexed Record TIP

Methods

typeIndexed :: (TypeIndexedCxt s t a b, Profunctor p, Functor f) => p (TIP (TagR a)) (f (TIP (TagR b))) -> p (Record s) (f (Record t))

(HUnzip TIP x y xy, HZipList xL yL xyL, (~) * lty (HList xL -> HList yL -> HList xyL), Coercible * lty (TIP x -> TIP y -> TIP xy), (~) [*] (UntagR x) xL, (~) [*] (UntagR y) yL, (~) [*] (UntagR xy) xyL, UntagTag x, UntagTag y, UntagTag xy) => HZip TIP x y xy

Methods

hZip :: TIP x -> TIP y -> TIP xy

(HZipList xL yL xyL, (~) * lty (HList xyL -> (HList xL, HList yL)), Coercible * lty (TIP xy -> (TIP x, TIP y)), (~) [*] (UntagR x) xL, (~) [*] (TagR xL) x, (~) [*] (UntagR y) yL, (~) [*] (TagR yL) y, (~) [*] (UntagR xy) xyL, (~) [*] (TagR xyL) xy, SameLengths * ((:) [*] x ((:) [*] y ((:) [*] xy ([] [*])))), UntagTag x, UntagTag y, UntagTag xy) => HUnzip TIP x y xy

Methods

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

(HDeleteAtLabel k Record e v v', HTypeIndexed v') => HDeleteAtLabel k TIP e v v'

Methods

hDeleteAtLabel :: Label TIP v -> e v' -> e v'

(HUpdateAtLabel * Record e' e r r', HTypeIndexed r', (~) * e e') => HUpdateAtLabel * TIP e' e r r'

Methods

hUpdateAtLabel :: Label TIP e -> r -> e' r' -> e' r'

LabelableTIPCxt k x s t a b => Labelable k x TIP s t a b

make a Lens' (TIP s) a.

tipyLens provides a Lens (TIP s) (TIP t) a b, which tends to need too many type annotations to be practical

Associated Types

type LabelableTy (s :: [*] -> *) :: LabeledOpticType

Methods

hLens' :: Label x TIP -> LabeledOptic x TIP s t a b b

HasField * e (Record ((:) * x ((:) * y l))) e => HOccurs e (TIP ((:) * x ((:) * y l)))

Methods

hOccurs :: TIP ((* ': x) ((* ': y) l)) -> e

(~) * tee (Tagged * e e) => HOccurs e (TIP ((:) * tee ([] *)))

One occurrence and nothing is left

This variation provides an extra feature for singleton lists. That is, the result type is unified with the element in the list. Hence the explicit provision of a result type can be omitted.

Methods

hOccurs :: TIP ((* ': tee) [*]) -> e

(HRLabelSet ((:) * (Tagged * e e) l), HTypeIndexed l) => HExtend e (TIP l)

Associated Types

type HExtendR e (TIP l) :: *

Methods

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

Bounded (HList r) => Bounded (TIP r)

Methods

minBound :: TIP r

maxBound :: TIP r

Eq (HList a) => Eq (TIP a)

Methods

(==) :: TIP a -> TIP a -> Bool

(/=) :: TIP a -> TIP a -> Bool

Ord (HList r) => Ord (TIP r)

Methods

compare :: TIP r -> TIP r -> Ordering

(<) :: TIP r -> TIP r -> Bool

(<=) :: TIP r -> TIP r -> Bool

(>) :: TIP r -> TIP r -> Bool

(>=) :: TIP r -> TIP r -> Bool

max :: TIP r -> TIP r -> TIP r

min :: TIP r -> TIP r -> TIP r

HMapOut (HComp HShow HUntag) l String => Show (TIP l)

Methods

showsPrec :: Int -> TIP l -> ShowS

show :: TIP l -> String

showList :: [TIP l] -> ShowS

Ix (HList r) => Ix (TIP r)

Methods

range :: (TIP r, TIP r) -> [TIP r]

index :: (TIP r, TIP r) -> TIP r -> Int

unsafeIndex :: (TIP r, TIP r) -> TIP r -> Int

inRange :: (TIP r, TIP r) -> TIP r -> Bool

rangeSize :: (TIP r, TIP r) -> Int

unsafeRangeSize :: (TIP r, TIP r) -> Int

Semigroup (HList a) => Semigroup (TIP a)

Methods

(<>) :: TIP a -> TIP a -> TIP a

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

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

Monoid (HList a) => Monoid (TIP a)

Methods

mempty :: TIP a

mappend :: TIP a -> TIP a -> TIP a

mconcat :: [TIP a] -> TIP a

((~) * e e', HasField * e (Record l) e') => HasField * e (TIP l) e'

Methods

hLookupByLabel :: Label e (TIP l) -> e' -> v

(HAppend (HList l) (HList l'), HTypeIndexed (HAppendListR * l l')) => HAppend (TIP l) (TIP l')

Methods

hAppend :: TIP l -> TIP l' -> HAppendR * (TIP l) (TIP l')

(HOccurs e (TIP l1), SubType * * (TIP l1) (TIP l2)) => SubType * * (TIP l1) (TIP ((:) * e l2))

SubType * * (TIP l) (TIP ([] *))

Subtyping for TIPs

type LabelableTy TIP

type LabelableTy TIP = LabelableLens

type HExtendR e (TIP l)

type HExtendR e (TIP l) = TIP ((:) * (Tagged * e e) l)

type HAppendR * (TIP l) (TIP l')

type HAppendR * (TIP l) (TIP l') = TIP (HAppendListR * l l')

mkTIP :: HTypeIndexed l => HList l -> TIP l

emptyTIP :: TIP '[]

Type-indexed type sequences

class (HAllTaggedEq l, HRLabelSet l) => HTypeIndexed (l :: [*])

this constraint ensures that a TIP created by mkTIP has no duplicates

Instances

(HAllTaggedEq l, HRLabelSet l) => HTypeIndexed l

class HAllTaggedEq (l :: [*])

Instances

HAllTaggedEq ([] *)

(HAllTaggedEq l, (~) * tee (Tagged k e e')) => HAllTaggedEq ((:) * tee l)

Shielding type-indexed operations

The absence of signatures is deliberate! They all must be inferred.

onRecord :: (HAllTaggedLV l, HLabelSet [*] (LabelsOf l), HAllTaggedEq l) => (Record r -> Record l) -> TIP r -> TIP l

tipyUpdate :: (SameLength' * * r r, HUpdateAtLabel * record v v r r) => v -> record r -> record r

tipyProject :: (H2ProjectByLabels ls t l b, HAllTaggedEq l, HLabelSet [*] (LabelsOf l), HAllTaggedLV l) => proxy ls -> TIP t -> TIP l

Use Labels to specify the first argument

tipyLens' :: (Functor f, SameLabels [*] [*] t t, SameLength' * * t t, HAllTaggedLV t, HLabelSet [*] (LabelsOf t), HAllTaggedEq t, HUpdateAtLabel2 * a a t t, HasField * a (Record t) a) => (a -> f a) -> TIP t -> f (TIP t)

provides a Lens' (TIP s) a. hLens' :: Label a -> Lens' (TIP s) a is another option.

tipyLens :: (Functor f, HAppendList l1 ((:) * (Tagged * a2 a2) xs2), HAllTaggedLV (HAppendListR * l1 ((:) * (Tagged * a2 a2) xs2)), HLabelSet [*] (LabelsOf (HAppendListR * l1 ((:) * (Tagged * a2 a2) xs2))), HAllTaggedEq (HAppendListR * l1 ((:) * (Tagged * a2 a2) xs2)), HFind2 * b (Label * a1) (LabelsOf xs1) ((:) * (Label * x) (LabelsOf xs1)) n, HEq * (Label * a1) (Label * x) b, HLengthEq2 HNat l1 n, HLengthEq1 HNat l1 n, SameLength' * * (HReplicateR * n ()) l1, HAppendList1 * l1 ((:) * (Tagged * a1 a1) xs2) ((:) * (Tagged * x x) xs1), HSplitAt1 ([] *) n ((:) * (Tagged * x x) xs1) l1 ((:) * (Tagged * a1 a1) xs2)) => (a1 -> f a2) -> TIP ((:) * (Tagged * x x) xs1) -> f (TIP (HAppendListR * l1 ((:) * (Tagged * a2 a2) xs2)))

provides a Lens (TIP s) (TIP t) a b

When using set (also known as .~), tipyLens' can address the ambiguity as to which field "a" should actually be updated.

tipyProject2 :: (HAllTaggedLV l2, HAllTaggedLV l1, HLabelSet [*] (LabelsOf l2), HLabelSet [*] (LabelsOf l1), HAllTaggedEq l2, HAllTaggedEq l1, H2ProjectByLabels ls r l1 l2) => proxy ls -> TIP r -> (TIP l1, TIP l2)

The same as tipyProject, except also return the types not requested in the proxy argument

conversion to and from HList

class SameLength a ta => TagUntagFD a ta | a -> ta, ta -> a where

TagR can also be used to avoid redundancy when defining types for TIC and TIP.

 type XShort = TagR [A,B,C,D]

 type XLong = [Tagged A A, Tagged B B, Tagged C C, Tagged D D]

an equivalent FD version, which is slightly better with respect to simplifying types containing type variables (in ghc-7.8 and 7.6): http://stackoverflow.com/questions/24110410/

With ghc-7.10 (http://ghc.haskell.org/trac/ghc/ticket/10009) the FD version is superior to the TF version:

class (UntagR (TagR a) ~ a) => TagUntag a where
    type TagR a :: [*]
    hTagSelf :: HList a -> HList (TagR a)
    hUntagSelf :: HList (TagR a) -> HList a

instance TagUntag '[] where
    type TagR '[] = '[]
    hTagSelf _ = HNil
    hUntagSelf _ = HNil

instance TagUntag xs => TagUntag (x ': xs) where
    type TagR (x ': xs) = Tagged x x ': TagR xs
    hTagSelf (HCons x xs) = Tagged x HCons hTagSelf xs
    hUntagSelf (HCons (Tagged x) xs) = x HCons hUntagSelf xs

type family UntagR (xs :: [*]) :: [*]
type instance UntagR '[] = '[]
type instance UntagR (x ': xs) = Untag1 x ': UntagR xs

Length information should flow backwards

>>> let len2 x = x `asTypeOf` (undefined :: HList '[a,b])
>>> let f = len2 $ hTagSelf (hReplicate Proxy ())
>>> :t f
f :: HList '[Tagged () (), Tagged () ()]

Minimal complete definition

hTagSelf, hUntagSelf

Methods

hTagSelf :: HList a -> HList ta

hUntagSelf :: HList ta -> HList a

Instances

TagUntagFD ([] *) ([] *)

Methods

hTagSelf :: HList [*] -> HList [*]

hUntagSelf :: HList [*] -> HList [*]

(TagUntagFD xs ys, (~) * txx (Tagged * x x)) => TagUntagFD ((:) * x xs) ((:) * txx ys)

Methods

hTagSelf :: HList ((* ': x) xs) -> HList ((* ': txx) ys)

hUntagSelf :: HList ((* ': txx) ys) -> HList ((* ': x) xs)

type TagUntag xs = TagUntagFD xs (TagR xs)

type UntagTag xs = (TagR (UntagR xs) ~ xs, TagUntagFD (UntagR xs) xs)

Sometimes the type variables available have TagR already applied (ie the lists have elements like Tagged X X). Then this abbreviation is useful:

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

Instances

type TagR ([] *)

type TagR ([] *) = [] *

type TagR ((:) * x xs)

type TagR ((:) * x xs) = (:) * (Tagged * x x) (TagR xs)

type family UntagR (ta :: [*]) :: [*]

Instances

type UntagR ([] *)

type UntagR ([] *) = [] *

type UntagR ((:) * (Tagged * y y) ys)

type UntagR ((:) * (Tagged * y y) ys) = (:) * y (UntagR ys)

type family Untag1 (x :: *) :: *

Instances

type Untag1 (Tagged k1 k2 x)

type Untag1 (Tagged k1 k2 x) = x

tipHList :: (TagUntagFD a2 l, TagUntagFD a1 ta, Functor f, Profunctor p) => p (HList a1) (f (HList a2)) -> p (TIP ta) (f (TIP l))

Iso (TIP (TagR a)) (TIP (TagR b)) (HList a) (HList b)

tipHList' :: (Profunctor p, Functor f, TagUntagFD a l) => p (HList a) (f (HList a)) -> p (TIP l) (f (TIP l))

Iso' (TIP (TagR s)) (HList a)

conversion to and from Record

tipRecord :: (Functor f, Profunctor p) => p (Record r) (f (Record l)) -> p (TIP r) (f (TIP l))

Iso (TIP s) (TIP t) (Record s) (Record t)

typeIndexed may be more appropriate

tipRecord' :: (Profunctor p, Functor f) => p (Record l) (f (Record l)) -> p (TIP l) (f (TIP l))

Iso' (TIP (TagR s)) (Record a)

Zip

hZipTIP :: (TagUntagFD y ta2, TagUntagFD x ta1, TagUntagFD a l, HZipList x y a) => TIP ta1 -> TIP ta2 -> TIP l

specialization of hZip

hUnzipTIP :: (TagUntagFD a2 l3, TagUntagFD a1 l2, TagUntagFD l1 ta, HAllTaggedLV l3, HAllTaggedLV l2, HLabelSet [*] (LabelsOf l3), HLabelSet [*] (LabelsOf l2), HAllTaggedEq l3, HAllTaggedEq l2, HZipList a1 a2 l1) => TIP ta -> (TIP l2, TIP l3)

specialization of hUnzip

TIP Transform

class TransTIP op db where

Transforming a TIP: applying to a TIP a (polyvariadic) function that takes arguments from a TIP and updates the TIP with the result.

In more detail: we have a typed-indexed collection TIP and we would like to apply a transformation function to it, whose argument types and the result type are all in the TIP. The function should locate its arguments based on their types, and update the TIP with the result. The function may have any number of arguments, including zero; the order of arguments should not matter.

The problem was posed by Andrew U. Frank on Haskell-Cafe, Sep 10, 2009. http://www.haskell.org/pipermail/haskell-cafe/2009-September/066217.html The problem is an interesting variation of the keyword argument problem.

Examples can be found in examples/TIPTransform.hs and examples/TIPTransformM.hs

Minimal complete definition

ttip

Methods

ttip :: op -> TIP db -> TIP db

Instances

(HMember * (Tagged * op op) db b, Arity op n, TransTIP1 b n op db) => TransTIP op db

Methods

ttip :: op -> TIP db -> TIP db

class TransTIP1 (b :: Bool) (n :: HNat) op db where

Minimal complete definition

ttip1

Methods

ttip1 :: Proxy b -> Proxy n -> op -> TIP db -> TIP db

Instances

Fail ErrorMessage (FieldNotFound * * notfun (TIP db)) => TransTIP1 False HZero notfun db

Methods

ttip1 :: Proxy Bool False -> Proxy HNat HZero -> notfun -> TIP db -> TIP db

HTPupdateAtLabel * TIP op op db => TransTIP1 True n op db

Methods

ttip1 :: Proxy Bool True -> Proxy HNat n -> op -> TIP db -> TIP db

(HMember * (Tagged * arg arg) db b, TransTIP2 b arg op db) => TransTIP1 False (HSucc n) (arg -> op) db

Methods

ttip1 :: Proxy Bool False -> Proxy HNat (HSucc n) -> (arg -> op) -> TIP db -> TIP db

class TransTIP2 (b :: Bool) arg op db where

Minimal complete definition

ttip2

Methods

ttip2 :: Proxy b -> (arg -> op) -> TIP db -> TIP db

Instances

Fail ErrorMessage (FieldNotFound * * arg (TIP db)) => TransTIP2 False arg op db

Methods

ttip2 :: Proxy Bool False -> (arg -> op) -> TIP db -> TIP db

(HOccurs arg (TIP db), TransTIP op db) => TransTIP2 True arg op db

Methods

ttip2 :: Proxy Bool True -> (arg -> op) -> TIP db -> TIP db

Monadic version

class Monad m => TransTIPM m op db where

In March 2010, Andrew Frank extended the problem for monadic operations. This is the monadic version of TIPTransform.hs in the present directory.

This is the TF implementation. When specifying the operation to perform over a TIP, we can leave it polymorphic over the monad. The type checker will instantiate the monad based on the context.

Minimal complete definition

ttipM

Methods

ttipM :: op -> TIP db -> m (TIP db)

Instances

(Monad m, HMember * (Tagged * op op) db b, Arity (m' op) n, TransTIPM1 b n m (m' op) db) => TransTIPM m (m' op) db

Methods

ttipM :: m' op -> TIP db -> m (TIP db)

class Monad m => TransTIPM1 (b :: Bool) (n :: HNat) m op db where

Minimal complete definition

ttipM1

Methods

ttipM1 :: Proxy b -> Proxy n -> op -> TIP db -> m (TIP db)

Instances

(Fail ErrorMessage (FieldNotFound * * op (TIP db)), Monad m) => TransTIPM1 False HZero m op db

Methods

ttipM1 :: Proxy Bool False -> Proxy HNat HZero -> op -> TIP db -> m (TIP db)

(Monad m, (~) (* -> *) m m', HTPupdateAtLabel * TIP op op db) => TransTIPM1 True n m (m' op) db

Methods

ttipM1 :: Proxy Bool True -> Proxy HNat n -> m' op -> TIP db -> m (TIP db)

(Monad m, HMember * (Tagged * arg arg) db b, TransTIPM2 b m arg op db) => TransTIPM1 False (HSucc n) m (arg -> op) db

Methods

ttipM1 :: Proxy Bool False -> Proxy HNat (HSucc n) -> (arg -> op) -> TIP db -> m (TIP db)

class TransTIPM2 (b :: Bool) m arg op db where

Minimal complete definition

ttipM2

Methods

ttipM2 :: Proxy b -> (arg -> op) -> TIP db -> m (TIP db)

Instances

Fail ErrorMessage (FieldNotFound * * op (TIP db)) => TransTIPM2 False m arg op db

Methods

ttipM2 :: Proxy Bool False -> (arg -> op) -> TIP db -> m (TIP db)

(HOccurs arg (TIP db), TransTIPM m op db) => TransTIPM2 True m arg op db

Methods

ttipM2 :: Proxy Bool True -> (arg -> op) -> TIP db -> m (TIP db)

Sample code

Assume

>>> import Data.HList.TypeEqO
>>> import Data.HList.FakePrelude
>>> import Data.HList.HOccurs

>>> :{
newtype Key    = Key Integer deriving (Show,Eq,Ord)
newtype Name   = Name String deriving (Show,Eq)
data Breed     = Cow | Sheep deriving (Show,Eq)
newtype Price  = Price Float deriving (Show,Eq,Ord)
data Disease   = BSE | FM deriving (Show,Eq)
type Animal =  TagR '[Key,Name,Breed,Price]
:}

>>> :{
let myTipyCow :: TIP Animal -- optional
    myTipyCow = Key 42 .*.  Name "Angus" .*.  Cow .*.  Price 75.5 .*. emptyTIP
    animalKey :: (HOccurs Key l, SubType l (TIP Animal)) => l -> Key
    animalKey = hOccurs
:}

Session log

>>> :t myTipyCow
myTipyCow
  :: TIP
       '[Tagged Key Key, Tagged Name Name, Tagged Breed Breed,
         Tagged Price Price]

>>> hOccurs myTipyCow :: Breed
Cow

>>> BSE .*. myTipyCow
TIPH[BSE,Key 42,Name "Angus",Cow,Price 75.5]

>>> Sheep .*. hDeleteAtLabel (Label::Label Breed) myTipyCow
TIPH[Sheep,Key 42,Name "Angus",Price 75.5]

>>> tipyUpdate Sheep myTipyCow
TIPH[Key 42,Name "Angus",Sheep,Price 75.5]

>>> tipyProject2 (Proxy :: Labels '[Name,Price]) myTipyCow
(TIPH[Name "Angus",Price 75.5],TIPH[Key 42,Cow])

>>> tipyProject (Proxy :: Labels '[Name,Price]) myTipyCow
TIPH[Name "Angus",Price 75.5]

Don't bother repeating the type error:

>>> Sheep .*. myTipyCow
...
...No instance for (Fail (DuplicatedLabel (Label Breed)))
...