Expressions and Priorities

This page treats Vitte logic as an executable mechanism: each rule is linked to a concrete consequence in the program flow. A Vitte expression must remain locally evaluable. If the operator precedence makes the reading uncertain, the expression must be decomposed.

proc expr_a(a: int) -> int {
  let v: int = (a + 1) * 2
  give v
}

Why this step is solid. Parentheses impose the order of calculation and eliminate the ambiguity of precedence. The result is then named to keep local track of the subcalculation.

What happens at runtime. expr_a(4) calculates (4+1)=5, then 5*2=10, then returns 10.

proc expr_b(ready: bool, blocked: bool) -> bool {
  let ok: bool = ready and not blocked
  give ok
}

Why this step is solid. not applies to the predicate blocked before the conjunction. The evaluation is short-circuited: if ready is false, the second part can be ignored.

What happens at runtime. (true,false)->true, (true,true)->false, (false,false)->false.

proc expr_c(value: int) -> int {
  make n as int = value as int
  give n
}

Why this step is solid. Explicit as conversion kept visible even when the types appear compatible. This choice is useful at the module boundary where conversions need to be audited.

What happens at runtime. expr_c(9) returns 9; the conversion trace remains present at the source level.

The Vitte rule on expressions is strict. Implicit priority acceptable for trivial cases, obligatory decomposition as soon as the density of operators harms the verification.