# Difference between revisions of "CTRex"

(→Introduction) |
|||

Line 40: | Line 40: | ||

Of course it would be much nicer to just write <hask>`x</hask> instead of <hask> Label :: Label "x"</hask> but this is currently not available. This may change in the future. |
Of course it would be much nicer to just write <hask>`x</hask> instead of <hask> Label :: Label "x"</hask> but this is currently not available. This may change in the future. |
||

+ | |||

+ | == Rows == |
||

+ | |||

+ | A type-level record, i.e. the mapping of labels to types is called a '''row'''. |
||

+ | A record has the following type: <hask> Rec (r :: Row *) </hask>, where r is the |
||

+ | row. |
||

+ | |||

+ | The constructors of <hask>Rec</hask> as well as the constructors of the datakind <hask>Row</hask> are not exported. Hence we can only manipulate records and rows bby the value and type level operations given in the CTRex module. |
||

== Operations == |
== Operations == |
||

⚫ | For example, the value level operation for extending a record (adding a field) has type < |
||

+ | For all operations available on records, the value level interface and the type level interface correspond to each other. |
||

+ | |||

⚫ | |||

+ | |||

+ | <haskell> Extend (l :: Symbol) (a :: *) (r :: Row *) :: Row *</haskell> |
||

+ | |||

+ | In this way each value level operation (that changes the type) has a corresponding type level operation with the same name (but starting with a capitol). |
||

## Revision as of 16:51, 4 December 2013

## Contents

# Introduction

This page will describe the design, usage and motivation for CTRex.

CTRex is a library for Haskell which implements extensible records using closed type families and type literals. It does **not** use overlapping instances.

Features:

- Row-polymorphism

- Support for scoped labels (i.e. duplicate labels)
**and**non-scoped labels (i.e. the lacks predicate on rows).

- The value level interface and the type level interface correspond to each other.

- The order of labels (except for duplicate labels) does not matter. I.e. {x = 0, y = 0} and {y = 0, x = 0} have the
**same type**.

- Syntactic sugar on the value level as well as type level.

- If all values in a record satisfy a constraint such as
`Show`

, then we are able to do operations on all fields in a record, if that operation only requires that the constraint is satisfied. In this way we can create instances such as`Forall r Show => Show (Rec r)`

. This is available to the application programmer as well.

- Fast extend, lookup and restriction (all O(log n)) using HashMaps.

The haddock documentation is available here.

# Programmer interface

## Labels

Labels (such as x,y and z) in CTRex are type level symbols (i.e. type level strings). We can point to a label by using the label type:

```
data Label (s :: Symbol) = Label
```

For example, we can declare shorthands for pointing at the type level symbol "x", "y" and "z" as follows.

```
x = Label :: Label "x"
y = Label :: Label "y"
z = Label :: Label "z"
```

Of course it would be much nicer to just write ``x`

instead of `Label :: Label "x"`

but this is currently not available. This may change in the future.

## Rows

A type-level record, i.e. the mapping of labels to types is called a **row**.
A record has the following type: `Rec (r :: Row *)`

, where r is the
row.

The constructors of `Rec`

as well as the constructors of the datakind `Row`

are not exported. Hence we can only manipulate records and rows bby the value and type level operations given in the CTRex module.

## Operations

For all operations available on records, the value level interface and the type level interface correspond to each other.

For example, the value level operation for extending a record (adding a field) has type```
extend :: KnownSymbol l => Label l -> a -> Rec r -> Rec (Extend l a r)
```

```
Extend (l :: Symbol) (a :: *) (r :: Row *) :: Row *
```

In this way each value level operation (that changes the type) has a corresponding type level operation with the same name (but starting with a capitol).

## Syntactic sugar

```
p :<-| z .| y :<- 'b' .| z :!= False .| x := 2 .| y := 'a' .| empty
```

instead of

```
rename z p $ update y 'b' $ extendUnique z False $ extend x 2 $ extend y 'a' empty
```