primate 0.1.0

A small DSL for cross-language constants. Write once, generate typed Rust, TypeScript, and Python.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

# Matrices and fixed shapes

When you have data with a fixed shape — RGB triples, 3×3 matrices,
fixed-byte buffers — use `array<T, N>`. The arity is part of the
type, so generators emit idiomatic fixed-size containers per target.

## RGB triples

```primate
// constants/colors.prim

type Pixel = array<u32, 3>

Pixel RED   = [255, 0, 0]
Pixel GREEN = [0, 255, 0]
Pixel BLUE  = [0, 0, 255]
```

Generated TypeScript:

```typescript
export type Pixel = [number, number, number];

export const colors = {
  RED:   [255, 0, 0],
  GREEN: [0, 255, 0],
  BLUE:  [0, 0, 255],
} as const;
```

In Rust the same `Pixel` becomes `[u32; 3]`; in Python it's
`Tuple[int, int, int]`.

## 3×3 matrices

The compact form fits on one line — the formatter keeps it inline:

```primate
type Mat3 = array<array<u32, 3>, 3>

Mat3 SMALL = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
```

For larger matrices the same shape gets long. Use a **trailing comma**
on the outer literal to opt into multi-line layout:

```primate
Mat3 IDENTITY = [
    [1, 0, 0],
    [0, 1, 0],
    [0, 0, 1],
]
```

The trailing `,` after the last row tells the formatter "keep this
multi-line, even if it would fit on one line." See
[Values](../language/values.md) for the rule.

Generated TypeScript:

```typescript
export type Mat3 = [
  [number, number, number],
  [number, number, number],
  [number, number, number],
];

export const IDENTITY: Mat3 = [
  [1, 0, 0],
  [0, 1, 0],
  [0, 0, 1],
];
```

## Length-mismatch is a hard error

```primate
type V3 = array<u32, 3>

V3 SHORT = [1, 2]      // ✗ length-mismatch: expected 3, got 2
V3 LONG  = [1, 2, 3, 4]   // ✗ length-mismatch
```

The error includes the expected and actual lengths and points at the
literal.

## Wider tables

A matrix-like value can also be a `tuple<...>` of heterogeneous types
when the columns have different shapes:

```primate
type RetrySchedule = tuple<u32, duration, duration>

RetrySchedule DEFAULT = [3, 100ms, 30s]
RetrySchedule AGGR    = [10, 50ms, 5s]
```

Tuples and fixed arrays both compile to fixed-shape containers in the
target languages; the difference is only in whether the elements share
a type.

## Lookup tables

For sparse named lookups, reach for `map`:

```primate
map<string, u32> SERVICE_PORTS = {
    "http":  80,
    "https": 443,
    "ssh":   22,
    "smtp":  25,
}
```

Trailing comma keeps it multi-line; without it, short maps stay
inline.