Real types.
One binary.
Isolated heaps.

class Box[T]
  def initialize(value: T)
    @value = value
  end

  def value() -> T = @value
  def map[U](transform: Callable[[T], U]) -> Box[U] = Box[U].new(transform(@value))
end

def label(n: Int) -> String = "item #{n}"
def double(n: Int) -> Int = n * 2

box = Box.new(21)          # Box[Int]: T inferred from the argument
names = box.map(label)     # Box[String]: U inferred from label's signature
puts(double(box.value()))
double(names.value())      # a String where an Int is required

interface Named
  def name() -> String
end

struct City(name: String, population: Int)
end
struct Tag[T](name: T)
end

# No "implements": anything with a matching name() -> String is Named.
def introduce(thing: Named) -> String = "This is #{thing.name()}."

puts(introduce(City.new("Oslo", 717_710)))
puts(introduce(Tag.new("urgent")))     # Tag[String] has name() -> String
introduce(Tag.new(42))                 # Tag[Int] does not

struct Circle(radius: Float)
end
struct Rect(width: Float, height: Float)
end
struct Triangle(base: Float, height: Float)
end

def area(shape: Circle | Rect | Triangle) -> Float
  case shape
  when Circle{radius: r} then 3.14159 * r * r
  when Rect{width: w, height: h} then w * h
  end
end

class Model
  def self.find(id: Int) -> Self | Nil
    id > 0 ? self.new() : nil
  end

  def touch() -> Self
    @touched_at = Time.now()
    self
  end
end

class Author < Model
  def greet() -> String = "hello from an Author"
end
class Book < Model
end

def welcome(author: Author) -> String = author.touch().greet()

author = Author.find(1)        # Author | Nil, not Model | Nil
if author != nil
  puts(welcome(author))        # narrowed to Author
end
book = Book.find(1)
if book != nil
  welcome(book)                # a Book is not an Author
end

def parse(text) = text.to_i()          # no annotations: as dynamic as a script
def half(n: Int) -> Int = n / 2

puts(half(parse("84")))
settings = {"port": "8080"}
half(settings["port"])                 # unknown until it runs, so checked then

struct Player(name: String, level: Int)
end

def describe(event) -> String
  case event
  when ["join", Player{name: name, level: 1}]
    "#{name} joined for the first time"
  when ["join", Player{name: name}]
    "#{name} is back"
  when {"score": points, "player": Player{name: name}} if points >= 100
    "#{name} hit #{points}!"
  when {"score": points, **rest}
    "#{points} points (#{rest.length()} more fields)"
  else
    "unknown event"
  end
end

puts(describe(["join", Player.new("Ada", 1)]))
puts(describe(["join", Player.new("Grace", 7)]))
puts(describe({"score": 120, "player": Player.new("Ada", 1)}))
puts(describe({"score": 40, "team": "red", "round": 3}))

def worker(jobs, results)
  loop do
    job = jobs.receive()
    break if job == nil
    raise "bad job" if job == 3      # crashes; the supervisor restarts it
    results.send(job * job)
  end
end

jobs = Channel.new(16)
results = Channel.new(16)
stop = Channel.new(1)

sup = Supervisor.new()
sup.restart_policy({"max_restarts": 3, "within_ms": 1000, "backoff_ms": 10})
child = sup.add_child(worker, jobs, results)
[1, 2, 3, 4].each() do |n| jobs.send(n) end

loop do
  picked = Channel.select([stop, results], Time.monotonic() + 0.5)
  break if picked == nil || picked[0] == 0
  puts("result: #{picked[1]}")
end
jobs.close()
sup.join()
puts("restarts: #{sup.restart_count(child)}, last: #{sup.last_error(child)}")

def counter()
  total = 0
  loop do
    step = Fiber.yield(total)      # hand back the total, wait for the next step
    total += step
  end
end

running = Fiber.new(counter)
puts(running.resume(0))
puts(running.resume(10))
puts(running.resume(5))

puts("sum: #{(1..10).sum()}")      # plain computation always runs

begin
  text = File.read("/etc/os-release")
  puts("read #{text.length()} bytes")
rescue error: SandboxError
  puts("denied: #{error.message()}")
end

i = 0
loop do                            # a runaway loop
  i += 1
end

def even?(n: Int) -> Bool = n == 0 ? true : odd?(n - 1)
def odd?(n: Int) -> Bool = n == 0 ? false : even?(n - 1)

puts(even?(1_000_000))