Emela

tour/
├── Pome.toml
└── src/
    ├── main.emel
    └── email.emel

# A tour of the pure part of the language. `dbg` prints to stderr.
import Email

# Variants carry labelled fields.
enum Shape {
  Circle(radius: Float)
  Rect(width: Float, height: Float)
}

# A record type.
type Todo(id: Int, title: String, done: Bool)

fn area(shape: Shape) -> Float {
  shape match {
    Circle(radius:)       -> 3.14 * radius * radius
    Rect(width:, height:) -> width * height
  }
}

# Self tail calls compile to loops, so deep recursion is fine.
fn sum(xs: List[Int], acc: Int) -> Int {
  xs match {
    []          -> acc
    [x, ..rest] -> sum(rest, acc + x)
  }
}

fn fizzbuzz(n: Int) -> String {
  (n % 3, n % 5) match {
    (0, 0) -> "FizzBuzz"
    (0, _) -> "Fizz"
    (_, 0) -> "Buzz"
    _      -> Int.to_string(n)
  }
}

fn main() {
  todo = Todo(id: 1, title: "Write docs", done: False)
  finished = Todo(done: True, ..todo)
  dbg(finished) # Todo(id: 1, title: "Write docs", done: True)

  dbg(area(Rect(width: 2.0, height: 3.0))) # 6.0

  dbg(sum(List.range(1, 10001), 0)) # 50005000

  # "1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz"
  List.range(1, 16)
    |> List.map(fizzbuzz)
    |> String.join(" ")
    |> dbg

  dbg(Email.parse("alice@example.com") |> Option.map(Email.to_string)) # Some("alice@example.com")
  dbg(Email.parse("not an email")) # None
}

# Run with `emela test`.
@test
fn fizzbuzz_of_15() {
  assert fizzbuzz(15) == "FizzBuzz"
}

# `opaque` hides the constructor and fields outside this module,
# so every Email goes through `parse`.
pub opaque type Email(value: String)

pub fn parse(input: String) -> Option[Email] {
  if String.contains(input, "@") { Some(Email(value: input)) } else { None }
}

pub fn to_string(email: Email) -> String {
  email.value
}

import Std.Console.{Console, SystemConsole}

fn greet(name: String) {
  console = use Console
  console.print_line("Hello, #{name}!")
}

fn main() {
  with SystemConsole {
    console = use Console
    console.print_line("hi")
    List.map(["Emela", "world"], greet)
    console.print_error_line("done")
  }
}

# Typed errors and effects. `fails` and `use` are inferred unless written.

import Std.Console.{Console, SystemConsole}

error NotFound(id: Int)
error Invalid(reason: String)

type User(id: Int, name: String)

# An effect declares operations; handlers implement them.
effect Users {
  fn find(id: Int) -> User fails NotFound
}

handler SampleUsers: Users {
  fn find(id) {
    id match {
      1 -> User(id: 1, name: "alice")
      2 -> User(id: 2, name: "bob")
      _ -> fail NotFound(id:)
    }
  }
}

# Inferred: fails NotFound | Invalid, use Users.
fn greeting(id: Int) {
  if id < 0 { fail Invalid(reason: "negative id") }
  user = (use Users).find(id)
  "Hello, #{user.name}!"
}

# `escape` handles NotFound; Invalid still propagates.
fn greeting_or_guest(id: Int) {
  greeting(id) escape {
    NotFound(_) -> "Hello, guest!"
  }
}

fn main() {
  with SystemConsole, SampleUsers {
    console = use Console
    console.print_line(greeting_or_guest(1))
    console.print_line(greeting_or_guest(3))
    console.print_line(greeting_or_guest(-1))
  }
}

# Tests swap the handler instead of mocking.
handler NoUsers: Users {
  fn find(id) { fail NotFound(id:) }
}

@test
fn unknown_users_get_the_guest_greeting() {
  with NoUsers {
    assert greeting_or_guest(1) == "Hello, guest!"
  }
}

# Suspending effects. `sleep` is a `suspend fn`: calls to it look like any other
# call, and the handler decides when the caller resumes.

import Std.Console.{Console, SystemConsole}
import Std.Clock.{Clock, SystemClock}
import Std.Instant.{Instant}

fn countdown(n: Int) {
  console = use Console
  clock = use Clock
  List.map(List.range(0, n), fn(i) {
    clock.sleep(100)
    console.print_line("#{n - i}")
  })
  console.print_line("liftoff")
}

fn main() {
  with SystemConsole, SystemClock {
    countdown(3)
  }
}

# Resumes on the spot, so tests do not wait and need no `Async`.
handler InstantClock: Clock {
  suspend fn sleep(ms, resume) { resume(()) }
  fn now() { Instant.from_unix_milliseconds(0) }
}

@test
fn countdown_does_not_wait() {
  with SystemConsole, InstantClock {
    countdown(3)
  }
}

(_, lines) = State.run([], fn() {
  with TestConsole {
    greet("a")
    greet("b")
  }
})
# lines == ["hello, a", "hello, b"]

fn main() {
  with SystemConsole, SystemClock {
    console = use Console
    # The waits overlap: the second fetch ends first.
    (a, b) = Fiber.both(fn() { fetch(1, 200) }, fn() { fetch(2, 100) })
    console.print_line("both: #{a}, #{b}")
    names = Fiber.map([3, 4, 5], fn(id) { fetch(id, 100 * (6 - id)) })
    console.print_line("map: #{names}")
    first = Fiber.race([fn() { fetch(6, 300) }, fn() { fetch(7, 100) }])
    console.print_line("race: #{first}")
    late = Fiber.timeout(100, fn() { fetch(8, 1000) })
    console.print_line("timeout: #{late}")
    # A failing child interrupts its siblings, and the error reaches the scope.
    failed = Fiber.scope(fn() {
      ok = Fiber.fork(fn() { fetch(9, 1000) })
      bad = Fiber.fork(fn() { fetch(-1, 100) })
      "#{Fiber.join(ok)} #{Fiber.join(bad)}"
    }) escape {
      NotFound(id:) -> "not found: #{id}"
    }
    console.print_line(failed)
  }
}

## Appends `text` as a line to `notes/<day>.txt` and returns the number of lines in it.
fn note(day: String, text: String) {
  fs = use FileSystem
  fs.create_directory(DIR)
  path = Path.join(DIR, "#{day}.txt")
  fs.append_text(path, "#{text}\n")
  String.split(fs.read_text(path), "\n") |> List.filter(fn(l) { l != "" }) |> List.length
}

## The text of `notes/<day>.txt`, or a message if there is none.
fn show(day: String) {
  (use FileSystem).read_text(Path.join(DIR, "#{day}.txt")) escape {
    FileNotFound(path:) -> "no notes in #{path}"
  }
}

fn search_request(query: String, page: Int) -> Request {
  query_string = Http.encode_query([("q", query), ("page", Int.to_string(page))])
  Http.request(Get, "#{BASE}/search?#{query_string}") |> Http.add_header("accept", "text/plain")
}

fn first_result(query: String) {
  first_line(query) escape {
    UnexpectedStatus(status:, body: _) -> "status #{status}"
    ConnectionFailed(url: _, message:) -> "unreachable: #{message}"
  }
}

@test
fn a_404_is_not_a_failure() {
  server = TestServer(respond: fn(req, n) { Some(Http.response(404, "")) }, sent: [])
  (text, after) = State.run(server, fn() { with TestHttp { first_result("x") } })
  assert text == "status 404"
  assert List.length(after.sent) == 1
}

syntax → resolve → types → core ──────→ codegen-js ───┐
   ↓                         └─→ lir → codegen-wasm ──┤
  fmt                                                 ↓
                                        driver → lsp → cli