Zero Shapes: Defining Struct-Like Records

Declaring a Shape

A shape is a record type with named, typed fields:

shape Point {
    x: i32,
    y: i32,
}

Pieces:

• shape introduces the declaration.
• Point is the type's name.
• The braces enclose a list of fields, each name: Type.

That declaration adds a new type called Point to the current scope. Anywhere you can use a built-in type like i32, you can now also use Point.

Constructing a Shape Value

Create an instance with a struct-literal expression:

let point = Point { x: 40, y: 2 }

The literal names the shape and assigns each field. Every field must be present — Zero doesn't silently default missing fields to zero or null. If you forget one, the compiler tells you so:

{
    "code": "FLD002",
    "message": "missing field: y",
    "line": 4
}

(The exact error code may vary; the principle of "no implicit defaults" is the constant.)

You can read or annotate the type explicitly if you want it to be visible:

let point: Point = Point { x: 40, y: 2 }

Reading Fields

Field access uses dot syntax:

let point = Point { x: 40, y: 2 }
let xVal  = point.x
let yVal  = point.y

point.x reads the x field. There's no get_x() method — fields are plain data.

A Full Worked Example

This is the canonical point.0 example from the language's repository — click Run to try it:

shape Point {
    x: i32,
    y: i32,
}

fun sum(point: Point) -> i32 {
    return point.x + point.y
}

pub fun main(world: World) -> Void raises {
    let point = Point { x: 40, y: 2 }
    let total = sum(point)
    if total == 42 {
        check world.out.write("point works\n")
    } else {
        check world.out.write("point broke\n")
    }
}

Walk through it from the top:

1. Declare a Point shape with two i32 fields.
2. Define a sum function that takes a Point and returns the sum of its fields.
3. In main, construct a Point, call sum, and compare the result.

Three steps, three shapes-related ideas (declare, construct, access), and one effect — the check world.out.write(...) at the end. Notice that sum doesn't touch World. It's a pure function over data, and the signature makes that obvious.

Shapes with Nested Fields

A shape can hold values of any type, including other shapes:

shape Range {
    start: i32,
    end: i32,
}

shape Segment {
    label: String,
    range: Range,
}

let seg = Segment {
    label: "warmup",
    range: Range { start: 0, end: 10 },
}

Field access chains as you'd expect:

let len = seg.range.end - seg.range.start

Generic Shapes

When a shape's fields should be type-polymorphic, declare type parameters in angle brackets:

shape Pair<T, U> {
    left: T,
    right: U,
}

Instances pin the parameters to concrete types:

let intBytePair: Pair<i32, u8> = Pair { left: 40, right: 2_u8 }
let words: Pair<String, String> = Pair { left: "hello", right: "world" }

A type alias can shorten a common parameterization:

type BytePair = Pair<u8, u8>

let bytes: BytePair = Pair { left: 1_u8, right: 2_u8 }

Generics covers type parameters in more depth — including on functions, not just shapes.

What Shapes Are Not

A few things you might expect from a "struct" in another language that shapes deliberately don't include:

• No methods. A shape declaration is just data. Behavior lives in free functions that take the shape as a parameter. This mirrors the same separation between data and effects you see in functions.
• No inheritance. Shapes don't extend other shapes. If you want shared structure, factor it into a common field or build a sum type with choice.
• No implicit constructors or destructors. Construction is the struct-literal expression. Cleanup is explicit — when the standard library exposes resources that need disposal, it's done through capability-style APIs rather than hidden RAII.
• No private fields. A shape's fields are all accessible to code that can see the shape's type. Visibility is at the type level, not the field level.

The pattern is: shapes are simple, predictable record types, and you build everything else from them.

When to Use a Shape vs. a Choice

Quick guide:

• Use a shape when a value has all of these fields together. A Point always has both an x and a y.
• Use a choice when a value is one of several alternatives. A Result is either an ok or an err.
• Use an enum when the alternatives carry no extra data — they're just labels. Days of the week, simple states.

These three building blocks — shape (and), choice (or), enum (or with no payload) — cover almost every data-modeling need.

Next: Generics

You've seen Pair<T, U> show up in passing. The next doc, generics, explains how type parameters work on both shapes and functions, including the patterns that appear throughout the Zero standard library.