calendar

2.9 KB

1. \* Timer.hl → class Timer — ONE clock event source, its lifetime, its events.
3. `every(n)`, `after(n)` and `until(t)` all hand back one of these. The event
4. loop wiring lives HERE so app code never sees it: the source is registered AT
5. this instance, the internal fan-out re-emits `tick` at itself, and
6. `on interval.tick()` in the app is an ordinary instance-scoped handler — the
7. same shape hl:proc's Process has carried since 2026-08-17.
9. let interval = every(360)
10. on interval.tick(t) { … } \\ t = { count, at }
11. interval.stop()
13. ONE EVENT NAME FOR ALL THREE. `after(n)` IS `every(n)` that fires once and
14. `until(t)` IS `after(t - now())`; one primitive, two conveniences. Naming the
15. one-shot's event `finished` or `isUp` would mean swapping the constructor
16. forces rewriting the handler, and this language's events are verbs of arrival
17. — `line`, `exit`, `chunk`, `ready`, `saved`, `tick`. *\
19. \* The interval this timer was created with, in seconds (raised to hl:time's
20. floor if it was written below it — see server.hl). *\
21. Number seconds = 0
22. \* True for `every()`; false for the one-shots `after()` and `until()`. *\
23. Boolean repeating = false
24. \* False once a one-shot has fired or `stop()` was called. An `every` whose
25. `running` is true keeps the program alive — that is the point of it. *\
26. Boolean running = false
27. \* How many ticks have been delivered. 1 on a one-shot's only tick. *\
28. Number count = 0
30. Number #id = 0
31. Number #srcId = 0
33. \* Arm the timer and register its source. Called by `every`/`after`/`until`;
34. there is no reason to call it yourself. *\
35. start(Number secs, Boolean repeat) {
36. let armed = __native("time.timer", secs, repeat)
37. #id = armed.id
38. seconds = secs
39. repeating = repeat
40. running = true
41. #srcId = __native("eventloop.register", armed.events, "__timerTick")
42. return this
43. }
45. on __timerTick(ev) {
46. count = ev.count
47. if (repeating == false) {
48. // A SPENT ONE-SHOT RETIRES ITS SOURCE, BEFORE the tick is emitted.
49. // Mission 249 found the same defect in hl:proc on 2026-08-29: a child
50. // that had exited left its source registered, so the loop still held
51. // something that would never speak again and NO hl:proc program could
52. // ever end. An `after()` that does not retire hangs every program that
53. // uses one, which is why the test for this asserts TERMINATION and not
54. // output.
55. running = false
56. __native("eventloop.unregister", #srcId)
57. __native("time.timer_stop", #id)
58. }
59. emit tick(ev)
60. return null
61. }
63. \* Stop an interval (and end the program, if it was the only thing keeping it
64. alive) — the counterpart of `server.kill()`. True when this call was the one
65. that stopped it; false if it had already fired or been stopped. *\
66. stop() {
67. if (running == false) {
68. return false
69. }
70. running = false
71. // ORDER IS LOAD-BEARING: retire the source first, so the loop has dropped
72. // this fd from its epoll set before the fd is closed.
73. __native("eventloop.unregister", #srcId)
74. __native("time.timer_stop", #id)
75. return true
76. }