Classes and traits

Classes support single inheritance with constructors and field defaults. Traits define shared behaviour across unrelated types. Both integrate with the type system.

Classes

The constructor method is named init. Instantiate with ClassName(args).

scratch.xs

class Animal {
  name = ""
  sound = "..."

  fn init(self, name) {
    self.name = name
  }

  fn speak(self) {
    return "{self.name} says {self.sound}"
  }
}

let cat = Animal("Cat")
cat.sound = "meow"
println(cat.speak())             -- Cat says meow

Inheritance

Use class Dog : Animal to extend a class. Call super.init(...) to initialize parent fields. Methods can be overridden freely.

scratch.xs

class Animal {
  name = ""
  sound = "..."

  fn init(self, name) {
    self.name = name
  }

  fn speak(self) {
    return "{self.name} says {self.sound}"
  }
}

class Dog : Animal {
  fn init(self, name) {
    super.init(name)
    self.sound = "woof"
  }

  fn fetch(self) {
    return "{self.name} fetches the ball"
  }
}

let d = Dog("Rex")
println(d.speak())               -- Rex says woof
println(d.fetch())               -- Rex fetches the ball

Traits

Traits define a contract: a set of method signatures a type must implement. A type can implement multiple traits.

scratch.xs

trait Describe {
  fn describe(self) -> str
}

struct Dog { name, breed }
struct Car { make, year }

impl Describe for Dog {
  fn describe(self) -> str {
    return "{self.name} the {self.breed}"
  }
}

impl Describe for Car {
  fn describe(self) -> str {
    return "{self.year} {self.make}"
  }
}

let d = Dog { name: "Rex", breed: "Shepherd" }
println(d.describe())            -- Rex the Shepherd

let car = Car { make: "Volvo", year: 2024 }
println(car.describe())          -- 2024 Volvo

Default methods

Traits can provide default implementations. Types only need to override them when they want different behaviour.

scratch.xs

trait Greet {
  fn hello(self) -> str {
    return "hello from {self.name}"
  }
  fn goodbye(self) -> str      -- no default: must implement
}

struct Person { name }

impl Greet for Person {
  -- hello() uses the default implementation
  fn goodbye(self) -> str { return "bye from {self.name}" }
}

let p = Person { name: "Alice" }
println(p.hello())               -- hello from Alice
println(p.goodbye())             -- bye from Alice

Super traits and associated types

A trait can declare that implementing it also requires another trait. Traits can also declare associated type names.

trait Display {
  fn display(self) -> str
}

-- PrettyPrint requires Display to be implemented first
trait PrettyPrint: Display {
  fn pretty(self) -> str
}

-- associated type
trait Iterator {
  type Item
  fn next(self) -> Item
}

The semantic analyser enforces trait implementations: missing required methods, parameter count mismatches, and return type mismatches are all caught before execution.

When to use which

Use structs + traits when you have plain data that different parts of the codebase should process in different ways. The separation of data and behaviour keeps things composable.

Use classes when you need encapsulated mutable state, a natural inheritance hierarchy, or are modelling entities with identity (database rows, UI components, game objects).

Edit this page on GitHub ->