Interface value

// A variable can have an interface as its type. `let shape: Shape = wheel;` makes an interface
// value: it holds a copy of the circle, together with a note of which type that copy is.
//
// A call such as `shape.Area()` follows the note to Circle's own `Area`. Put a rectangle in the
// same variable and the very same call runs Rectangle's `Area` instead. Which function runs is
// decided while the program runs, by the value inside, not by anything written at the call. That
// is called dynamic dispatch, and it is what lets values of different types share one variable,
// one array, or one loop.
import Io::PrintLine;

interface Shape {
    func Area() -> float64;
    func Name() -> char8[..];
}

struct Circle {
    radius: float64;
}

struct Rectangle {
    width: float64;
    height: float64;
}

extend Circle : Shape {
    func Area(self: &Circle) -> float64 {
        return 3.14 * self.radius * self.radius;
    }

    func Name(self: &Circle) -> char8[..] {
        return "circle";
    }
}

extend Rectangle : Shape {
    func Area(self: &Rectangle) -> float64 {
        return self.width * self.height;
    }

    func Name(self: &Rectangle) -> char8[..] {
        return "rectangle";
    }
}

func Main() -> int {
    let wheel = Circle { radius: 2.0 };
    let door = Rectangle { width: 1.0, height: 2.0 };

    // The annotation is what turns a circle into a Shape.
    var shape: Shape = wheel;
    PrintLine("holding a {} with area {}", shape.Name(), shape.Area());

    // Same variable, different type inside, so the same calls now run Rectangle's code.
    shape = door;
    PrintLine("holding a {} with area {}", shape.Name(), shape.Area());

    // A circle and a rectangle cannot share an array: `let shapes = [wheel, door];` is refused
    // with "array element 2 has type 'Rectangle', but element 1 established element type
    // 'Circle'". Two Shapes can, and the annotation makes each element a Shape, as it did above.
    let shapes: Shape[2] = [wheel, door];
    var total = 0.0;
    for each in shapes {
        total += each.Area();
    }
    PrintLine("total area {}", total);

    // An interface value holds a copy. Changing the original afterwards leaves the copy alone.
    var balloon = Circle { radius: 1.0 };
    let photo: Shape = balloon;
    balloon.radius = 2.0;
    PrintLine("the balloon's area is {}, the photo's is {}", balloon.Area(), photo.Area());

    // Only what Shape promises can be reached through it. `shape.width` is rejected even while a
    // rectangle is inside: "interface type 'Shape' has no member 'width'".
    return 0;
}