Gradual typing

Browser runtime: loading…

Add annotations where they help, lean on inference elsewhere, and use structural interfaces when you want typed boundaries without explicit implementation declarations. Each runnable snippet uses the same WASM engine as the playground.

Type annotations

Sapphire is gradually typed: you can add name: Type and -> Type where they help, and lean on inference elsewhere. The type checker enforces the annotations you choose; untyped code still runs.

types.spr

def clamp(value: Int, min: Int, max: Int) -> Int {
  if value < min {
    min
  } elsif value > max {
    max
  } else {
    value
  }
}

print clamp(5, 1, 10)   # 5
print clamp(-3, 1, 10)  # 1
print clamp(99, 1, 10)  # 10

# Annotations are optional — add them where you want safety

def abs(n: Int) -> Int {
  return -n if n < 0
  n
}

def factorial(n: Int) -> Int {
  return 1 if n <= 1
  n * factorial(n - 1)
}

print factorial(6)  # 720

Press Run to execute this snippet. ⌘↵ runs from the editor.

Interfaces and mixins

Interfaces are structural: a value satisfies an interface by implementing the required methods, without an explicit declaration. Modules package reusable methods and include(...) mixes them into a class.

interfaces.spr

interface Greeter {
  def greet -> String
}

module Friendly {
  def greet -> String {
    "hello from a mixin"
  }
}

class Person {
  include(Friendly)
}

def welcome(person: Greeter) -> String {
  person.greet + "!"
}

print welcome(Person.new)

Press Run to execute this snippet. ⌘↵ runs from the editor.