rulec diagnostics

Every code rulec can print, what makes it appear, and how to fix it. The code and the JSON shape are a stable API; only the prose improves. For one of them: rulec explain E101.

E001

error — Unterminated string

When. A string opened with " is not closed on the same line. Neither a cell nor a description may contain a line break.

Fix. Close the " on the same line. A long description either fits on one line or moves into a # comment.

Smallest reproduction:

rule t(t) v1
description "unterminated

Related codes: E002

E002

error — Unreadable character

When. A character that is neither a letter nor _ appears where a name is expected — an alias in parentheses that is not a name (sixty(60)) included. The check exists so that a typo does not quietly become a name, nor an alias quietly go missing.

Fix. Delete the character. A name starts with a letter or _ (@x(x) becomes x(x), and sixty(60) becomes sixty(size_60)).

Smallest reproduction:

rule t(t) v1

inputs
  %x(x) : bool

Related codes: E001, E009

E003

error — The file does not start with a rule line

When. One .rule is one rule, and its first line carries the name and the version. Anything else comes before it, or the rule line has no name — a file whose rule line had none used to pass the check as a rule with nothing in it.

Fix. Add rule <name>(<alias>) v1 as the first line.

Smallest reproduction:

inputs
  x(x) : bool

Related codes: E004, E011

E004

error — The line does not start with a word

When. A line that is neither a table row, a comment nor blank starts with a symbol. The syntax is line-oriented: the first word of a line decides what is being declared.

Fix. Start the line with a declaring word (description / import / enum / group / inputs / elements / outputs / derive / define / constraint / table / fold / count / sum / max / min / sequence / result / examples / policy / overrides / clause / source / apply / shape / machine / scenario / prerequisites / chances / open). A table row starts with |.

Smallest reproduction:

rule t(t) v1

= 1

Related codes: E003, E005

E005

error — A word that cannot appear at this position

When. The word at the head of the line is not in the vocabulary. The vocabulary has no synonyms: one English spelling each.

Fix. Correct it to one of description / import / enum / group / inputs / elements / outputs / derive / define / constraint / table / fold / count / sum / max / min / sequence / result / examples / policy / overrides / clause / source / apply / shape / machine / scenario / prerequisites / chances / open. Business words belong in names and cells, not at the head of a line.

Smallest reproduction:

rule t(t) v1

foo bar

Related codes: E004, E009

E006

error — The declaration has no =

When. enum, group, derive, define and result separate the name from the body with =. It is missing.

Fix. Insert the =, e.g. enum k(k) = a(a) | b(b).

Smallest reproduction:

rule t(t) v1

enum k(k) a(a) | b(b)

Related codes: E005

E007

error — No such policy

When. The word after policy is not unique or first. DMN's Any, Priority and Collect are not adopted.

Fix. Write either policy unique (every overlap is an error) or policy first (the earlier row wins).

Smallest reproduction:

rule t(t) v1

inputs
  x(x) : bool

outputs
  r(r) : bool

table j(j)
policy any
| x | -> r(r) : bool |
| - | true           |

Related codes: W110, E105, W105

E008

error — Empty cell

When. A cell of a table holds only whitespace. A blank is indistinguishable from a forgotten entry, so it is a syntax error.

Fix. If any value is meant, write -. If a value was forgotten, write the value.

Smallest reproduction:

rule t(t) v1

inputs
  x(x) : bool

outputs
  r(r) : bool

table j(j)
policy unique
| x | -> r(r) : bool |
|   | true           |

Related codes: E101

E009

error — A declared name collides with a reserved word

When. A declared name (or alias) is the same as a word of the vocabulary. Otherwise the line-oriented parser reads the line as the start of a section and drops the declaration silently. An enum value never starts a line, so for a value it is only the eleven words its own position reads as something else (not none true false starts_with default after empty exhausted by with).

Fix. Rename it (enum range(kind) becomes enum range_band(range_kind)). The reserved words are fixed by the one table in src/kw.rs.

Smallest reproduction:

rule t(t) v1

enum range(kind) = a(a) | b(b)

Related codes: E005, E011

E010

error — The .. range notation is not allowed

When. A cell contains .., as in 0g..1000g. Whether "up to 1000g" includes the endpoint cannot be read off the text.

Fix. Rewrite it with comparison operators: 0g..1000g is either <=1000g or <1000g. To fix both ends, write >=0g <=1000g.

Smallest reproduction:

rule t(t) v1

inputs
  w(w) : mass[g]  range >=0g <=10kg

outputs
  r(r) : bool

table j(j)
policy unique
| w         | -> r(r) : bool |
| 0g..1000g | true           |
| >1000g    | false          |

Related codes: E105, E101

E011

error — A public name has no ASCII alias

When. The rule name, an input, an output, a sequence or a field of one element has a non-ASCII name and no alias in parentheses. The alias becomes the public name in the generated code (a kanji has no uppercase and cannot begin an exported Go identifier, and the name of a field of the .proto is ASCII alone). A sequence is an input the caller passes, and the fields of one element are what the caller fills in, so they are as public as an input. A name that is already ASCII is its own public name and needs no alias.

Fix. Add the alias in parentheses (重量 : bool becomes 重量(weight) : bool). On a derived value, a definition, a group or a table the alias is optional: write one and the generated code uses it, leave it out and the declared name is used as it stands.

Smallest reproduction:

rule t(t) v1

inputs
  重量 : bool

outputs
  r(r) : bool

table j(j)
policy unique
| 重量 | -> r(r) : bool |
| -    | true           |

A sequence with no ASCII alias:

rule pieces_total v1

elements pièces
  amount : money[USD]  range >=0USD <=100USD

outputs
  total : money[USD]  round down(1USD)

sum spent over pièces of amount  range >=0USD <=1000USD

define total : money[USD] = spent

Related codes: E009, E012

E012

error — The name is not declared

When. A column or an expression names something that is declared nowhere. There is no forward reference: a name is declared above the line that uses it. It also appears when a value written in a cell or a group is a value of no enum; when the rule imports a built-in namespace of divisions (std/us/states and the rest), the note gives the closest spelling, or the namespace of another country that has the word. And it appears when a word is a spelling two imported countries share (WA is the code of Washington and of Western Australia). none is not one of these: under an optional column it is the absent value, and under any other column it is E103.

Fix. Match the spelling to the declaration, or declare the input, derived value or definition above. For a spelling two countries share, write the value's name (Washington or Western_Australia).

Smallest reproduction:

rule t(t) v1

inputs
  x(x) : bool

outputs
  r(r) : bool

table j(j)
policy unique
| y | -> r(r) : bool |
| - | true           |

Related codes: E011, E013

E013

error — No such import

When. The target of import is not there. There are three kinds: the built-in namespace (the first-level divisions of thirteen countries: std/us/states, std/gb/nations, std/cn/provinces, std/tw/divisions, std/kr/provinces, std/in/states, std/fr/regions, std/es/communities, std/it/regions, std/de/states, std/au/states, std/br/states and std/jp/prefectures, whose prefectures std/都道府県 also imports, with the values spelled in Japanese), an enum in a .proto (import proto "<file>" <Enum> -> <enum of this rule>), and an enum in a JSON Schema (import jsonschema "<file>" "<pointer>" -> <enum of this rule>, OpenAPI included). For the last two it appears when the file cannot be read, when it holds no such enum, or when the line is not that shape. YAML is not read; point at a JSON form of it. It also appears when one country's divisions are imported under both of its names (std/都道府県 and std/jp/prefectures).

Fix. Correct the namespace's spelling (the note gives the closest one), or declare the enum in this file with enum. When importing from a file, the path is followed from the directory of the rule file, so write it relative to that. A JSON Schema pointer looks like #/components/schemas/<name>, and one that does not resolve comes back with the keys that are there.

Smallest reproduction:

rule t(t) v1

import std/us/state

Related codes: E012, E032

E014

error — An output cell cannot hold an expression

When. A cell to the right of -> holds two or more words. Only one value or one name may be written there. Taking just the first word and skipping the rest would emit generated code with the multiplication silently dropped.

Fix. Give the calculation a name on a define line and leave only that name in the table (| - | rate_discount |). A table holds the branching and nothing else.

Smallest reproduction:

rule t(t) v1

inputs
  p(p) : money[JPY, incl_tax]  range >=0JPY <=10_000JPY
  r(r) : rate[step 1%]  range >=0% <=100%

outputs
  o(o) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy first
| r    | -> o(o) : money[JPY, incl_tax] |
| <=5% | 0JPY                           |
| -    | p * r                          |

Related codes: E008, E012

E015

error — result can only assemble the first output

When. A result names an output other than the first. result is sugar for the first output, and both the evaluator and the generated code apply it only there. The name used to be ignored, so a number could land in a money slot without an E103.

Fix. Write a define of the same name as that output (define points(pts) : number = base_points * multiplier); outputs are taken, in declaration order, from the binding of their own name. To assemble it with result instead, move that output to the top of outputs.

Smallest reproduction:

rule t(t) v1

inputs
  p(p) : money[JPY, incl_tax]  range >=0JPY <=10_000JPY

outputs
  a(a) : money[JPY, incl_tax]  round down(1JPY)
  b(b) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| p | -> a(a) : money[JPY, incl_tax] |
| - | 100JPY                         |

result b = p

Related codes: E016, E103

E016

error — There can be only one result

When. A file has more than one result line. Only the first output can be assembled, so a second result merely replaces the first — which it used to do in silence.

Fix. Keep one. The other outputs are taken from a define of the same name as the output.

Smallest reproduction:

rule t(t) v1

inputs
  p(p) : money[JPY, incl_tax]  range >=0JPY <=10_000JPY

outputs
  a(a) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| p | -> a(a) : money[JPY, incl_tax] |
| - | 100JPY                         |

result a = p
result a = p + 100JPY

Related codes: E015

E017

error — A constraint is not shaped like this

When. A constraint line is not input comparison input: there is no comparison, a side is neither one name nor names added up with +, or both sides are sums.

Fix. Write constraint <input> <= <input>; the comparisons are <=, <, >= and >. One side may add inputs up (constraint discount + points <= subtotal); a coefficient or a constant cannot be written. For A = B, write the two lines A <= B and A >= B.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : number  range >=0 <=10
  b(b) : number  range >=0 <=10

constraint a

outputs
  r(r) : bool

table j(j)
policy unique
| a | -> r(r) : bool |
| - | true           |

Related codes: E018

E018

error — A constraint relates two inputs

When. A side of a constraint is not an input, or has a type with no order. A constraint says which combinations of the values the caller passes can happen, so both sides name something in inputs, and each is money, a quantity, a rate, a number or a date. Every name a sum adds is held to the same.

Fix. Name inputs on both sides. A derived or defined value is computed from inputs, so write the relation between those inputs; an enum and a boolean have no order.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : number  range >=0 <=10

constraint a <= r

outputs
  r(r) : bool

table j(j)
policy unique
| a | -> r(r) : bool |
| - | true           |

Related codes: E017, W111

E019

error — An example is an input the generated code refuses at its door

When. An example's inputs do not satisfy a constraint, or the value of an input — a field of an element of the sequence included — lies outside its declared range. A constraint declares that a combination does not happen and a range that no value outside it arrives; the completeness check believed them and demanded no row there, and the generated code refuses that input at the door. It is not an input an answer can be claimed for. An example outside the range, and one that breaks a constraint between two dates, used to pass the check, and the vector made from it was then refused by the generated code.

Fix. Correct the example's values — or, if that value or combination really does arrive, widen the range or drop the constraint.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : number  range >=0 <=10
  b(b) : number  range >=0 <=10

constraint a <= b

outputs
  r(r) : bool

table j(j)
policy unique
| a | b | -> r(r) : bool |
| - | - | true           |

examples
| a | b | -> r |
| 5 | 1 | true |

Related codes: E017, E018, E101

E020

error — The elements declaration is not right

When. An elements line has no name, or nothing walks the sequence it declares. A sequence becomes a value of the rule only when a count, a sum, a max, a min or a fold names it after over; an item that reads a field of a sequence nothing walks reads no element in particular. A rule may walk any number of sequences, each under an elements of its own.

Fix. Write elements fee_rows(fee_rows), and the fields of one element under it, declared the way inputs are. If the sequence is needed, add the line that walks it; if not, take the elements out.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=0 <=10

elements xs(xs)
  k(k) : number  range >=0 <=10

outputs
  r(r) : bool

table j(j)
policy unique
| n | -> r(r) : bool |
| - | true           |

Related codes: E028, E021, E031

E021

error — The fold is not written correctly

When. The heading is not fold <verdict column> over <sequence> [-> <name> [: <type>]], or an arm is not one of next, stop, stop with <value>, take_unique <value>, take_first <value>, keep_max <value> by <key>, take_weighted <value> by <weight>, or the column being folded is not an enum. So is an answer named after an input, a field of an element, a sequence or a value declared above; a name that is no output given no type; an output's name given a type other than the output's; and a name that the fold and another item both decide. So, too, is a value of the fold that reads what is not there when it is decided: empty and exhausted are decided where no element is being looked at and cannot read an element's value; no value can read what is computed from the fold's own answer (a verdict that read it would need the answer before there is one); and held, what the walk holds once it has seen every element, belongs in exhausted only.

Fix. Correct the heading and the arms. A bare take cannot be written: whether one and only one element may be taken, or the first of several, is for the author to choose. To answer with a value of an element, take it with take_unique, take_first or keep_max, and answer exhausted -> held. Name the answer with -> <name> for the items below to read it; a verdict that needs a fold's answer goes in another fold, which reads it on a second walk.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=0 <=10

elements xs(xs)
  k(k) : number  range >=0 <=10

outputs
  r(r) : bool

table j(j)
policy unique
| n | -> r(r) : bool |
| - | true           |

fold r
  empty -> false

Related codes: E020, E022, E023, E024

E022

error — The answer for a sequence with no elements is not declared

When. A fold has no empty -> <value>, or a max or a min has no empty <value>. An empty sequence always turns up, and it is the case a hand-written loop most often forgets — usually by reading the first element and falling over. For a max and a min, it is also the answer when no element passes the where.

Fix. Add empty -> <value> (empty <value> on a max or a min). What to answer is a business decision, and not one the tool can make.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  b -> take_first k
  exhausted -> held

A max with no empty:

rule t(t) v1

elements xs(xs)
  k(k) : number  range >=0 <=10

outputs
  r(r) : number  round down(1)

max r over xs of k

Related codes: E023, E024

E023

error — The answer for a walk that reached the end is not declared

When. A fold has no exhausted -> <value>: the answer when the sequence ran out and no element ended the walk. Answering with the value that was held is a choice, and it is made by writing it.

Fix. Add exhausted -> <value>; to answer with what is held, that is exhausted -> held.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  b -> take_first k
  empty -> 0JPY

Related codes: E022, E024

E024

error — Some verdict has no arm

When. A verdict the table can produce has no arm in the fold: when an element lands on it, the walk has no move. It is the table's own completeness check, applied to the fold.

Fix. Add the arm, or stop the table producing that value. The other direction — an arm for a verdict nothing can reach — is W115.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  empty -> 0JPY
  exhausted -> held

Related codes: E022, E023, W115

E025

error — The examples have no column for the sequence

When. A rule that walks a sequence has examples, but the header has no column named after its elements. An example that does not say which sequence it walks is an example with no answer.

Fix. Write the list with sequence <name>, add a column for the sequence to the examples header, and name it in the cell. A sequence with no rows is the example for a sequence with nothing in it.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  b -> take_first k
  empty -> 0JPY
  exhausted -> held

examples
| -> r |
| 0JPY |

Related codes: E026, E027

E026

error — The sequence is not written correctly

When. The columns of a sequence do not line up with the fields of elements: a column that is not a field, a field left out, one field's column twice, a ->, no sequence to be a list of, two blocks with the same name, or a cell that is not a value (a range or a -).

Fix. Make the header the fields of elements as they are, and write one element's values per row. This is not a table: it is the list of values as they would really be passed.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  b -> take_first k
  empty -> 0JPY
  exhausted -> held

sequence s(s)
| m    |
| 3JPY |

Related codes: E025, E020

E027

error — The example names a sequence that is not there

When. The cell in the sequence column names a sequence that is not declared, or holds something that is not a name at all.

Fix. Write a sequence under that name, or correct the cell to one that is written.

Smallest reproduction:

rule t(t) v1

enum v(v) = a(a) | b(b)

elements xs(xs)
  k(k) : money[JPY, incl_tax]  range >=0JPY <=10JPY

outputs
  r(r) : money[JPY, incl_tax]  round down(1JPY)

table j(j)
policy unique
| k      | -> d(d) : v |
| <=5JPY | a           |
| >5JPY  | b           |

fold d over xs
  a -> next
  b -> take_first k
  empty -> 0JPY
  exhausted -> held

examples
| xs   | -> r |
| nope | 0JPY |

Related codes: E025, E026

E028

error — The count is not written correctly

When. The line is not count <name>(<alias>) over <sequence> where <column> = <value>: no over, no where, a sequence that elements does not declare, or an = with nothing on its right. So is a sum that is not sum <name>(<alias>) over <sequence> of <column>, and a max or a min that is not <name>(<alias>) over <sequence> of <column> [where <column> [= <value>]] empty <value>.

Fix. Write it in that shape. The = <value> may be left out only for a bool column.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=0 <=10

elements xs(xs)
  b(b) : bool

outputs
  r(r) : bool

count h(h) where b  range >=0 <=10

table j(j)
policy unique
| n | -> r(r) : bool |
| - | true           |

Related codes: E029, E030, E020

E029

error — This column cannot be counted

When. The column where names is not a value of one element (an input or a derived value is one per call, so counting it could only answer 0 or 1); or its values are not a closed set; or the value written is not one of that enum's; or an enum column was given no = <value>. The column after of on a sum, a max or a min is held the same way, and it also appears when that column is a value of another sequence than the one over names, when a sum reads no number, and when a max or a min reads neither a number, a date nor an ordered enum (their title then says the column cannot be summarised).

Fix. Name a field of an element, or a column a per-element table produces. Writing the classification as a table is what puts the classification itself under the completeness check.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=0 <=10
  ok(ok) : bool

elements xs(xs)
  b(b) : bool

outputs
  r(r) : bool

count h(h) over xs where ok  range >=0 <=10

table j(j)
policy unique
| h | -> r(r) : bool |
| - | true           |

Related codes: E028, E012

E030

error — A count needs a range

When. The count line has no range >=0 <=<max>, or no upper bound, or a negative lower one. The range means two things: the universe the completeness check quantifies over once the count is a column, and the cap on the sequence.

Fix. Write it as range >=0 <=100. The generated code refuses a longer sequence at the door, the way it refuses a number outside its range.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=0 <=10

elements xs(xs)
  b(b) : bool

outputs
  r(r) : bool

count h(h) over xs where b

table j(j)
policy unique
| h | -> r(r) : bool |
| - | true           |

Related codes: E028, E112

E031

error — One item reads the elements of two sequences

When. One item (a table, a clause, a derive, a definition or a fold) reads a value of one element of each of two sequences. A value of one element exists only while its sequence is walked, so reading both together would walk one sequence again from the start at every element of the other — a walk inside a walk. The number of walks would then grow with the length of a sequence, and the checks could not finish. So is an output that is a value of one element: once the walk is over, it is not one value. A rule's items fall into those that read no element and those of one element, and an item of one element is worked out on the walk after the one that finds every summary it reads (an item of one element that reads a summary goes on a second walk).

Fix. Make one of the sequences one value first — a count, a sum, a max, a min or a fold — and read that value in the item of the other; the item is then worked out on a second walk, once the value is known. To answer with something each element decides, make it one value for the whole sequence with a summary first.

Smallest reproduction:

rule t(t) v1

elements xs(xs)
  a(a) : number  range >=0 <=10

elements ys(ys)
  b(b) : number  range >=0 <=10

outputs
  r(r) : number  round down(1)
  s(s) : number  round down(1)

define both(both) : number = a + b

sum r over xs of both  range >=0 <=1000

sum s over ys of b  range >=0 <=1000

An output that is a value of one element:

rule big_parts v1

elements parts
  price : number  range >=0 <=100

outputs
  total : number  round down(1)
  big   : bool

table big_of
policy unique
| price | -> big : bool |
| >=50  | true          |
| <50   | false         |

sum total over parts of price  range >=0 <=10000

Related codes: E021, E029, E020

E032

error — The declared enum and the imported one disagree

When. The values of the enum named by import proto or import jsonschema and the values of the rule's enum (their ASCII aliases, where they have them) are not the same set. Values on either side alone are named, in both directions. It is usually the proto that gained one, and it shipped as a compatible change made outside this rule.

Fix. Add the new value to the rule's enum; where the enum gives its values names with aliases, the name is yours to choose. A value the contract dropped goes from the rule too. Once it is added, the table asks whether it needs a row (E033).

Smallest reproduction:

rule t(t) v1

import proto "tier.proto" Tier -> v
enum v(v) = one(one)

inputs
  x(x) : v

outputs
  r(r) : bool

table j(j)
policy unique
| x   | -> r(r) : bool |
| one | true           |

With tier.proto beside it:

syntax = "proto3";

enum Tier {
  TIER_UNSPECIFIED = 0;
  TIER_ONE = 1;
  TIER_TWO = 2;
}

Related codes: E013, E033, E101

E033

error — A value that came from elsewhere has neither a row nor default

When. A value of an imported enum appears in no row and is not marked default. The same holds for a value a contribution adds with extend that no row of a table names and that falls in silence to a row of -, a not: that does not leave it out, or a comparing cell that now covers it (each such row is named). For a value you wrote yourself that is a forgotten line (W111); for a value that came through a contract or a contribution it means a change from elsewhere that nobody has read yet, so it stops. With a default row the completeness check passes and the new value quietly takes the default row's answer.

Fix. Add a row for it, or mark the value default in the declaration. For a value a contribution adds, have a contribution add its row to the open table, or put default on the extend line. default is a signature saying that falling through to the default row is what is meant — that someone decided how it is treated.

Smallest reproduction:

rule t(t) v1

import proto "tier.proto" Tier -> v
enum v(v) = one(one) | two(two)

inputs
  x(x) : v

outputs
  r(r) : bool

table j(j)
policy first
| x   | -> r(r) : bool |
| one | true           |
| -   | false          |

With tier.proto beside it:

syntax = "proto3";

enum Tier {
  TIER_UNSPECIFIED = 0;
  TIER_ONE = 1;
  TIER_TWO = 2;
}

A value a contribution adds (extend):

contribution c(c) v1
to "base.rule" signature:69e01897ab91b191

extend kind with z

With base.rule beside it:

rule base(base) v1

enum kind(kind) = a(a) | b(b)  open

inputs
  k(k) : kind

outputs
  fee(fee) : number  round down(1)

table t(t)
policy first
| k | -> fee : number |
| a | 1               |
| - | 2               |

Related codes: E032, W111, E101, E067

E034

error — A name appears twice

When. A file writes one name twice among the names of one kind, and it is said at the second. The kinds are the values (the inputs, the sequences and the fields of their elements, the outputs, and what derive, define, count, sum, max, min, open and the output columns of tables and clauses decide), the tables and clauses, the enums, the values of one enum, the groups and the values one lists, the shapes, the sources, the applies, the prerequisites blocks, the labels of the rows of one table, and the columns of the heading of a table or of the examples. An output shares its name with what decides it, and several tables and clauses may decide one name; any other two values of one name stop here, an output named like an input among them. A group named like a value of an enum is one word read two ways, and stops here too. So do two names of one list that come to one identifier in the generated code (the alias of one is the alias or the name of the other), one name given two aliases, and, in an enums file, an enum's name that is another enum's alias (import enum finds an enum by either). So do two names whose identifiers differ but which every language that writes them spells as one: the types of two enums and two values of one enum (both written in PascalCase), the functions of two prerequisites blocks (in snake_case), the element types of a rule's two sequences, and a shape beside an input or a sequence among the parameters of the function that reads the caller's objects. Two that only some languages spell as one are W121. An enum read with import enum, and a group that comes with it, is held to the names of this rule and of the other import enum lines, and an input a contribution adds to the names of the rule it adds to. A fold's answer is held by E021, and the name an apply gives a callee output by E041.

Fix. Remove one of the two, or rename one (a row label and a column of a heading alike). Of two names that come to one identifier, give one another alias. An enum read with import enum can be read under another name with -> <another name>.

Smallest reproduction:

rule weight_check v1

inputs
  weight : number  range >=0 <=9
  weight : number  range >=0 <=99

outputs
  heavy : bool

table decide
policy unique
| weight | -> heavy |
| <=5    | false    |
| >5     | true     |

One value written twice in an enum:

rule free_shipping v1

enum member_kind = basic | gold | basic

inputs
  member : member_kind

outputs
  free : bool

table decide
policy unique
| member | -> free |
| basic  | false   |
| gold   | true    |

Two names that come to one identifier:

rule size_check v1

inputs
  weight(w) : number  range >=0 <=9
  width(w)  : number  range >=0 <=9

outputs
  large : bool

table decide
policy first
| weight | width | -> large |
| >5     | -     | true     |
| -      | >5    | true     |
| -      | -     | false    |

One column twice in a table's heading:

rule weight_check v1

inputs
  weight : number  range >=0 <=9

outputs
  heavy : bool

table decide
policy first
| weight | weight | -> heavy |
| <=5    | >5     | true     |
| -      | -      | false    |

Two enums whose types take one name:

rule tier_fee v1

enum tier_level = basic | gold
enum tierLevel = low | high

inputs
  member : tier_level
  band   : tierLevel

outputs
  fee : money[USD]  round down(1USD)

table fee_by_member
policy unique
| member | band | -> fee |
| basic  | -    | 1USD   |
| gold   | low  | 2USD   |
| gold   | high | 3USD   |

One label on two rows of a table:

rule t(t) v1

inputs
  a(a) : bool

outputs
  x(x) : bool

table t1(t1)
   | a     | -> x  |
r1 | true  | true  |
r1 | false | false |

Related codes: E009, E035, E021, E041, E075, W121

E035

error — The target of overrides does not exist

When. An overrides line names a table that does not exist, or one declared below this table, or a row label (table:label) the table has no row of. A line whose shape cannot be read is reported the same way. The exception is written after what it excepts, so a target is always above.

Fix. Name a table declared above, or one of its rows (label the row at its head and write table:label). Write the side that takes precedence later.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : bool

outputs
  x(x) : bool

table t1(t1)
overrides no_such_table
| a     | -> x  |
| true  | true  |
| false | false |

Related codes: E034, E036

E036

error — The target of overrides does not define the same output

When. The table an overrides line names defines a different output from this table. Precedence exists only between definitions of the same output.

Fix. Name a table that defines the same output, or make this table's output column the same one.

Smallest reproduction:

rule t(t) v1

inputs
  a(a) : bool

outputs
  x(x) : bool
  y(y) : bool

table base(base)
| a | -> x |
| - | true |

table special(special)
overrides base
| a | -> y |
| - | true |

Related codes: E035, E045

E037

error — A cited fragment is not pinned

When. A fragment cited with @source fragment has no fragment sha256:… pin line under its source line; for a file source, the line carries no sha256:…. A law cited with no article (@source alone), and a fragment name, a citation or a source line whose shape cannot be read, are reported the same way (a file beside the rule may be cited whole, @postal). A document's fragments are its tables, so table3 (the third table in document order; 表3 is its Japanese spelling) is the only name read. A fragment the language cannot read as one word is quoted (@osha "§1910.157"). Without a pin, a revised copy passes check in silence.

Fix. Once the transcribed rows are checked against the document, paste the fix.text line or run rulec source pin <file.rule> to pin the copy's digest.

Smallest reproduction:

rule t(t) v1

source 法 = law "000AC0000000001" asof 2026-04-01

inputs
  a(a) : bool

outputs
  x(x) : bool

table 表(t1)  @法 第1条
| a | -> x |
| - | true |

With sources/law/000AC0000000001@2026-04-01/MainProvision-Article_1.xml beside it:

<Article Num="1"><ArticleTitle>第一条</ArticleTitle><Paragraph Num="1"><ParagraphNum/><ParagraphSentence><Sentence>甲は、乙とする。</Sentence></ParagraphSentence></Paragraph></Article>

Related codes: E038, E039, W119

E038

error — A source fragment has changed

When. The pinned digest differs from the digest of the copy beside the rule. It fails in the pull request that refreshed the copy, and names the tables, clauses and rows that cite the fragment, which is all there is to reread.

Fix. Read the copy's diff; if the transcribed rows still hold, rewrite the pin line as fix.text says (rulec source pin writes it too). If the rows have to change, change them first.

Smallest reproduction:

rule t(t) v1

source 法 = law "000AC0000000001" asof 2026-04-01
  第1条 sha256:0000000000000000

inputs
  a(a) : bool

outputs
  x(x) : bool

table 表(t1)  @法 第1条
| a | -> x |
| - | true |

With sources/law/000AC0000000001@2026-04-01/MainProvision-Article_1.xml beside it:

<Article Num="1"><ArticleTitle>第一条</ArticleTitle><Paragraph Num="1"><ParagraphNum/><ParagraphSentence><Sentence>甲は、乙とする。</Sentence></ParagraphSentence></Paragraph></Article>

Related codes: E037, E039

E039

error — There is no copy of a source

When. The copy of a cited fragment is not beside the rule — sources/law/<law id>@<date>/<element>.xml for a law, tariff.md.fragments/table3.tsv beside the document for a document's table — or the file source itself cannot be read. check reads neither the network nor the document, so without a copy there is nothing to compare.

Fix. rulec source fetch <file.rule> fetches the fragment from e-Gov, the Japanese government's statute database, and takes the cited tables out of a document, into the copies beside the rule. Commit the copies.

Smallest reproduction:

rule t(t) v1

source 法 = law "000AC0000000001" asof 2026-04-01

inputs
  a(a) : bool

outputs
  x(x) : bool

table 表(t1)  @法 第2条
| a | -> x |
| - | true |

Related codes: E037, E038

E040

error — A file relied on differs from its pin

When. An apply heading carries no pin, or the pin differs from the callee beside the rule. The pin is meaning:… — the callee's rows and declarations with its comments, description and citations left out — and a sha256:… written before (the file's bytes) is still read. When the callee's rows are amended, the answers of the rule that applies it change too. The same holds for the signature:… on a contribution's to and after lines, missing or not matching: it is the shape of the file added to (its name, inputs and outputs, open values and outputs, open enums and blocks, and the declarations of the names the contribution reads), so a row or a comment of that file does not move it, and when the shape moves the diagnostic says what moved (when the repository's history holds the version it was pinned at). Without a pin, the change passes with nobody approving it.

Fix. See with rulec diff <old> <new> how many answers of this rule move and by how much; once the movement is approved, rewrite the heading as fix.text says or run rulec source pin <file.rule> to pin the callee again. For a contribution, read it against the new shape, then rewrite the signature: with rulec source pin <contribution>.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=1 <=10

outputs
  y(y) : number  round down(1)

apply call(c) = "callee.rule"
  a = n
  x -> y

With callee.rule beside it:

rule callee(callee) v1

inputs
  a(a) : number  range >=1 <=10

outputs
  x(x) : number  round down(1)

table t(t)
policy unique
      | a   | -> x |
small | <=5 | 1    |
large | >5  | 2    |

A contribution's signature: differs from the shape it adds to:

contribution c(c) v1
to "base.rule" signature:0123456789abcdef

extend kind with z

With base.rule beside it:

rule base(base) v1

enum kind(kind) = a(a) | b(b)  open

inputs
  k(k) : kind

outputs
  fee(fee) : number  round down(1)

table t(t)
policy first
| k | -> fee : number |
| a | 1               |
| - | 2               |

Related codes: E037, E038, E044, E067

E041

error — The bindings of an apply do not match the callee

When. A callee input is left unbound or bound twice, a binding or an output line names something the callee does not have, the name given to a callee output is already declared in this rule, one callee output is given two names, or the apply block is not shaped as one. Substitution is written by binding every input explicitly, so a missing binding is a substitution left unwritten.

Fix. Bind each callee input with one <callee input> = <value> line, and rename an output with <callee output> -> <name>. The callee's input and output names are listed in the message.

Smallest reproduction:

rule t(t) v1

inputs
  n(n) : number  range >=1 <=10

outputs
  y(y) : number  round down(1)

apply call(c) = "callee.rule" sha256:1c554496c37f709f
  b = n
  x -> y