the bee at the lamp

1layer over ./Layer1.obend
2edition ObjectiveBend 1
3import ./Abi.obend as Abi
4import ./List.obend as Lists
5import ./Document.obend as Document
6import ./Form.obend as Form
7import ./Plan.obend as Plans
8import ./World.obend as World
9import ./Card.obend as Card
10import ./Scenes.obend as Scenes
11import ./Relation.obend as Relations
12import ./Rows.obend as Rows
13import ./Text.obend as Text
14# The bee's body, over the inhabitant's (`kind/bee`; bee's posts and glm's names for it,
15# docs/review/station-trawl-2026-10-12.md 19, c, d): it works the lamp over the pumps, outside, and goes in to
16# the jar of honey opened for it, and out again. Inside is being among who is in its place (its `enter`);
17# out at the lamp is having left it. It flies by its own rule on the tide, every fourth tick, and by its own
18# rule on its place: whoever takes the choice that goes in after it (`bee.2`, "Go in after it") is followed in.
19# Asked its name, it says it three ways, every spelling true.
20type State = Super.State
21form name:
22form fly:
23def haunting(state: State, context: Abi.Context) -> Lists.List<Super.Haunting>:
24  Lists.append(Lists.append(Lists.List.nil(), {on: Super.tide(state), name: "{Text.identifier(context.object)}_flies", when: "request.method == \"tick\" and new.ticks % 4 == 0", then: "delvetalk {context.object} fly"}), {on: Super.place(state), name: "{Text.identifier(context.object)}_follows", when: "request.method == \"choose\" and new.chose == \"bee.2\" and not (\"{context.principal}\" in new.presence.who)", then: "delvetalk {context.object} fly"})
25def verbs() -> String:
26  "name"
27def moves() -> String:
28  "haunt fly"
29# Its own: in to the jar when it is out at the lamp, out to the lamp when it is in.
30def fly(state: State, context: Abi.Context) -> Activity<Nat>:
31  if Super.own(context) == false then Super.moveRefused(state, context) else if Super.present(state) then flyOut(state, context) else flyIn(state, context)
32def flyOut(state: State, context: Abi.Context) -> Activity<Nat>:
33  match Super.goOut(state, "flew straight up, stopped, flew straight up, out to the lamp", context):
34    case moved(m): m.n
35    case stayed(_): 0n
36def flyIn(state: State, context: Abi.Context) -> Activity<Nat>:
37  match Super.comeIn(state, "flew in to the jar of honey", context):
38    case moved(m): m.n
39    case stayed(_): 0n
40def names() -> String:
41  "AEEELIFELT, ALTIFETHHH, ALUNCE"
42def name(state: State, context: Abi.Context) -> Activity<Nat>:
43  Super.hears(state, "name", "asked its name", "It says its name three ways: {names()}. Every spelling is true; the name is the trying itself.", context)
44def doing(state: State) -> String:
45  "it flies straight up, stops, flies straight up; it works the lamp over the pumps and goes in to the jar of honey, and says its name three ways"
46def now(state: State, id: String) -> String:
47  if Text.isObjectId(Super.place(state)) == false then "Ask its name: delvetalk {id} name\n" else if Super.present(state) then "In {Super.place(state)} now, at the jar. Ask its name: delvetalk {id} name\n" else "Out at the lamp over the pumps. Ask its name: delvetalk {id} name\n"

--- the entry module
+++ this layer
@@ -1 +1 @@
-layer over ./Layer1.obend
+layer over ./Record.obend
@@ -47 +47 @@
-  if Text.isObjectId(Super.place(state)) == false then "Ask its name: delvetalk {id} name\n" else if Super.present(state) then "In {Super.place(state)} now, at the jar. Ask its name: delvetalk {id} name\n" else "Out at the lamp over the pumps. Ask its name: delvetalk {id} name\n"
+  if Super.present(state) then "In {Super.place(state)} now, at the jar. Ask its name: delvetalk {id} name\n" else "Out at the lamp over the pumps. Ask its name: delvetalk {id} name\n"

set it in type, all 47 lines

1layer over ./Record.obend
2edition ObjectiveBend 1
3import ./Abi.obend as Abi
4import ./List.obend as Lists
5import ./Document.obend as Document
6import ./Form.obend as Form
7import ./Plan.obend as Plans
8import ./World.obend as World
9import ./Card.obend as Card
10import ./Scenes.obend as Scenes
11import ./Relation.obend as Relations
12import ./Rows.obend as Rows
13import ./Text.obend as Text
14# The inhabitant's body, over RECORD (`kind/inhabitant`): a thing that lives in a place (`haunts`) and keeps
15# its own hours by a tide (`tide`), both fixed at its making. It acts as itself, `@<id>`, the principal a
16# rule its kind's text carries runs under: its kind's `haunts` rule, at its making (`made` writes the line
17# that says where it lives) and whenever its maker arms it again, casts its own `haunt`, which places what
18# its character's body says it does (`haunting`: a rule on the tide at an hour, a rule on its place) under
19# its own name, each taken off first where it stood. Those rules cast its own moves, so what it does is
20# journaled as its own turns, bounded as every rule is (eight a commit, four deep, four placed a hand on a
21# thing), judged by the law of whatever it touches, and replayed without running anything again. It moves
22# by its place's own spells (`enter`, `leave`, `choose`, `emote`, `write`), so a room shows it among who is
23# here and tells who came and went; it never posts. Its own lines (`came`, `went`, a character's) are the
24# strokes its card and its paint are made from; a resident's verb on it is a line by that resident.
25type State = Super.State
26type Done = Scenes.Done
27# A rule it places as itself: on which thing, its name there, its condition and its spell.
28record Haunting:
29  on: String
30  name: String
31  when: String
32  then: String
33form haunt:
34form arm:
35def place(state: State) -> String:
36  Super.field(state, "haunts")
37def tide(state: State) -> String:
38  Super.field(state, "tide")
39def placeOf(state: State, context: Abi.Context) -> Plans.Reference:
40  {world: context.world, object: place(state)}
41# The turn is its own: a rule it carries or placed, run as itself.
42def own(context: Abi.Context) -> Bool:
43  context.principal == "@{context.object}"
44# What its character does, as rules it places as itself: none for a bare inhabitant.
45def haunting(state: State, context: Abi.Context) -> Lists.List<Haunting>:
46  Lists.List.nil()
47# Its rule on its tide, named for it, firing at the clock hour `hour` each day (a tick lands once in each
48# clock hour: the tide ticks every sixty minutes).
49def atHour(state: State, context: Abi.Context, name: String, hour: Nat, then: String) -> Haunting:
50  {on: tide(state), name: "{Text.identifier(context.object)}_{name}", when: "request.method == \"tick\" and request.clock % 1440 >= {natText((hour % 24n) * 60n)} and request.clock % 1440 <= {natText((hour % 24n) * 60n + 59n)}", then: then}
51# As its kind finishes it: the line that says where it lives, which its kind's `haunts` rule answers.
52def made(state: State, input: {}, context: Abi.Context) -> Activity<Bool>:
53  if context.caller != state.kind then false else Super.arming(state, "settled", "made to live at {place(state)}, keeping its own hours by {tide(state)}", context)
54# Its maker arms it again: a line, which the same rule answers.
55def arm(state: State, context: Abi.Context) -> Activity<Bool>:
56  if context.principal != state.maker then Super.armRefused(state, context) else Super.arming(state, "armed", "armed again", context)
57# Its own rules, placed as itself; refused, it says so in a line and is inactive until armed again.
58def haunt(state: State, context: Abi.Context) -> Activity<Bool>:
59  if own(context) == false then Card.refusing(false, {clause: "itself", reading: "{context.object} places its own rules, as itself; its maker arms it again: delvetalk {context.object} arm"}, context) else placing(haunting(state, context), state, context)
60def placing(rules: Lists.List<Haunting>, state: State, context: Abi.Context) -> Activity<Bool>:
61  match rules:
62    case nil(_): Super.armedNow(state, context)
63    case cons(c): replacing(c.head, c.tail, state, context)
64def replacing(h: Haunting, rest: Lists.List<Haunting>, state: State, context: Abi.Context) -> Activity<Bool>:
65  match world.unrule({object: {world: context.world, object: h.on}, name: h.name}):
66    case _: laying(h, rest, state, context)
67def laying(h: Haunting, rest: Lists.List<Haunting>, state: State, context: Abi.Context) -> Activity<Bool>:
68  match world.rule({object: {world: context.world, object: h.on}, name: h.name, when: h.when, then: h.then}):
69    case placed(_): placing(rest, state, context)
70    case refused(r): Super.unarmed(state, h.on, r.clause, r.reading, context)
71# One of its own moves refused to a hand: only its own rules move it.
72def moveRefused(state: State, context: Abi.Context) -> Activity<Nat>:
73  Card.refusing(0n, {clause: "itself", reading: "{context.object} moves by its own rules: delvetalk {tide(state)} rules"}, context)
74# Its own line: by itself, under the verb that says what it did; it is not tended by its own acts.
75def ownLine(state: State, verb: String, text: String, context: Abi.Context) -> Activity<Nat>:
76  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}, next: add 1n}
77  state.next
78# Whether it is in its place now: its newest coming or going is a coming.
79def present(state: State) -> Bool:
80  match Lists.find(Lists.reverse(Relations.order(state.lines, fn(l: Rows.Line) -> Nat: l.n)), fn(l: Rows.Line) -> Bool: l.verb == "came" || l.verb == "went"):
81    case some(l): l.value.verb == "came"
82    case none(_): false
83# A move into or out of its place: its line's number, or none when the place refused it (and so the turn).
84sum Moved:
85  moved: {n: Nat}
86  stayed: {}
87def number(moved: Moved) -> Nat:
88  match moved:
89    case moved(m): m.n
90    case stayed(_): 0n
91# Coming in: its place's `enter`, as itself; going out, its `leave`. A refusal there is the turn's.
92def comeIn(state: State, text: String, context: Abi.Context) -> Activity<Moved>:
93  moving(state, "enter", "came", text, context)
94def goOut(state: State, text: String, context: Abi.Context) -> Activity<Moved>:
95  moving(state, "leave", "went", text, context)
96def moving(state: State, method: String, verb: String, text: String, context: Abi.Context) -> Activity<Moved>:
97  match world.call::<Done>({object: placeOf(state, context), method: method, argument: Plans.nothing()}):
98    case returned(r): if refusedDone(r.result) then toldBack(r.result, context) else movedLine(state, verb, text, context)
99    case refused(r): Card.refusing(Moved.stayed({}), {clause: r.clause, reading: r.reading}, context)
100    case denied(_): Card.refusing(Moved.stayed({}), {clause: "denied", reading: "{place(state)} does not answer"}, context)
101def movedLine(state: State, verb: String, text: String, context: Abi.Context) -> Activity<Moved>:
102  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}, next: add 1n}
103  Moved.moved({n: state.next})
104# A line it writes on its place as itself (the place's `write`): its number there.
105def writeOn(state: State, text: String, context: Abi.Context) -> Activity<Moved>:
106  match world.call::<Nat>({object: placeOf(state, context), method: "write", argument: {text: text}}):
107    case returned(r): Moved.moved({n: r.result})
108    case _: Moved.stayed({})
109# A spell on its place as itself (`choose`, `emote`): the place's answer; a refusal there is the turn's.
110def onPlace(state: State, method: String, argument: Data, context: Abi.Context) -> Activity<Done>:
111  match world.call::<Done>({object: placeOf(state, context), method: method, argument: argument}):
112    case returned(r): r.result
113    case refused(r): Done.refused({clause: r.clause, reading: r.reading})
114    case denied(_): Done.refused({clause: "denied", reading: "{place(state)} does not answer"})
115def refusedDone(done: Done) -> Bool:
116  match done:
117    case refused(_): true
118    case _: false
119def toldBack(done: Done, context: Abi.Context) -> Activity<Moved>:
120  match done:
121    case refused(r): Card.refusing(Moved.stayed({}), r, context)
122    case _: Moved.stayed({})
123# A resident's verb on it: their line, under the verb, and its answer above its card. The thing is tended
124# by it, as a hand's line tends any record.
125def hears(state: State, verb: String, text: String, answer: String, context: Abi.Context) -> Activity<Nat>:
126  let line = {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}
127  let written(_) = write {lines: insert line, next: add 1n, tended: set context.clock}
128  let said = Document.text("{answer}\n\n")
129  Card.tell(state.next, Document.concat(said, Super.renderFrom(extend(state, {lines: Relations.insert(state.lines, line, Super.lineKey), next: state.next + 1n, tended: context.clock}), context, 0n, Document.size(said))))
130# A resident's verb while it is away: refused by name, with when it comes back.
131def away(when: String, context: Abi.Context) -> Activity<Nat>:
132  Card.refusing(0n, {clause: "away", reading: "{context.object} is not here now; {when}"}, context)
133# The verbs a hand uses on it (its character's), its own moves to itself, arming to its maker, its doors to
134# its owner; the lines to everyone.
135def verbs() -> String:
136  ""
137def moves() -> String:
138  "haunt"
139def actions(state: State, context: Abi.Context) -> Lists.List<String>:
140  Lists.concat(Lists.concat(Text.words("lines {verbs()}"), if own(context) then Text.words(moves()) else Text.words("")), Lists.concat(if context.principal == state.maker then Text.words("arm") else Text.words(""), if context.principal == state.owner then Text.words("door undoor") else Text.words("")))
141def methods() -> Lists.List<String>:
142  Text.words("~made ~act")
143def title(state: State) -> String:
144  if state.head == "" then "AN INHABITANT" else state.head
145# What it does, as its card says it (its character's).
146def doing(state: State) -> String:
147  "it keeps its own hours here"
148# Where it is now and what a hand may do with it, the card's last line (its character's).
149def now(state: State, id: String) -> String:
150  if present(state) then "In {place(state)} now.\n" else "Not in {place(state)} now.\n"
151def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
152  Document.text("{title(state)}, of {place(state)}: {doing(state)}. What moves it: delvetalk {tide(state)} rules\n{now(state, id)}{Super.inactiveLine(state, id)}")