Chains that cover a type

type Shape {
	Circle    { radius: Int }
	Rectangle { width: Int, height: Int }
	Point
}

func area(shape: Shape): Int {
	if shape is Shape.Circle(r) {
		return 3 * r * r
	} else if shape is Shape.Rectangle(w, h) {
		return w * h
	} else if shape is Shape.Point {
		return 0
	}
	// No `else`, and none needed: the three variants are the whole of Shape.
}

func size(found: Result<Int, Str>): Int {
	if found is Result.Ok(n) {
		return n
	} else if found is Result.Error(_) {
		return -1
	}
}

proc main(): void {
	echo area(Shape.Rectangle(3, 4))
	echo size(Result.Error("missing"))
}

type Route {
	Page { segments: Str[dyn] }
	Missing
}

// Every value a Result<Route, Str> can be is taken below, so the
// chain ends the function and nothing has to follow it.
func kind(r: Result<Route, Str>): Str {
	if r is Result.Ok(Route.Page([])) {
		return "an empty page"
	} else if r is Result.Ok(Route.Page([_, ...more])) {
		return "a page of {len(more) + 1}"
	} else if r is Result.Ok(Route.Missing) {
		return "a missing page"
	} else if r is Result.Error(_) {
		return "no page at all"
	}
}

proc main(): void {
	echo kind(Result.Ok(Route.Page(["a", "b"])))   // a page of 2
	echo kind(Result.Ok(Route.Missing()))          // a missing page
	echo kind(Result.Error("offline"))             // no page at all
}