Agendamiento: every, after y timeout

Un contador con break tras 3 iteraciones; una suma acumulada que se detiene al alcanzar el total deseado.

// Feature: periodic loop with `every <dur> { ... }`

// Syntax: `every <duration> { body }` — repeats the body at the given

// interval. It is a keyword (not a variable name).

// When to use: health-checks, polling, animation, metrics, any

// task that needs to run repeatedly on a fixed interval.


var tick = 0

// Runs 3 times (short interval for the demo) and exits with `break`.

every 50ms {
  tick = tick + 1
  print("tick #{tick}")
  if tick >= 3 {
    break
  }
}

print("done")

// expected:

// tick #1

// tick #2

// tick #3

// done


// Another example: summing until a total is reached.

var total = 0
every 25ms {
  total = total + 10
  if total >= 30 {
    break
  }
}
print("total = {total}")
// expected: total = 30

Tres after coexistiendo; el orden de disparo lo determina el scheduler.

// Feature: schedule one execution with `after <dur> { ... }`

// Syntax: `after <duration> { body }` — fire-and-forget; the block

// runs **once** after the delay. It is a keyword.

// When to use: one-shot callbacks, timers, expirations, single

// reminders. Unlike `every`, it does not repeat.


print("scheduling...")

// Block runs 50ms later — does not block the main flow here.

after 50ms {
  print("fired after 50ms!")
}

// Multiple `after` may coexist.

after 100ms {
  print("fired after 100ms!")
}

after 25ms {
  print("this one was first")
}

print("scheduled, waiting...")

// Keep the program alive long enough to see the firings.

sleep 200ms
print("end")
// expected (approximate order — depends on the scheduler):

// scheduling...

// scheduled, waiting...

// this one was first

// fired after 50ms!

// fired after 100ms!

// end

Camino feliz con retorno dentro del plazo; nota sobre el comportamiento cooperativo y alternativa de nombre para la variable de plazo.

// Feature: cancel work that takes too long with `timeout`

// Syntax: `timeout <dur> { body }` — returns a `Result`-like

// (`{ ok, value, error }`) with `ok = true` if it completed, or

// `ok = false, error = "timeout"` if it expired.

// When to use: network calls, uncertain IO, tasks that need a

// fail-safe. Cooperative: only fires at a yield point.


// Happy path: body finishes within the deadline.

let result_ok = timeout 100ms {
  return 42
}
if result_ok.ok {
  print("ok: {result_ok.value}")
} else {
  print("err: {result_ok.error}")
}

// expected: ok: 42


// Timeout case: body takes longer than the limit and is interrupted.

// Note: cooperative — the body must yield (e.g. via `sleep`) for

// the deadline to fire. If it never yields, the body runs to

// completion and `ok = true`.

// SKIP: sleep inside `timeout { ... }` raises a YieldError in the

// current runtime; the failure case is therefore commented out.

//

// let result_slow = timeout 30ms {

//   sleep 200ms

//   return "too late"

// }

// if result_slow.ok {

//   print("ok: {result_slow.value}")

// } else {

//   print("err: {result_slow.error}")

// }

//

// expected: err: timeout


// IMPORTANT: `timeout` is a reserved keyword — you cannot use it

// as a variable name. Use `deadline`, `limit`, `dur`, etc. instead.

let limit = 5000
print("using '{limit}' instead of 'timeout' as the name")