examples/shapes/

# What a pair of corners measures.
#
# **`use geom/point` and not `use point`** — and `point.hero` is the file
# right next to this one. A `use` path is read from the directory of the
# file you compile, so a neighbour has no shorter spelling than a stranger;
# the reward is that this line means the same thing wherever it is copied
# to, which is what `render/ascii.hero` does with it.
use geom/point

function rect(a: point.Point, b: point.Point) -> i64
    return point.span(from: a, to: b) * height(a: a, b: b)

function perimeter(a: point.Point, b: point.Point) -> i64
    return 2 * (point.span(from: a, to: b) + height(a: a, b: b))

# The other side, measured the same way the first one is — through the
# module that owns the idea of a distance rather than by subtracting here.
function height(a: point.Point, b: point.Point) -> i64
    swapped_a = point.Point(x: a.y, y: a.x)
    swapped_b = point.Point(x: b.y, y: b.x)
    return point.span(from: swapped_a, to: swapped_b)

test "a rectangle of no width has no area and a perimeter twice its height"
    a = point.Point(x: 2, y: 0)
    b = point.Point(x: 2, y: 5)
    assert rect(a: a, b: b) == 0
    assert perimeter(a: a, b: b) == 10

# A point, and the one measurement everything else is built from.
#
# This module names nothing: it is the leaf of the program's little graph,
# which is why it is the one every other file reaches for. It sits in
# `geom/` and is spelled `geom/point` from every file that uses it,
# including the one beside it.

record Point
    x: i64
    y: i64

# The distance along x, never negative. `span` rather than `width` because a
# pair of points has no orientation until somebody gives it one.
function span(from: Point, to: Point) -> i64
    dx = to.x - from.x

    if dx < 0
        return 0 - dx
    return dx

test "a span is the same in both directions"
    a = Point(x: 1, y: 0)
    b = Point(x: 5, y: 0)
    assert span(from: a, to: b) == 4
    assert span(from: b, to: a) == 4

# Drawing, in a different directory from the geometry it draws.
#
# The `use` line below is character for character the one in `main.hero` and
# in `geom/area.hero`. Three files at two depths, one spelling: that is the
# whole of what the root base buys, and it is why copying an import from a
# neighbouring file is the correct move here rather than the classic mistake.
use geom/point

# `use scale` — and there is a `render/scale.hero` BESIDE this file. This line
# reaches the ROOT's `scale.hero`, because every `use` starts at the directory
# of the file you compile. `scale.hero`'s own doc is where that is explained.
use scale

function bar(width: i64) -> str
    origin = point.Point(x: 0, y: 0)
    tip = point.Point(x: width, y: 0)
    return "#".repeat(point.span(from: origin, to: tip).to_u64().must())

function frame(width: i64, height: i64) -> str
    rows: [str] @= [bar(width: width)]
    at: i64 @= 1

    while at < height
        rows @ rows.push(bar(width: width))
        at @ at + 1

    return rows.join("\n")

test "a bar is as wide as the span it is given, and a frame repeats it"
    assert bar(width: 3) == "###"
    assert bar(width: 0) == ""
    assert frame(width: 2, height: 2) == "##\n##"

# The root's factor, reached from a subdirectory by a bare `use`.
function scaled(width: i64) -> i64
    return width * scale.factor()

test "the bare use reached the root, so the factor is ten"
    assert scaled(width: 2) == 20

# The neighbour that is NOT reached by a bare `use scale`.
#
# `render/ascii.hero` sits beside this file and says `use scale`; that line
# names the root's `scale.hero`, not this one. To reach this module a file
# writes `use render/scale`, from anywhere in the program, because a path
# starts at the directory of the file you compile.
#
# `main.hero` does exactly that, so both modules are live and the program's
# output tells them apart: 10 from the root, 3 from here. If the resolution
# ever flips, `main.expected` changes and the corpus goes red.

function factor() -> i64
    return 3

test "the neighbour's scale is three"
    assert factor() == 3

# A root module with a name a subdirectory also uses — deliberately.
#
# **This file exists to pin the sharp edge of the rule, in a program that
# runs** (panels 099 R1, 100 R5, 101 R5). `render/ascii.hero` says
# `use scale`, and there is a `render/scale.hero` sitting right beside it.
# The `use` reaches THIS file, because every `use` starts at the directory of
# the file you compile — never beside the file that writes the line.
#
# It is correct and it is silent: no diagnostic fires, because the program is
# exactly what the rule says it is. The loud half exists too — delete this
# file and the same line becomes `unknown_module`, naming the directory it
# looked in — so the compiler teaches the rule the moment it can. What it
# cannot do is guess which file you meant, and a refusal here would leave a
# file inside `render/` with no way at all to name the root's `scale`.
#
# The number is 10 rather than 1 so a wrong resolution changes the program's
# output instead of hiding inside it.

function factor() -> i64
    return 10

test "the root's scale is ten"
    assert factor() == 10