Sound Types

// TypeScript - this compiles but crashes at runtime
const user: User = JSON.parse(response) // No guarantee it's a User!

// MetaScript - type-safe parsing
const user = User.parse(response) // Returns Result<User, ParseError>

type Result<T, E> =
  | { ok: true, value: T }
  | { ok: false, error: E }

function divide(a: number, b: number): Result<number, string> {
  if (b === 0) {
    return { ok: false, error: "Division by zero" }
  }
  return { ok: true, value: a / b }
}

// Compiler enforces handling both cases
const result = divide(10, 2)
if (result.ok) {
  console.log(result.value) // Compiler knows this is number
} else {
  console.error(result.error) // Compiler knows this is string
}

@derive(Eq, Hash)
class Point {
  x: number
  y: number
}

const p1 = new Point(1, 2)
const p2 = new Point(1, 2)
console.log(p1.equals(p2)) // true

class Stack<T> {
  private items: T[] = []

  push(item: T): void {
    this.items.push(item)
  }

  pop(): T | undefined {
    return this.items.pop()
  }
}

const numbers = new Stack<number>()
numbers.push(42)
numbers.push("oops") // Compile error!

// Type inferred as number[]
const numbers = [1, 2, 3]

// Type inferred as (x: number) => number
const double = (x) => x * 2

// Return type inferred as string
function greet(name: string) {
  return `Hello, ${name}!`
}

trait Serializable {
  toJSON(): string
  static fromJSON(json: string): Self
}

@derive(Serializable)
class User {
  name: string
  email: string
}

// Works with any Serializable
function save<T: Serializable>(item: T): void {
  localStorage.setItem("data", item.toJSON())
}

function process(value: string | number) {
  if (typeof value === "string") {
    // Compiler knows value is string here
    console.log(value.toUpperCase())
  } else {
    // Compiler knows value is number here
    console.log(value.toFixed(2))
  }
}

function findUser(id: string): User | null {
  return db.users.find(u => u.id === id)
}

const user = findUser("123")
// user.name // Compile error! Might be null

if (user) {
  user.name // OK - compiler knows it's User
}

// Or use optional chaining
user?.name // Returns string | undefined