Data.Has

Entiry based records.

Has class

class Knows lab (TypeOf lab) s => Has lab s

Same as Knows lab (TypeOf lab) s, Useful on writing type signitures.

Holds e == (lab .^ (lab ^= e $ s)) where lab :: lab; e :: TypeOf lab; s :: s

Instances

Knows lab (TypeOf lab) s => Has lab s

Rows in records

type Field a = a ::: TyNil

Field a is a type list which contains only one element of a. And every field in the records should be this type.

(&) :: Append a b => a -> b -> a :&: b

Concatenates between Fields or records. Records are concatenated rows. For example, Following expressions are valid.

 -- Concatenation of rows (i.e. record)
 field "string" & field True

 -- Concatenation of records
 (field 'c' & field ()) & (field False & field "string")

 -- ... And concatenations between a field and a record
 field () & (field False & field "string")
 (field 'c' & field ()) & field False

type family a :&: b

Represents concatenated rows or records.

field :: a -> Field a

Creates a Field of a.

Update and Lookup values from records

(^=) :: Knows lab (TypeOf lab) s => lab -> TypeOf lab -> s -> s

Strict version of injl

(^.) :: Knows lab (TypeOf lab) s => lab -> s -> TypeOf lab

Strict version of prjl

(^:) :: Knows lab (TypeOf lab) s => lab -> (TypeOf lab -> TypeOf lab) -> s -> s

Strict version of updl

class Contains (Labelled lab e) s => Knows lab e s | lab s -> e where

Injects and Projects a labelled values into records.

Methods

injl :: lab -> e -> s -> s

Injects a labelled value

prjl :: lab -> s -> e

Projects a labelled value

Instances

Contains (Labelled lab e) s => Knows lab e s

updl :: Knows lab b a => lab -> (b -> b) -> a -> a

Updates a labelled value

Labelled values

data Labelled lab a

Represents labelled value.

Instances

Bounded a => Bounded (Labelled lab a)

Eq a => Eq (Labelled lab a)

Ord a => Ord (Labelled lab a)

Read a => Read (Labelled lab a)

Show a => Show (Labelled lab a)

Arbitrary a => Arbitrary (Labelled lab a)

CoArbitrary a => CoArbitrary (Labelled lab a)

Monoid a => Monoid (Labelled lab a)

type :> lab a = Field (Labelled lab a)

Represents labelled field.

(.>) :: lab -> a -> lab :> a

Makes a labelled field.

Defining labels

type family TypeOf a

TypeOf a should indicate a type labelled by a

type family FieldOf a

 FieldOf a == a :> TypeOf a

fieldOf :: TypeOf a -> FieldOf a

Creates a field labelled by a

Make parsing error messages easier

data a ::: b

Cons a type onto type-list.

Instances

Contains e r => Contains e (::: h r)

Contains e (::: e r)

(Bounded a, Bounded b) => Bounded (::: a b)

(Eq a, Eq b) => Eq (::: a b)

(Ord a, Ord b) => Ord (::: a b)

(Read a, Read b) => Read (::: a b)

(Show a, Show b) => Show (::: a b)

(Arbitrary a, Arbitrary b) => Arbitrary (::: a b)

(CoArbitrary a, CoArbitrary b) => CoArbitrary (::: a b)

(Monoid a, Monoid b) => Monoid (::: a b)

Append y b => Append (::: x y) b

data TyNil

The empty type-list.

Instances

Bounded TyNil

Eq TyNil

Ord TyNil

Read TyNil

Show TyNil

Arbitrary TyNil

CoArbitrary TyNil

Monoid TyNil

Append TyNil b

class Contains e s

Provides injection and projection into type lists.

Holds e == prj (inj e s) for all s and e.

Instances

Contains e r => Contains e (::: h r)

Contains e (::: e r)