@sdboyer/thema-ui 0.0.0-stage → 0.1.0

package/errors/E0370.md

@@ -0,0 +1,59 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0370: a lens's arithmetic may overflow
+
+Integer arithmetic in a lens may exceed int64 for some instance. Bound the
+fields the lens reads so that every result fits.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: int64
+				b: int64
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				n: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			n: v0_0.a + v0_0.b
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			a: 0
+			b: 0
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0370]: n in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:23:7
+   |
+23 |             n: v0_0.a + v0_0.b
+   |                ^^^^
+   |
+   = note: n in the result of lens 0.0->1.0 computes v0_0.a + v0_0.b, whose result may be [-18446744073709551616, 18446744073709551614], outside int64; bound the fields it reads so that the result fits
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule arith-overflow)
+```

package/errors/E0371.md

@@ -0,0 +1,59 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0371: a lens may divide by zero
+
+A lens divides by a field that may be zero, which is an error in CUE, so the
+lens fails on every instance where it is. Exclude zero from the divisor's
+schema, or test for it.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				n: int32
+				d: int32
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				q: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			q: quo(v0_0.n, v0_0.d)
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			n: 0
+			d: 1
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0371]: q in the result of lens 0.0->1.0 divides by v0_0.d, which may be 0
+  --> lineage.cue:23:11
+   |
+23 |             q: quo(v0_0.n, v0_0.d)
+   |                    ^^^^
+   |
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule division-by-zero)
+```

package/errors/E0372.md

@@ -0,0 +1,57 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0372: a lens indexes a table with a value that has no entry
+
+A lens looks a value up in a table, and some value the source allows has no
+entry. Give the table an entry for every value, or a catch-all.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				t: "a" | "b" | "c"
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				u: 1 | 2
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		_T: {a: 1, b: 2}
+		v0_0: _
+		v1_0: {
+			u: _T[v0_0.t]
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			t: "a"
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0372]: u in the result of lens 0.0->1.0 indexes a table by v0_0.t, which may be "c", for which the table has no entry
+  --> lineage.cue:23:7
+   |
+23 |             u: _T[v0_0.t]
+   |                ^^
+   |
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule table-key-missing)
+```

package/errors/E0380.md

@@ -0,0 +1,71 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0380: a lens copies a value the checker cannot show its target accepts
+
+The totality checker judges a copy with the compatibility checker: does the
+target accept every value the source allows? Where the source constrains the
+field by another field's value, the compatibility checker cannot decide, so
+neither can the totality checker. A lens that cannot be shown total does not
+bind.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: int
+				b: <a
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				b: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			b: v0_0.b
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			a: 1
+			b: 0
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0380]: b in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:23:7
+   |
+23 |             b: v0_0.b
+   |                ^^^^
+   |
+   = note: b in the result of lens 0.0->1.0 copies v0_0.b, which is constrained by a in the source schema and not in the new one; the checker cannot compare constraints between fields (compat rule unknown-crossfield)
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule unknown-copy)
+   = help: write the mapping in a form the checker can follow, or add a lacuna where it cannot decide
+
+error[E0366]: b in the result of lens 1.0->0.0 is the constant 0, which the target schema does not accept: non-concrete value a for bound <
+  --> lineage.cue:30:4
+   |
+30 |             b: 0
+   |             ^
+   |
+   = note: a lens must be total: every instance of schema 1.0 must translate to an instance of schema 0.0 (totality rule literal-not-instance)
+```

package/errors/E0381.md

@@ -0,0 +1,61 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0381: a lens's condition is not one the checker can read
+
+The checker reads a comprehension's condition as a pattern over the input: a
+presence test, an equality, a type test, or a conjunction of these. A condition
+of any other form, such as a comparison, is one it cannot reason about.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				n: int32
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				big?: bool
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			if v0_0.n > 5 {
+				big: true
+			}
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			n: 0
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0381]: the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:22:4
+   |
+22 |             if v0_0.n > 5 {
+   |             ^^
+   |
+   = note: the result of lens 0.0->1.0 has fields under v0_0.n > 5, which is not a pattern: a presence test (p != _|_), an equality (p == c) or a type test ((p & T) != _|_) on an input field, or a conjunction (&&) of these
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule unknown-pattern)
+   = help: write the mapping in a form the checker can follow, or add a lacuna where it cannot decide
+```

package/errors/E0382.md

@@ -0,0 +1,64 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0382: a lens writes a required field only under conditions the checker cannot show exhaustive
+
+A required target field written only under conditions must be written under
+conditions that together cover every instance. Here two of the three values
+`k` can take are handled, so the checker cannot show the third is.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				k: "x" | "y" | "z"
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			if v0_0.k == "x" {
+				a: "1"
+			}
+			if v0_0.k == "y" {
+				a: "2"
+			}
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			k: "x"
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0382]: a in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:21:3
+   |
+21 |         v1_0: {
+   |         ^^^^
+   |
+   = note: a in the result of lens 0.0->1.0 is required by the target schema, and is written only under v0_0.k == "x"; v0_0.k == "y", which the checker cannot show cover every instance; write it unconditionally, under a condition and its negation, or under type tests covering every alternative of the tested field
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule unknown-exhaustive)
+   = help: write the mapping in a form the checker can follow, or add a lacuna where it cannot decide
+```

package/errors/E0383.md

@@ -0,0 +1,61 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0383: a lens computes with an operation the checker cannot prove
+
+The totality checker proves a fixed set of operations: arithmetic, len, and a
+handful of string functions. A computation outside that set cannot be shown
+to produce a value the target accepts.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+import "strconv"
+
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				s: string
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				n: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			n: strconv.Atoi(v0_0.s)
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			s: "0"
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0383]: n in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:24:7
+   |
+24 |             n: strconv.Atoi(v0_0.s)
+   |                ^^^^^^^
+   |
+   = note: n in the result of lens 0.0->1.0 calls strconv.Atoi, which is outside the provable set (len; quo, rem, div, mod; strings.Contains, strings.HasPrefix, strings.HasSuffix, strings.Replace, strings.ToLower, strings.ToUpper, strings.Trim, strings.TrimLeft, strings.TrimPrefix, strings.TrimRight, strings.TrimSpace, strings.TrimSuffix)
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule unknown-op)
+   = help: write the mapping in a form the checker can follow, or add a lacuna where it cannot decide
+```

package/errors/E0384.md

@@ -0,0 +1,63 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0384: a lens produces fields or elements dynamically
+
+Fields or elements produced by a `for` clause, a dynamic label or a list
+comprehension depend on the instance, so the checker cannot know which fields
+the result has. Write each field.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				m: [string]: int
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				mm: [string]: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			mm: {
+				for k, v in v0_0.m {
+					"\(k)": v
+				}
+			}
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			m: {}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0384]: mm in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:23:5
+   |
+23 |                 for k, v in v0_0.m {
+   |                 ^^^
+   |
+   = note: mm in the result of lens 0.0->1.0 has fields produced by a for clause over v0_0.m, so which fields exist depends on the instance; write each field
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule unknown-dynamic)
+   = help: write the mapping in a form the checker can follow, or add a lacuna where it cannot decide
+```

package/errors/E0385.md

@@ -0,0 +1,61 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0385: a lens refers to something the checker cannot follow
+
+The checker follows a lens's references to the input or to constants. A
+selection by a computed index or label leads somewhere it cannot follow.
+Select fields by name.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				k: string
+				m: [string]: int
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				v: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			v: v0_0.m[v0_0.k]
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			k: ""
+			m: {}
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0385]: v in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:23:7
+   |
+23 |             v: v0_0.m[v0_0.k]
+   |                ^^^^
+   |
+   = note: v in the result of lens 0.0->1.0 reads v0_0.m[v0_0.k], a selection into the input the checker cannot follow (a computed index or label); select fields by name
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule unknown-reference)
+   = help: write the mapping in a form the checker can follow, or add a lacuna where it cannot decide
+```

package/errors/E0386.md

@@ -0,0 +1,59 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0386: a lens's integer arithmetic has no bounds the checker can trust
+
+To show integer arithmetic fits its target, the checker needs finite bounds on
+what it reads. An unbounded int gives it none, so it cannot show the result
+within int64 or within the target's bounds. Bound the fields the lens reads.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				n: int
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				m: int32
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			m: v0_0.n + 1
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			n: v1_0.m
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0386]: m in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:22:7
+   |
+22 |             m: v0_0.n + 1
+   |                ^^^^
+   |
+   = note: m in the result of lens 0.0->1.0 is an integer computed by v0_0.n + 1, in [-inf, +inf], which the checker cannot show within int64 and the target's int32; bound the fields it reads (int32, >=0 & <=100)
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule unknown-bounds)
+   = help: write the mapping in a form the checker can follow, or add a lacuna where it cannot decide
+```

package/errors/E0387.md

@@ -0,0 +1,59 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0387: a lens's divisor may be zero as far as the checker can tell
+
+A divisor's range includes zero, though zero itself may be excluded by a
+constraint the checker does not follow. Bound the divisor away from zero with
+`>0` or `<0`.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				d: int & !=0 & >=-5 & <=5
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				q: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			q: quo(10, v0_0.d)
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			d: 1
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0387]: q in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:22:11
+   |
+22 |             q: quo(10, v0_0.d)
+   |                    ^^
+   |
+   = note: q in the result of lens 0.0->1.0 divides by v0_0.d, whose range [-5, 5] includes 0, though 0 may not be an instance; bound the divisor away from 0 (>0 or <0)
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule unknown-divisor)
+   = help: write the mapping in a form the checker can follow, or add a lacuna where it cannot decide
+```