sl0ppty: PI is 180

Angles here are degrees, and pi in an angle language is not a number -- it is a
half turn. So `PI` is 180, `TAU` is 360, and a formula written the radian way
ports across as written:

    sin(TAU * x / cols)      one cycle over the pane's width
    sin(TAU * p * 3 / perim) three lobes fitted exactly to a border
    PI / 2                   a quarter turn
    PI / 6                   thirty degrees, exactly

That last line is the argument. A numeric pi would be 3 in this language, and
`3.14159 / 6` in integers is 0 -- so radians cannot express a sixth of a turn
here at all, while degrees give it as a whole number. The pun is not a
compromise; it is the more precise reading of the two.

Which is why there is no `deg2rad` or `rad2deg` beside them, and asking for one
says `unknown function`. There is one angle unit. A conversion could only lose
the angle (`deg2rad(90)` is 1, and `sin(1)` is nearly nothing) or invent a second
scale for the language to disagree with itself about.

Spelled-out numbers rather than variables: they read no environment, carry no
dependency, and fold into the program like the literals they are. The browser
preview learned the same two, from the same table.

Verified: 12 cases in `tests/expr_test.c`, including that `deg2rad` and
`rad2deg` are refused; the cross-check agrees with the compiler on 700
evaluations, now including `sin(TAU * x / cols)` and friends.

Two smaller things ride along, both from the repl. `PI`/`TAU` tab-complete, and
its drift test grew a third table to check -- it already caught `sin`/`cos`
missing before I did. And it now checks the script *parses* before starting a
pane that runs it: I broke the indentation of one line here, and the failure
arrived as `IndexError: list index out of range` from a pane that died before
its prompt, which is a long way from "line 212".

1 files changed, 9 insertions, 0 deletions

diff --git a/docs/shaders.md b/docs/shaders.md
index 716395a..5197cb9 100644
--- a/docs/shaders.md
+++ b/docs/shaders.md
@@ -66,6 +66,15 @@ shaders {
 | functions | `min(a,b)` `max(a,b)` `abs(a)` `clamp(v,lo,hi)` |
 | | `dist(x1,y1,x2,y2)` — counts a row double, because a cell is about twice as tall as it is wide |
 | | `sin(deg)` `cos(deg)` — **degrees** in, −255..255 out, so `128 + sin(t / 4) / 2` is a breathe |
+| constants | `PI` = 180, `TAU` = 360 — pi as an *angle*, which is what it is here: a half turn |
+
+`PI` being a half turn is what makes a radian-shaped formula port across as
+written: `sin(TAU * x / cols)` is one cycle over the pane's width, `PI / 2` is a
+quarter turn, `PI / 6` is thirty degrees. It is also *more* exact than radians
+could be in a language with no fractions — a sixth of a turn is 30 whole degrees,
+where `3.14159 / 6` in integers is 0. For the same reason there is no `deg2rad`
+or `rad2deg`: there is one angle unit, and a conversion could only lose the angle
+or invent a second scale to disagree with.
 
 There are no loops and no recursion, on purpose: a config cannot spin and there
 is nothing to sandbox. An expression that does not compile drops that one shader