The compiler that does the repeated work for you.

fn longest(items: ref<array<string>>) -> u64 effects {} {
  var best: u64 = 0
  var i: u64 = 0
  loop {
    if i == array.len(items) { break }
    let item: str = str.view(array.borrow(items, i))  // borrow, no copy
    if str.len(item) > str.len(str.view(array.borrow(items, best))) { best = i }
    i = i + 1
  }
  best          // no allocation, no effects declared
}

pub type Task = struct {
  id: u64, title: string, done: bool, tags: array<string>
} derive codec(strict)

// AIR generates Task_decode and Task_encode. No generated files.
match Task_decode(body) {
  ok(value) => { var task: Task = value
                 reply = try Task_encode(task) },
  err(problem) => report(problem),   // e.g. unknown_field at /extra
}

task.scope {
  var jobs: array<task<u64>> = array.new()
  var i: u64 = 1
  loop {
    if i > 4 { break }
    array.push(jobs, task.spawn(i, fn=square))
    i = i + 1
  }
  loop {
    match tasks.join_next<u64>(jobs, tasks.forever()) {
      some(result) => { total = total + result },
      none => { break },
    }
  }
}   // handles can never escape the scope that spawned them