wren/doc/site/branching.markdown

^title Branching

Control flow is used to determine which chunks of code are executed and how many times. Expressions and statements for deciding whether or not to execute some code are called branching and are covered here. To execute something more than once, you'll want looping.

Truthiness

Branching is conditional on the value of some expression. We take the entire universe of possible values and divide them into two buckets: some we consider "true" and the rest are "false". If the expression results in a value in the true bucket, we branch one way. Otherwise, we go the other way.

Obviously, the boolean true is in the "true" bucket and false is in "false", but what about values of other types? The choice is ultimately arbitrary, and different languages have different rules. Wren's rules follow Ruby:

• The boolean value false is false.
• The null value null is false.
• Everything else is true.

This means 0, empty strings, and empty collections are all considered "true" values.

If statements

The simplest branching statement, if lets you conditionally skip a chunk of code. It looks like this:

:::wren
if (ready) IO.write("go!")

That evaluates the parenthesized expression after if. If it's true, then the statement after the condition is evaluated. Otherwise it is skipped. Instead of a statement, you can have a block:

:::wren
if (ready) {
  IO.write("getSet")
  IO.write("go!")
}

You may also provide an else branch. It will be executed if the condition is false:

:::wren
if (ready) IO.write("go!") else IO.write("not ready!")

And, of course, it can take a block too:

if (ready) {
  IO.write("go!")
} else {
  IO.write("not ready!")
}

The logical operators && and ||

The && and || operators are lumped here under branching because they conditionally execute some code—they short-circuit. Both of them are infix operators, and, depending on the value of the left-hand side, the right-hand operand expression may or may not be evaluated.

An && ("logical and") expression evaluates the left-hand argument. If it's falsey, it returns that value. Otherwise it evaluates and returns the right-hand argument.

:::wren
IO.write(false && 1)  // false
IO.write(1 && 2)      // 2

An || ("logical or") expression is reversed. If the left-hand argument is truthy, it's returned, otherwise the right-hand argument is evaluated and returned:

:::wren
IO.write(false || 1)  // 1
IO.write(1 || 2)      // 1

TODO: Conditional operator.