Control Flow in Hare

Control flow is how a program decides what to do next — branching on conditions and repeating work. As an imperative systems language in the C tradition, Hare uses familiar structured constructs: if/else for branching, switch for multi-way dispatch, and a single, flexible for keyword that covers every kind of loop.

What sets Hare apart from C is that if is an expression, not just a statement. It evaluates to a value, which means Hare doesn’t need a separate ternary operator. Combined with the requirement that every branch be explicit and the consistent use of braces, Hare’s control flow is conservative and predictable by design — there are no surprises hiding behind implicit conversions or fall-through.

In this tutorial you’ll learn how to branch with if/else if/else, use if as an expression, dispatch on values with switch, write counting and condition-based loops with for, and control loop execution with break and continue — including labeled jumps out of nested loops.

Conditionals: if / else if / else

The most basic control structure is the if statement. The condition must be wrapped in parentheses, and each branch uses braces. Hare does not allow a non-boolean value to stand in as a condition — the expression must be of type bool.

Create a file named conditionals.ha:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

use fmt;

export fn main() void = {
	const score = 85;

	if (score >= 90) {
		fmt::println("Grade: A")!;
	} else if (score >= 80) {
		fmt::println("Grade: B")!;
	} else if (score >= 70) {
		fmt::println("Grade: C")!;
	} else {
		fmt::println("Grade: F")!;
	};
};

Each branch is checked in order, and the first matching one runs. Note the semicolon after the closing brace of the whole if chain — in Hare, control flow constructs are expressions, and statements are terminated with ;.

if as an Expression

Because if evaluates to a value, you can assign its result directly to a binding. This replaces the ternary operator (?:) found in C — Hare deliberately omits the ternary because expression-style if does the same job more readably. Both branches must produce a value of the same type.

Create a file named if_expression.ha:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

use fmt;

export fn main() void = {
	const a = 12, b = 27;

	// 'if' is an expression - it evaluates to a value
	const max = if (a > b) a else b;
	const min = if (a < b) a else b;

	fmt::printfln("max = {}, min = {}", max, min)!;

	// Hare has no ternary operator; expression-style if replaces it
	const parity = if (a % 2 == 0) "even" else "odd";
	fmt::printfln("{} is {}", a, parity)!;
};

When used as an expression, the branches can be single expressions without braces, as shown here. An if used this way must have an else branch, since the expression always needs a value to evaluate to.

Switch Statements

When you need to dispatch on the value of a single expression, switch is clearer than a long if/else if chain. Each case lists one or more values, and there is no fall-through — only the matching case runs. The bare case => acts as the default, catching any value not listed.

Create a file named switch.ha:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

use fmt;

export fn main() void = {
	const day = 3;

	switch (day) {
	case 1 =>
		fmt::println("Monday")!;
	case 2 =>
		fmt::println("Tuesday")!;
	case 3 =>
		fmt::println("Wednesday")!;
	case 4, 5 =>
		fmt::println("Almost the weekend")!;
	case =>
		fmt::println("Weekend")!;
	};
};

A switch must be exhaustive: every possible value has to be handled, which is why the default case => is included. The case 4, 5 => line shows how a single branch can match multiple values. Like if, switch is also an expression and can produce a value when every branch returns one.

Loops with for

Hare has a single loop keyword, for, that covers all looping needs. The most common form is the C-style loop with three clauses — an initializer, a condition, and an afterthought. Dropping the initializer and afterthought turns it into a while-style loop driven only by a condition.

Create a file named loops.ha:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

use fmt;

export fn main() void = {
	// C-style for loop: binding; condition; afterthought
	fmt::println("Counting up:")!;
	for (let i = 1; i <= 5; i += 1) {
		fmt::printfln("  i = {}", i)!;
	};

	// While-style: only a condition
	fmt::println("Counting down:")!;
	let n = 3;
	for (n > 0) {
		fmt::printfln("  n = {}", n)!;
		n -= 1;
	};
};

The variable i declared with let in the loop header is scoped to the loop body. The while-style form for (n > 0) keeps running as long as the condition holds. An infinite loop is simply for (true) { ... }, which you then exit with break.

Loop Control: break, continue, and Labels

Inside a loop, continue skips to the next iteration and break exits the loop entirely. For nested loops, Hare lets you label a loop and then break or continue a specific outer loop by name — avoiding the flag variables you’d otherwise need.

Create a file named loop_control.ha:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

use fmt;

export fn main() void = {
	// continue: skip even numbers
	fmt::println("Odd numbers under 10:")!;
	for (let i = 0; i < 10; i += 1) {
		if (i % 2 == 0) {
			continue;
		};
		fmt::printfln("  {}", i)!;
	};

	// break with a label to exit nested loops at once
	fmt::println("First pair where i * j > 6:")!;
	for :outer (let i = 1; i <= 3; i += 1) {
		for (let j = 1; j <= 3; j += 1) {
			if (i * j > 6) {
				fmt::printfln("  i = {}, j = {}", i, j)!;
				break :outer;
			};
		};
	};
};

The label :outer is attached to the outer loop, and break :outer jumps out of both loops at once when the condition is met. Without the label, break would only exit the inner loop. The same labeling works with continue :outer to skip to the next iteration of an outer loop.

Running with Docker

Since there is no dedicated Hare image on Docker Hub, we use Alpine Linux’s edge repository, which packages the Hare toolchain. The apk add step installs the compiler before running each program.

1
2
3
4
5
6
7
8

# Pull the Alpine edge image
docker pull alpine:edge

# Run the conditionals example
docker run --rm -v $(pwd):/code alpine:edge sh -c "apk add --no-cache hare > /dev/null 2>&1 && cd /code && hare run conditionals.ha"

# Run any other example by swapping the filename
docker run --rm -v $(pwd):/code alpine:edge sh -c "apk add --no-cache hare > /dev/null 2>&1 && cd /code && hare run loop_control.ha"

If you have Hare installed locally on a supported platform (Linux or a BSD), you can skip the container and run each file directly:

1

hare run conditionals.ha

Expected Output

Running conditionals.ha:

Grade: B

Running if_expression.ha:

max = 27, min = 12
12 is even

Running switch.ha:

Wednesday

Running loops.ha:

Counting up:
  i = 1
  i = 2
  i = 3
  i = 4
  i = 5
Counting down:
  n = 3
  n = 2
  n = 1

Running loop_control.ha:

Odd numbers under 10:
  1
  3
  5
  7
  9
First pair where i * j > 6:
  i = 3, j = 3

Key Concepts

• if is an expression - It evaluates to a value, so Hare has no separate ternary operator; use const max = if (a > b) a else b;
• Conditions must be boolean - Hare won’t accept a non-bool value as a condition, eliminating a common class of C bugs
• Semicolons terminate statements - Even after a closing brace, control flow constructs end with ; because they are expressions
• switch has no fall-through - Only the matching case runs, and switches must be exhaustive (use the bare case => as a default)
• A case can match multiple values - List them comma-separated, as in case 4, 5 =>
• One loop keyword, several forms - for (init; cond; step) for counting, for (cond) for while-style, and for (true) for infinite loops
• Labeled loop control - Attach a label like :outer to a loop, then break :outer or continue :outer to control nested loops directly

Next Steps

Continue to Functions to learn how to define and call functions in Hare, work with parameters and return values, and use recursion.