@sdboyer/thema-ui 0.0.0-bootstrap.0 → 0.1.0

package/errors/E0357.md

@@ -0,0 +1,68 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0357: a mapping calls a function a lens may not call
+
+A mapping calls a function the lens language does not have. A computed
+mapping may use CUE's arithmetic, comparisons and the strings functions the
+help lists; anything else would make a lens whose totality thema cannot
+check.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	name: string
+	count?: int
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	name: string
+}
+
+ForwardLens: {
+	v0_0: _
+	v1_0: {
+		name: strings.Reverse(v0_0.name)
+	}
+}
+
+BackwardLens: {
+	v1_0: _
+	v0_0: {
+		name: v1_0.name
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	name: string
+}
+```
+
+thema reports:
+
+```
+error[E0357]: strings.Reverse is not a function a lens may call
+ --> history/1.0.thema:8:9
+  |
+8 |         name: strings.Reverse(v0_0.name)
+  |               ^^^^^^^
+  |
+  = help: the strings functions a lens may call are strings.Contains, strings.HasPrefix, strings.HasSuffix, strings.Replace, strings.ToLower, strings.ToUpper, strings.Trim, strings.TrimLeft, strings.TrimPrefix, strings.TrimRight, strings.TrimSpace, strings.TrimSuffix
+
+error[E0347]: 0.0 declares count and 1.0 does not, and nothing maps it: write <field>: v0_0.count to move it, or count: _drop
+ --> history/1.0.thema:5:1
+  |
+5 | ForwardLens: {
+  | ^^^^^^^^^^^
+  |
+```

package/errors/E0358.md

@@ -0,0 +1,50 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0358: a field both versions declare cannot be copied: the target does not accept every source value
+
+A field both versions declare, and no lens mentions, is copied. The copy has
+to produce a value the target accepts. Here kind narrows from any string to
+two of them, and the ForwardLens does not map it.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	name: string
+	kind: string
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	name: string
+	kind: "a" | "b"
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	name: string
+	kind: "a" | "b"
+}
+```
+
+thema reports:
+
+```
+error[E0358]: the ForwardLens in history/1.0.thema would copy v0_0.kind into kind, which does not accept every value of it
+ --> history/1.0.thema:1:1
+  |
+1 | Schema: {
+  | ^^^^^^
+  |
+  = note: both 0.0 and 1.0 declare kind, so a lens that does not map it copies it
+  = note: kind in 1.0 is now "a" | "b", which does not accept every value of the prior string (copying v0_0.kind; compatibility rule value-narrowed)
+  = help: map kind in the ForwardLens: a _match, a computed value, or a constant
+```

package/errors/E0359.md

@@ -0,0 +1,53 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0359: a move reads a source field whose values the target field does not all accept
+
+A move takes a source field's value as it is, so the target field must
+accept every value the source field may hold. Here count may be any integer,
+and total accepts only non-negative ones.
+
+## Example
+
+`ship/history/0.0.thema`:
+
+```cue
+Schema: {
+	count: int
+}
+```
+
+`ship/history/1.0.thema`:
+
+```cue
+Schema: {
+	total: int & >=0
+}
+
+ForwardLens: {
+	v0_0: _
+	v1_0: {
+		total: v0_0.count
+	}
+}
+```
+
+`ship/tip.thema`:
+
+```cue
+Schema: {
+	total: int & >=0
+}
+```
+
+thema reports:
+
+```
+error[E0359]: the ForwardLens in history/1.0.thema moves v0_0.count into total, which does not accept every value of it
+ --> history/1.0.thema:8:10
+  |
+8 |         total: v0_0.count
+  |                ^^^^
+  |
+  = note: total in 1.0 is now uint, which does not accept every value of the prior int (moving v0_0.count; compatibility rule value-narrowed)
+  = help: map total from a value it accepts: a _match, or a computed value
+```

package/errors/E0360.md

@@ -0,0 +1,59 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0360: a lens copies a value its target rejects for some instance
+
+A lens is total: every instance of its source schema translates to an instance
+of its target. Copying a field whose target is narrower than its source fails
+for the instances the target rejects. Here 0.0 allows any int and 1.0 only
+those below 10, so copying `a` forward is not total.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a!: int
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				a!: int & <10
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			a: v0_0.a
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			a: v1_0.a
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0360]: a in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:22:7
+   |
+22 |             a: v0_0.a
+   |                ^^^^
+   |
+   = note: a in the result of lens 0.0->1.0 copies v0_0.a, which is now int & <10, which does not accept every value of the prior int (compat rule value-narrowed)
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule copy-narrowed)
+```

package/errors/E0361.md

@@ -0,0 +1,59 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0361: a lens reads a field that may be absent
+
+A lens reads a field that may be absent from the input: an optional field, with
+no test that it is present. For the instances that lack it, the lens produces
+nothing there. Write the field under a presence test, or give it a fallback.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				b:  string
+				c?: string
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			a: v0_0.c
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			b: v1_0.a
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0361]: a in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:23:7
+   |
+23 |             a: v0_0.c
+   |                ^^^^
+   |
+   = note: a in the result of lens 0.0->1.0 copies v0_0.c, which may be absent: v0_0.c is optional in the source schema; write the field under if v0_0.c != _|_
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule source-absent)
+```

package/errors/E0362.md

@@ -0,0 +1,56 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0362: a lens reads a field its source schema does not declare
+
+A lens reads a field its source schema does not declare. No instance of the
+source has it, so the lens never has a value to copy.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				b: string
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			b: v0_0.nope
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			a: v1_0.b
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0362]: b in the result of lens 0.0->1.0 copies v0_0.nope, which the source schema does not declare
+  --> lineage.cue:22:7
+   |
+22 |             b: v0_0.nope
+   |                ^^^^
+   |
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule source-undeclared)
+```

package/errors/E0364.md

@@ -0,0 +1,58 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0364: a lens's pattern tests a field that may be absent
+
+A pattern that compares a field tests a field that may be absent. In CUE,
+comparing an absent field is an error rather than false, so the lens fails on
+every instance that lacks the field. Test presence first.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				c?: string
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				q?: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			if v0_0.c == "x" {
+				q: 1
+			}
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0364]: the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:22:4
+   |
+22 |             if v0_0.c == "x" {
+   |             ^^
+   |
+   = note: the result of lens 0.0->1.0 is under the pattern v0_0.c == "x", but v0_0.c may be absent (v0_0.c is optional in the source schema), and comparing an absent field is an error rather than false; test presence first: if v0_0.c != _|_
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule pattern-absent)
+```

package/errors/E0365.md

@@ -0,0 +1,58 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0365: a lens writes a constraint where an instance needs a value
+
+A lens writes a constraint, such as `int` or a disjunction, where an instance
+needs one concrete value. The result would not be an instance of the target.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				a: string
+				n: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			a: v0_0.a
+			n: int
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			a: v1_0.a
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0365]: n in the result of lens 0.0->1.0 is int, a constraint rather than a value; a result field must have a concrete value
+  --> lineage.cue:24:4
+   |
+24 |             n: int
+   |             ^
+   |
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule not-a-value)
+```

package/errors/E0366.md

@@ -0,0 +1,56 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0366: a lens writes a literal its target rejects
+
+A literal the lens writes is not an instance of the target at that path. Here
+the target wants a list of one int and the lens writes two elements.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: int
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				l: [int]
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			l: [v0_0.a, 1]
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			a: v1_0.l[0]
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0366]: l in the result of lens 0.0->1.0 is a list of 2 elements, which the target schema does not accept: incompatible list lengths (1 and 2)
+  --> lineage.cue:22:4
+   |
+22 |             l: [v0_0.a, 1]
+   |             ^
+   |
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule literal-not-instance)
+```

package/errors/E0367.md

@@ -0,0 +1,57 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0367: a lens computes a value its target rejects for some instance
+
+A computed value has a possible result the target rejects. Here the lens
+subtracts one from a non-negative int and writes it where the target requires
+a non-negative int: for an input of 0 the result is -1.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: int & >=0
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				n: int & >=0
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			n: v0_0.a - 1
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			a: v1_0.n
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0367]: n in the result of lens 0.0->1.0 is v0_0.a - 1, which may be as low as -1, where the target schema requires >=0
+  --> lineage.cue:22:7
+   |
+22 |             n: v0_0.a - 1
+   |                ^^^^
+   |
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule computed-narrowed)
+```

package/errors/E0368.md

@@ -0,0 +1,58 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0368: a lens leaves a required field unwritten for some instance
+
+The target schema requires a field the lens never writes, so no result is an
+instance of the target. Write the field: from the input, as a constant, or
+through a mapping.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: string
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				a: string
+				b: int
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			a: v0_0.a
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			a: v1_0.a
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0368]: b in the result of lens 0.0->1.0 is required by the target schema and never written
+  --> lineage.cue:22:3
+   |
+22 |         v1_0: {
+   |         ^^^^
+   |
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule required-not-written)
+```

package/errors/E0369.md

@@ -0,0 +1,60 @@
+<!-- Generated by go test ./diag; do not edit. -->
+
+# E0369: a lens writes a field twice with values that may disagree
+
+A field written twice unifies the two values. Where they can disagree, one
+rejects the other's value and the lens fails. Write each field once.
+
+## Example
+
+`lineage.cue`:
+
+```cue
+name: "ship"
+schemas: {
+	"0": {
+		"0": {
+			schema: {
+				a: int
+			}
+		}
+	}
+	"1": {
+		"0": {
+			schema: {
+				a: int
+				k: string
+			}
+		}
+	}
+}
+lenses: {
+	"0.0->1.0": {
+		v0_0: _
+		v1_0: {
+			a: v0_0.a
+			a: 1000
+			k: "v"
+		}
+	}
+	"1.0->0.0": {
+		v1_0: _
+		v0_0: {
+			a: v1_0.a
+		}
+	}
+}
+```
+
+thema reports:
+
+```
+error[E0369]: a in the result of lens 0.0->1.0 is not total for some instance
+  --> lineage.cue:23:4
+   |
+23 |             a: v0_0.a
+   |             ^
+   |
+   = note: a in the result of lens 0.0->1.0 is written as v0_0.a and as 1000, and the two unify, so one may reject the other's value; write the field once
+   = note: a lens must be total: every instance of schema 0.0 must translate to an instance of schema 1.0 (totality rule write-conflict)
+```