Lisette
A love letter to Go
written in Rust

Lisette is a little language inspired by Rust that compiles to Go, combining compile-time safety, expressive syntax and Go's ecosystem.

algebraic data types
pattern matching
no nil
immutability
readable Go
extensive tooling

Quickstart

import "go:encoding/json"
import "go:fmt"
import "go:os"

fn load_config(path: string) -> Result<Cfg, error> {
  let data = os.ReadFile(path)?
  let mut config = Cfg { port: 8080, tls: true }
  json.Unmarshal(data, &config)?
  Ok(config)
}

fn main() {
  match load_config("app.json") {
    Ok(config) => start(config),
    Err(e) => fmt.Println("error:", e),
  }
}

Expressive

Syntactically similar to Rust, conceptually simpler

enum Message {
  Ready,
  Write(string),
  Move { x: int, y: int },
}

fn handle(msg: Message) -> string {
  match msg {
    Ready => "ready",
    Write(text) => f"wrote: {text}",
    Move { x, y } => f"move to ({x}, {y})",
  }
}

import "go:math"

struct Point {
  x: float64,
  y: float64,
}

impl Point {
  fn distance(self, other: Point) -> float64 {
    let (dx, dy) = (self.x - other.x, self.y - other.y)
    math.Sqrt(dx*dx + dy*dy)
  }
}

Safe

Go runtime failures, caught at compile time

  ✕ match is not exhaustive
   ╭─[example.lis:5:3]
 4 │ fn should_alert(s: Severity) -> bool {
 5 │   match s {
   ·   ───┬───
   ·      ╰── not all patterns covered
 6 │     Severity.Low => false,
 7 │     Severity.High => true,
 8 │   }
 9 │ }
   ╰────
  help: Handle the missing case Severity.Critical,
        e.g. Severity.Critical => { ... }

✕ nil is not supported
   ╭─[users.lis:5:12]
 3 │ fn find(name: string) -> Option<User> {
 4 │   if name.is_empty() {
 5 │     return nil
   ·            ─┬─
   ·             ╰── does not exist
 6 │   }
 7 │   lookup(name)
 8 │ }
   ╰────
  help: Absence is encoded with Option<T> in Lisette. Use
        None to represent absent values

▲ Result is silently discarded
    ╭─[files.lis:9:3]
  8 │ fn shutdown() {
  9 │   cleanup()
    ·   ────┬────
    ·       ╰── failure will go unnoticed
 10 │   fmt.Println("done")
 11 │ }
    ╰────
  help: Handle this Result with ? or match, or explicitly
        discard it with let _ = ...

▲ Option is silently discarded
    ╭─[cache.lis:10:3]
  9 │ fn warm(c: Cache) {
 10 │   hit_count(c, "home")
    ·   ──────────┬─────────
    ·             ╰── absence will go unnoticed
 11 │   fmt.Println("warmed")
 12 │ }
    ╰────
  help: Handle this Option with ? or match, or explicitly
        discard it with let _ = ...

▲ Lost query mutation
   ╭─[link.lis:4:3]
 3 │ fn tag(u: Ref<url.URL>, value: string) {
 4 │   u.Query().Set("tag", value)
   ·   ─────────────┬─────────────
   ·                ╰── mutates a discarded copy
 5 │ }
   ╰────
  help: URL.Query returns a fresh copy, so this Set has no
        effect. Bind it, mutate it, then assign
        values.Encode() to RawQuery

✕ File permission written in decimal
   ╭─[perms.lis:4:24]
 3 │ fn lock() -> Result<(), error> {
 4 │   os.Chmod("app.conf", 600)
   ·                        ─┬─
   ·                         ╰── decimal 600 is octal 0o1130
 5 │ }
   ╰────
  help: File permissions are conventionally written in
        octal. Use a 0o prefix (for example 0o644) so the
        bits line up with the rwx triples

▲ Appending to a zero-filled slice
   ╭─[buffer.lis:2:13]
 1 │ fn ids() -> Slice<int> {
 2 │   let out = Slice.make<int>(3)
   ·             ─────────┬────────
   ·                      ╰── already all zeros
 3 │   out.append(7)
   ·   ──────┬──────
   ·         ╰── append adds element 4 here
 4 │ }
   ╰────
  help: For an empty slice with room for 3, use
        Slice.new<int>().reserve(3)

✕ Duplicate map key
   ╭─[flags.lis:3:14]
 1 │ /// Feature flags and their default values.
 2 │ fn defaults() -> Map<string, int> {
 3 │   Map.from([("debug", 1), ("debug", 0)])
   ·              ───┬───       ───┬───
   ·                 │             ╰── overwrites first
   ·                 ╰── key for first entry
 4 │ }
   ╰────
  help: Map.from keeps the last entry for a key, so the
        earlier entry never reaches the map. Remove one of
        the two entries

● Regexp recompiled on every iteration
   ╭─[scan.lis:7:34]
 6 │   for l in lines {
 7 │     let hit = regexp.MatchString("^lis", l)?
   ·                                  ───┬──
   ·                                     ╰── recompiled
 8 │     if hit {
   ╰────
  help: Compile the pattern once outside the loop and
        reuse it: regexp.MustCompile, or regexp.Compile to
        keep the error

● Unnecessary eager evaluation
    ╭─[scan.lis:16:30]
 15 │ fn caption(name: Option<string>) -> string {
 16 │   let shown = name.unwrap_or(fallback())
    ·                              ─────┬────
    ·                                   ╰── always evaluated
 17 │   strings.TrimSpace(shown)
 18 │ }
    ╰────
  help: Replace .unwrap_or(...) with .unwrap_or_else(...)
        so the fallback runs only when needed

● Filtered slice thrown away
   ╭─[jobs.lis:4:3]
 3 │ fn pending(jobs: Slice<Job>) -> Option<Job> {
 4 │   jobs.filter(|j| j.state == "pending").get(0)
   ·   ──────────────────────┬─────────────────────
   ·                         ╰── can use find
 5 │ }
   ╰────
  help: filter(...).get(0) builds the whole filtered
        slice. Use jobs.find(|j| j.state == "pending") to
        return the first match directly

● Inefficient string comparison
    ╭─[scan.lis:27:3]
 25 │   let left = strings.TrimSpace(a)
 26 │   let right = strings.TrimSpace(b)
 27 │   strings.ToLower(left) == strings.ToLower(right)
    ·   ───────────────────────┬───────────────────────
    ·                          ╰── can use strings.EqualFold
 28 │ }
    ╰────
  help: Use strings.EqualFold(left, right) to compare
        case-insensitively in one call

LSP support for: VSCode Neovim Zed Helix GoLand

Interoperable

Import Go packages, stay on Go's runtime

import "go:os"

fn server_url() -> string {
  let scheme = os.LookupEnv("HTTPS")
    .filter(|s| s == "1")
    .map(|_| "https")
    .unwrap_or("http")

  let host = os.LookupEnv("HOST")
    .unwrap_or("localhost")

  let port = os.LookupEnv("PORT")
    .unwrap_or("8080")

  scheme + "://" + host + ":" + port
}

os.d.lis

// func Getenv(key string) string
pub fn Getenv(key: string) -> string

// func LookupEnv(key string) (string, bool)
pub fn LookupEnv(key: string) -> Option<string>

// func Open(name string) (*File, error)
pub fn Open(name: string) -> Result<Ref<File>, error>

// func Remove(name string) error
pub fn Remove(name: string) -> Result<(), error>

// func Hostname() (string, error)
pub fn Hostname() -> Result<string, error>

Get started

Little to learn, and the rest is Go

Quickstart

learn-lisette

src/main.lis

import "go:errors"
import "go:fmt"
import "go:strconv"
import "go:strings"
import "go:time"

import "display"
import "models"
import "store"

pub fn add(args: Slice<string>) -> Result<(), error> {
  let Some(title) = args.get(2) else {
    return Err(errors.New(
      "usage: add <title> [--priority low|medium|high] [--tags a,b,c]",
    ))
  }

  let mut priority = models.Priority.Medium
  let mut tags: Slice<string> = []

  let mut i = 3
  while i < args.length() {
    match args[i] {
      "--priority" => {
        let Some(val) = args.get(i + 1) else {
          return Err(errors.New("--priority requires a value"))
        }
        priority = models.parse_priority(val)?
        i += 2
      },
      "--tags" => {
        let Some(val) = args.get(i + 1) else {
          return Err(errors.New("--tags requires a value"))
        }
        tags = strings.Split(val, ",")
        i += 2
      },
      other => return Err(errors.New(f"unknown flag: '{other}'")),
    }
  }

  let items = store.load()?
  let id = store.next_id(items)
  let item = models.Task.new(id, title, priority, tags)
  let items = items.append(item)
  store.save(items)?

  fmt.Println(f"Added task #{id}: {title} ({priority.label()} priority)")
  Ok(())
}

pub fn done(args: Slice<string>) -> Result<(), error> {
  let Some(raw) = args.get(2) else {
    return Err(errors.New("usage: done <id>"))
  }
  let id = parse_id(raw)?

  let items = store.load()?
  let items = store.set_status(items, id, models.Status.Done)?
  store.save(items)?

  fmt.Println(f"Completed task #{id}")
  Ok(())
}

pub fn cancel(args: Slice<string>) -> Result<(), error> {
  let Some(raw) = args.get(2) else {
    return Err(errors.New("usage: cancel <id> <reason>"))
  }
  let Some(reason) = args.get(3) else {
    return Err(errors.New("usage: cancel <id> <reason>"))
  }
  let id = parse_id(raw)?

  let items = store.load()?
  let items = store.set_status(items, id, models.Status.Cancelled(reason))?
  store.save(items)?

  fmt.Println(f"Cancelled task #{id}")
  Ok(())
}

pub fn list() -> Result<(), error> {
  let items = store.load()?
  let pending = items.filter(|t| t.status == models.Status.Pending)
  let done = items.filter(|t| t.status == models.Status.Done)
  let cancelled = items.filter(|t| t.status.is_cancelled())

  display.print_tasks("Pending", pending)
  display.print_tasks("Done", done)
  display.print_tasks("Cancelled", cancelled)
  Ok(())
}

pub fn stats() -> Result<(), error> {
  let items = store.load()?
  display.print_stats(items)
  Ok(())
}

pub fn watch() -> Result<(), error> {
  let ch = Channel.new<bool>()

  task {
    loop {
      time.Sleep(2 * time.Second)
      ch.send(true)
    }
  }

  fmt.Println("Watching tasks (Ctrl+C to stop)...")
  list()?

  for _ in ch {
    fmt.Println("\x1b[2J\x1b[H")
    list()?
  }
  Ok(())
}

fn parse_id(s: string) -> Result<int, error> {
  strconv.Atoi(s).wrap_err(f"'{s}' is not a valid task ID")
}

import "go:fmt"

import "models"

/// Prints nothing when the list is empty.
pub fn print_tasks(title: string, items: Slice<models.Task>) {
  if items.is_empty() { return }
  fmt.Println(f"\n{title}:")
  for item in items {
    fmt.Println(item.display())
  }
}

pub fn print_stats(items: Slice<models.Task>) {
  let total = items.length()
  let done = items.filter(|t| t.status == models.Status.Done).length()
  let pending = items.filter(|t| t.status == models.Status.Pending).length()
  let cancelled = total - done - pending
  let tag_count = items.fold(0, |sum, t| sum + t.tags.length())

  fmt.Println(f"\n  total:     {total}")
  fmt.Println(f"  done:      {done}")
  fmt.Println(f"  pending:   {pending}")
  fmt.Println(f"  cancelled: {cancelled}")
  fmt.Println(f"  tags:      {tag_count}")
}

pub fn print_usage() {
  fmt.Println("Usage: tasks <command> [args]")
  fmt.Println("")
  fmt.Println("Commands:")
  fmt.Println("  add <title> [--priority low|medium|high] [--tags a,b,c]")
  fmt.Println("  done <id>")
  fmt.Println("  cancel <id> <reason>")
  fmt.Println("  list")
  fmt.Println("  stats")
  fmt.Println("  watch")
}

import "go:errors"
import "go:fmt"
import "go:os"

import "commands"
import "display"

fn main() {
  let Some(command) = os.Args.get(1) else {
    display.print_usage()
    return
  }

  let result = match command {
    "add" => commands.add(os.Args),
    "done" => commands.done(os.Args),
    "cancel" => commands.cancel(os.Args),
    "list" => commands.list(),
    "stats" => commands.stats(),
    "watch" => commands.watch(),
    other => Err(errors.New(f"unknown command: '{other}'")),
  }

  if let Err(err) = result {
    fmt.Println(f"Error: {err}")
    os.Exit(1)
  }
}

import "go:errors"

pub enum Priority {
  Low,
  Medium,
  High,
}

impl Priority {
  pub fn label(self) -> string {
    match self {
      Low => "low",
      Medium => "medium",
      High => "high",
    }
  }
}

pub fn parse_priority(s: string) -> Result<Priority, error> {
  match s {
    "low" => Ok(Priority.Low),
    "medium" => Ok(Priority.Medium),
    "high" => Ok(Priority.High),
    other => Err(errors.New(
      f"unknown priority: '{other}' (expected low, medium, or high)",
    )),
  }
}

pub enum Status {
  Pending,
  Done,
  Cancelled(string),
}

impl Status {
  pub fn is_cancelled(self) -> bool {
    match self {
      Cancelled(_) => true,
      _ => false,
    }
  }

  pub fn label(self) -> string {
    match self {
      Pending => "pending",
      Done => "done",
      Cancelled(reason) => f"cancelled: {reason}",
    }
  }
}

#[test]
fn parse_priority_accepts_known_levels() {
  let assert Ok(low) = parse_priority("low")
  assert low.label() == "low"

  let assert Ok(medium) = parse_priority("medium")
  assert medium.label() == "medium"

  let assert Ok(high) = parse_priority("high")
  assert high.label() == "high"
}

#[test]
fn parse_priority_rejects_unknown() {
  let assert Err(err) = parse_priority("urgent")
  assert err.Error().contains("unknown priority")
}

#[test]
fn cancelled_status_carries_its_reason() {
  let status = Status.Cancelled("duplicate")
  assert status.is_cancelled()
  assert status.label() == "cancelled: duplicate"
}

#[test]
fn pending_status_is_not_cancelled() {
  assert !Status.Pending.is_cancelled()
}

#[json]
pub struct Task {
  pub id: int,
  pub title: string,
  pub priority: Priority,
  pub status: Status,
  pub tags: Slice<string>,
}

impl Task {
  pub fn new(
    id: int,
    title: string,
    priority: Priority,
    tags: Slice<string>,
  ) -> Task {
    Task { id, title, priority, status: Status.Pending, tags }
  }

  pub fn display(self) -> string {
    let icon = match self.status {
      Pending => "○",
      Done => "●",
      Cancelled(_) => "✕",
    }

    let priority = match self.priority {
      High => " !!",
      Medium => " !",
      Low => "",
    }

    let tags = match self.tags {
      [] => "",
      _ => f" [{self.tags.join(", ")}]",
    }

    let note = match self.status {
      Cancelled(_) => f" ({self.status.label()})",
      _ => "",
    }

    f"  {icon} #{self.id} {self.title}{priority}{tags}{note}"
  }
}

#[test]
fn new_task_starts_pending() {
  let item = Task.new(1, "write the docs", Priority.High, [])
  assert item.id == 1
  assert item.title == "write the docs"
  assert item.status == Status.Pending
}

#[test]
fn display_shows_id_priority_and_tags() {
  let item = Task.new(7, "ship release", Priority.High, ["urgent", "release"])
  let line = item.display()
  assert line.contains("#7 ship release")
  assert line.contains("!!")
  assert line.contains("[urgent, release]")
}

#[test]
fn display_omits_tags_when_empty() {
  let item = Task.new(2, "tidy up", Priority.Low, [])
  assert !item.display().contains("[")
}

import "go:encoding/json"
import "go:errors"
import "go:io/fs"
import "go:os"

import "models"

const FILE = "tasks.json"

/// A missing file yields an empty list, not an error.
pub fn load() -> Result<Slice<models.Task>, error> {
  let bytes = match os.ReadFile(FILE) {
    Ok(bytes) => bytes,
    Err(err) => {
      if errors.Is(err, fs.ErrNotExist) { return Ok([]) }
      return Err(err).wrap_err(f"reading {FILE}")
    },
  }
  let mut items: Slice<models.Task> = []
  json.Unmarshal(bytes, &items).wrap_err(f"parsing {FILE}")?
  Ok(items)
}

pub fn save(items: Slice<models.Task>) -> Result<(), error> {
  let data = json.MarshalIndent(items, "", "  ").wrap_err("encoding tasks")?
  let permissions = 0o644 as fs.FileMode
  os.WriteFile(FILE, data, permissions).wrap_err(f"writing {FILE}")?
  Ok(())
}

pub fn next_id(items: Slice<models.Task>) -> int {
  items.fold(0, |max, t| if t.id > max { t.id } else { max }) + 1
}

pub fn set_status(
  items: Slice<models.Task>,
  id: int,
  status: models.Status,
) -> Result<Slice<models.Task>, error> {
  let Some(_) = items.find(|t| t.id == id) else {
    return Err(errors.New(f"task #{id} not found"))
  }
  let updated = items.map(|t| {
    if t.id == id { models.Task { status, ..t } } else { t }
  })
  Ok(updated)
}

import "models"

fn sample() -> Slice<models.Task> {
  [
    models.Task.new(1, "first", models.Priority.Low, []),
    models.Task.new(2, "second", models.Priority.High, []),
  ]
}

#[test]
fn next_id_starts_at_one_for_empty() {
  let empty: Slice<models.Task> = []
  assert next_id(empty) == 1
}

#[test]
fn next_id_is_one_past_the_max() {
  assert next_id(sample()) == 3
}

#[test]
fn set_status_marks_a_task_done() {
  let assert Ok(updated) = set_status(sample(), 1, models.Status.Done)
  let assert Some(item) = updated.find(|t| t.id == 1)
  assert item.status == models.Status.Done
}

#[test]
fn set_status_reports_a_missing_task() {
  let assert Err(err) = set_status(sample(), 99, models.Status.Done)
  assert err.Error().contains("not found")
}

#[test]
fn set_status_records_a_cancel_reason() {
  let assert Ok(updated) = set_status(
    sample(),
    2,
    models.Status.Cancelled("obsolete"),
  )
  let assert Some(item) = updated.find(|t| t.id == 2)
  assert item.status.label() == "cancelled: obsolete"
}

LisetteA love letter to Gowritten in Rust

Expressive

Safe

Interoperable

Get started

Lisette
A love letter to Go
written in Rust