? wut · Conditionals
Hoon has the usual program control branches. It also has the usual logical operators: AND ?&, OR ?|, and NOT ?!. It also has a ?= rune that tests whether a value matches a given type. In the course of type inference, Hoon learns from ?= tests in the test condition of ?: ("wutcol") expressions.
Overview
All ? runes reduce to ?: and/or ?=.
If the condition of an ?: is a ?=, and the ?= is testing a leg of the subject, the compiler specializes the subject type for the branches of the ?:. Branch inference also works for expressions which expand to ?:.
The test does not have to be a single ?=; the compiler can analyze arbitrary boolean logic (?& ("wutpam"), ?| ("wutbar"), ?! ("wutzap")) with full short-circuiting. Equality tests (.= ("dottis")) are not analyzed.
If the compiler detects that the branch is degenerate (only one side is taken), it fails with an error.
?| "wutbar"
Logical OR.
Syntax
Variable number of arguments.
?| p1
p2
p3
pn
==?|(p1 p2 p3 pn)|(p1 p2 p3 pn)AST
Expands to
Pseudocode: a, b, c, ... as elements of .p:
Desugaring
Produces
If any argument evaluates to true (%.y), true. If all arguments evaluate to false (%.n), false.
Examples
?- "wuthep"
Switch against a union, with no default.
Syntax
One fixed argument, then a variable number of pairs.
None
AST
Expands to
Pseudocode: a, b, c, ... as elements of .q:
Desugaring
Discussion
The ?- rune is for a conditional expression in which the type of .p determines which branch is taken. Usually the type of .p is a union of other types. There is no default branch.
The compiler makes sure that your code neither misses a case of the union, nor includes a double case that isn't there. This is not special handling for ?-, just a consequence of the semantics of ?:, which ?- reduces to.
A missing case will throw the mint-lost error. An extra case will throw mint-vain.
Examples
?: "wutcol"
Branch on a boolean test.
Syntax
Three arguments, fixed.
None
AST
Produces
If .p produces true (%.y), then .q. If .p produces false (%.n), then .r. If .p is not a boolean, compiler yells at you.
Discussion
If test analysis reveals that either branch is never taken, or if .p is not a boolean, compilation fails. An untaken branch is indicated with mint-lost.
Note also that all other branching expressions reduce to ?:.
Examples
?. "wutdot"
Branch on a boolean test, inverted.
Syntax
Three arguments, fixed.
None
AST
Expands to
Discussion
?. is just like ?:, but with its last two subexpressions reversed.
As is usual with inverted forms, use ?. when the true-case expression is much taller and/or wider than the false-case expression.
Examples
?^ "wutket"
Branch on whether a wing of the subject is a cell.
Syntax
Three arguments, fixed.
None
AST
Expands to
Discussion
The type of the wing, .p, must not be known to be either an atom or a cell, or else you'll get a mint-vain error at compile time. mint-vain means that one of the ?^ branches, .q or .r, is never taken.
Examples
?< "wutgal"
Negative assertion.
Syntax
Two arguments, fixed.
None
AST
Expands to
Discussion
?< is used to force a crash when some condition .p doesn't yield false (%.n). It can be used for type inference with the ?= rune, much like the ?> rune.
Examples
?> "wutgar"
Positive assertion.
Syntax
Two arguments, fixed.
None
AST
Expands to
Discussion
?> is used to force a crash when some condition .p doesn't yield true (%.y). It can be used for type inference, with the ?= rune, to specify the type of a value.
Examples
?+ "wutlus"
Switch against a union, with a default.
Syntax
Two fixed arguments, then a variable number of pairs.
None
AST
Expands to
Pseudocode: a, b, c, ... as elements of .r:
Desugaring
Discussion
The ?+ rune is for a conditional expression in which the type of .p determines which branch is taken. Usually the type of .p is a union of other types. If .p's type doesn't match the case for any given branch, the default expression, .q, is evaluated.
If there is a case that is never taken you'll get a mint-vain error.
Examples
?& "wutpam"
Logical AND.
Syntax
Variable arguments.
AST
Expands to
Pseudocode: a, b, c, ... as elements of .p:
Desugaring
Produces
If ALL arguments evaluate to true (%.y), true (%.y). If one or more evalute to false (%.n), false (%.n).
Examples
?@ "wutpat"
Branch on whether a wing of the subject is an atom.
Syntax
Three arguments, fixed.
None
AST
Expands to
Produces
If .p is an atom, .q. If .p is a cell, .r.
Discussion
The type of the wing, .p, must not be known to be either an atom or a cell, or else you'll get a mint-vain error at compile time. mint-vain means that one of the ?@ branches, .q or .r, is never taken.
Examples
?~ "wutsig"
Branch on whether a wing of the subject is null.
Syntax
Three arguments, fixed.
None
AST
Expands to
Produces
If .p is null (~), .q. If .p is non-null, .r.
Discussion
It's bad style to use ?~ to test for any zero atom. Use it only for a true null, ~.
Examples
?= "wuttis"
Test pattern match.
Syntax
Two arguments, fixed.
AST
Produces
%.y (true) if the noun at .q is in the type of .p; %.n (false) otherwise.
Discussion
?= is not as powerful as it might seem. For instance, it can't generate a loop -- you cannot (and should not) use it to test whether a * is a (list @). Nor can it validate atomic auras.
Patterns should be as weak as possible. Unpack one layer of union at a time. Don't confirm things the type system knows.
For example, when matching from a tagged union for the type [%foo p=@ q=[@ @]], the appropriate pattern is [%foo *]. You have one question, which is whether the head of the noun is %foo.
A common error is find.$, meaning .p is not a type.
Examples
?! "wutzap"
Logical NOT.
Syntax
One argument, fixed.
?! p
?!(p)
!p
AST
Expands to
Produces
The logical NOT of .p, which must evaluate to either %.y or %.n.
Examples
Last updated