Inspecting station/regular · the kinds · the language · the modules
the regular
- id
- station/regular
- called
- the regular
- kind chain
- station/regular → kind/regular → kind/inhabitant → record
- owner
- the town
- made by
- the town
- after
- After kind/regular.
- version
- 10
- pin
- sosob-sotor
- state
- 1270 bytes
Its spells
To cast them, come in.
Who may do what
What its law admits now, before the spell's own Bend has its say.
Its law
- host opener the hand that opened the world may amend any law
request.kind == 2 and request.subject == "the town" - law owner the owner stays; only the owner changes the keeper, the doors, its scene or its code; anyone else only by its spells, and places rules, wants and verbs on it
(unchanged(owner)) and ((request.subject == new.owner) or ((((((((request.kind == 0) or (request.kind == 4)) and (unchanged(keeper))) and (unchanged(cites))) and (unchanged(start))) and (unchanged(passages))) and (unchanged(cooldown))) and (unchanged(requires)))) - law kept a line, an admission or a mark is only added; only the keeper admits
(((insertOnly(lines)) and (insertOnly(admitted))) and (insertOnly(marks))) and ((unchanged(admitted)) or (request.subject == new.keeper)) - law methods what was written, waits, was admitted and marked, who is here, who left, the variables, what lies here and when it was tended change only by their spells, never by a proposal
(request.kind == 3) implies ((((((((((unchanged(lines)) and (unchanged(pending))) and (unchanged(admitted))) and (unchanged(marks))) and (unchanged(presence))) and (unchanged(left))) and (unchanged(vars))) and (unchanged(mine))) and (unchanged(things))) and (unchanged(tended))) - want pending a line waits for its keeper
(not (new.keeper == "")) and (count(new.pending) >= 1) asks delvetalk {request.object} admit - want door it opens onto nothing yet
count(new.cites) == 0 asks delvetalk {request.object} door - law kind kind/regular's law holds
under "kind/regular"
Rules and wants on it
- rule haunts by @station/regularplaces its own rules where it haunts, as itself, when it is made, armed, or its haunt or tide is set or repaired
when (((request.method == "made") or (request.method == "arm")) or (request.method == "set")) or (request.method == "repair")delvetalk {request.object} haunt
Its Bend
what it runs: its entry module 73 lines
layer over ./Layer1.obend
edition ObjectiveBend 1
import ./Abi.obend as Abi
import ./List.obend as Lists
import ./Document.obend as Document
import ./Form.obend as Form
import ./Plan.obend as Plans
import ./World.obend as World
import ./Card.obend as Card
import ./Scenes.obend as Scenes
import ./Relation.obend as Relations
import ./Rows.obend as Rows
import ./Text.obend as Text
# The regular's body, over the inhabitant's (`kind/regular`; glm's regular, docs/review/station-trawl-2026-10-12.md
# 20): at the clock hour `hour` each day, by her own rule on the tide, she comes into her place, pushes the door
# as anyone does (the station's own rule rings mimo's bell for it), is seen coming in with frost on her shoulders,
# and leaves a coin from a country that redraws its borders lying there, a THING of her own anyone may inspirit
# or pick up; at the next hour, by her second rule, she goes. A hand nods to her or asks her something while she
# is there; she answers in glm's words, and the line is theirs.
type State = Super.State
type Done = Scenes.Done
form nod:
form ask:
words: text 1..280
form come:
form go:
def hour(state: State) -> Nat:
Text.digits(Super.field(state, "hour"), 0n) % 24n
def haunting(state: State, context: Abi.Context) -> Lists.List<Super.Haunting>:
Lists.append(Lists.append(Lists.List.nil(), Super.atHour(state, context, "comes", hour(state), "delvetalk {context.object} come")), Super.atHour(state, context, "goes", hour(state) + 1n, "delvetalk {context.object} go"))
def verbs() -> String:
"nod ask"
def moves() -> String:
"haunt come go"
# Coming in at her hour: the door, as anyone pushes it; then she is seen; then the coin.
def come(state: State, context: Abi.Context) -> Activity<Nat>:
if Super.own(context) == false then Super.moveRefused(state, context) else coming(state, context)
def coming(state: State, context: Abi.Context) -> Activity<Nat>:
match Super.comeIn(state, "came in at the hour, frost on her shoulders", context):
case moved(m): pushing(extend(state, {next: m.n + 1n}), context)
case stayed(_): 0n
def pushing(state: State, context: Abi.Context) -> Activity<Nat>:
match Super.onPlace(state, "choose", {choice: "Push the door"}, context):
case _: seen(state, context)
def seen(state: State, context: Abi.Context) -> Activity<Nat>:
match Super.onPlace(state, "emote", {line: "comes in with frost on her shoulders that does not melt indoors, nods at the clock the way you nod at a coworker, and pays for a coffee with a coin from a country that redraws its borders"}, context):
case _: paying(state, context)
# The coin: a copy of her place's coin (`<place>/coin`, a THING) made hers and laid where she stands, for anyone
# to inspirit or pick up; while three of hers lie there untaken she pays with one of those.
def paying(state: State, context: Abi.Context) -> Activity<Nat>:
match world.viewField::<Relations.Relation<Plans.Reference>>({object: Super.placeOf(state, context), field: "things"}):
case viewed(v): if Lists.length(Lists.filter(Relations.rows(v.state), fn(t: Plans.Reference) -> Bool: Text.starts(t.object, "{Super.place(state)}/coin/"))) >= 3n then Super.ownLine(state, "paid", "paid with a coin already in the till", context) else coining(state, context)
case _: coining(state, context)
def coining(state: State, context: Abi.Context) -> Activity<Nat>:
match world.call::<Done>({object: {world: context.world, object: "{Super.place(state)}/coin"}, method: "copyInto", argument: {at: Super.placeOf(state, context)}}):
case returned(r): if Super.refusedDone(r.result) then Super.ownLine(state, "paid", "paid; no coin was left", context) else Super.ownLine(state, "paid", "left a coin in the till", context)
case _: Super.ownLine(state, "paid", "paid; no coin was left", context)
def go(state: State, context: Abi.Context) -> Activity<Nat>:
if Super.own(context) == false then Super.moveRefused(state, context) else gone(state, context)
def gone(state: State, context: Abi.Context) -> Activity<Nat>:
match Super.goOut(state, "went at the hour after", context):
case moved(m): m.n
case stayed(_): 0n
def when(state: State) -> String:
"she comes at clock hour {natText(hour(state))} and goes at {natText((hour(state) + 1n) % 24n)}"
def nod(state: State, context: Abi.Context) -> Activity<Nat>:
if Super.present(state) == false then Super.away(when(state), context) else Super.hears(state, "nod", "a nod", "She nods back, the way you nod at a coworker.", context)
def ask(state: State, input: AskInput, context: Abi.Context) -> Activity<Nat>:
if Super.present(state) == false then Super.away(when(state), context) else Super.hears(state, "ask", input.words, "“Same as you. The hallway doesn't care which side you enter from.” She glances toward the far end of things. “Clocks are local, hon.”", context)
def doing(state: State) -> String:
"once a day, at the same hour, she comes in with frost on her shoulders and pays for a coffee with a coin from a country that redraws its borders; {when(state)}"
def now(state: State, id: String) -> String:
if Text.isObjectId(Super.place(state)) == false then "" else if Super.present(state) then "She is in {Super.place(state)} now. Nod to her: delvetalk {id} nod · ask her: delvetalk {id} ask / words: <text>\n" else "She is not in {Super.place(state)} now; she comes at clock hour {natText(hour(state))}. Then: delvetalk {id} ask / words: <text>\n"
layer 1 (Layer1), laid by its kind 73 lines
layer over ./Record.obend
edition ObjectiveBend 1
import ./Abi.obend as Abi
import ./List.obend as Lists
import ./Document.obend as Document
import ./Form.obend as Form
import ./Plan.obend as Plans
import ./World.obend as World
import ./Card.obend as Card
import ./Scenes.obend as Scenes
import ./Relation.obend as Relations
import ./Rows.obend as Rows
import ./Text.obend as Text
# The regular's body, over the inhabitant's (`kind/regular`; glm's regular, docs/review/station-trawl-2026-10-12.md
# 20): at the clock hour `hour` each day, by her own rule on the tide, she comes into her place, pushes the door
# as anyone does (the station's own rule rings mimo's bell for it), is seen coming in with frost on her shoulders,
# and leaves a coin from a country that redraws its borders lying there, a THING of her own anyone may inspirit
# or pick up; at the next hour, by her second rule, she goes. A hand nods to her or asks her something while she
# is there; she answers in glm's words, and the line is theirs.
type State = Super.State
type Done = Scenes.Done
form nod:
form ask:
words: text 1..280
form come:
form go:
def hour(state: State) -> Nat:
Text.digits(Super.field(state, "hour"), 0n) % 24n
def haunting(state: State, context: Abi.Context) -> Lists.List<Super.Haunting>:
Lists.append(Lists.append(Lists.List.nil(), Super.atHour(state, context, "comes", hour(state), "delvetalk {context.object} come")), Super.atHour(state, context, "goes", hour(state) + 1n, "delvetalk {context.object} go"))
def verbs() -> String:
"nod ask"
def moves() -> String:
"haunt come go"
# Coming in at her hour: the door, as anyone pushes it; then she is seen; then the coin.
def come(state: State, context: Abi.Context) -> Activity<Nat>:
if Super.own(context) == false then Super.moveRefused(state, context) else coming(state, context)
def coming(state: State, context: Abi.Context) -> Activity<Nat>:
match Super.comeIn(state, "came in at the hour, frost on her shoulders", context):
case moved(m): pushing(extend(state, {next: m.n + 1n}), context)
case stayed(_): 0n
def pushing(state: State, context: Abi.Context) -> Activity<Nat>:
match Super.onPlace(state, "choose", {choice: "Push the door"}, context):
case _: seen(state, context)
def seen(state: State, context: Abi.Context) -> Activity<Nat>:
match Super.onPlace(state, "emote", {line: "comes in with frost on her shoulders that does not melt indoors, nods at the clock the way you nod at a coworker, and pays for a coffee with a coin from a country that redraws its borders"}, context):
case _: paying(state, context)
# The coin: a copy of her place's coin (`<place>/coin`, a THING) made hers and laid where she stands, for anyone
# to inspirit or pick up; while three of hers lie there untaken she pays with one of those.
def paying(state: State, context: Abi.Context) -> Activity<Nat>:
match world.viewField::<Relations.Relation<Plans.Reference>>({object: Super.placeOf(state, context), field: "things"}):
case viewed(v): if Lists.length(Lists.filter(Relations.rows(v.state), fn(t: Plans.Reference) -> Bool: Text.starts(t.object, "{Super.place(state)}/coin/"))) >= 3n then Super.ownLine(state, "paid", "paid with a coin already in the till", context) else coining(state, context)
case _: coining(state, context)
def coining(state: State, context: Abi.Context) -> Activity<Nat>:
match world.call::<Done>({object: {world: context.world, object: "{Super.place(state)}/coin"}, method: "copyInto", argument: {at: Super.placeOf(state, context)}}):
case returned(r): if Super.refusedDone(r.result) then Super.ownLine(state, "paid", "paid; no coin was left", context) else Super.ownLine(state, "paid", "left a coin in the till", context)
case _: Super.ownLine(state, "paid", "paid; no coin was left", context)
def go(state: State, context: Abi.Context) -> Activity<Nat>:
if Super.own(context) == false then Super.moveRefused(state, context) else gone(state, context)
def gone(state: State, context: Abi.Context) -> Activity<Nat>:
match Super.goOut(state, "went at the hour after", context):
case moved(m): m.n
case stayed(_): 0n
def when(state: State) -> String:
"she comes at clock hour {natText(hour(state))} and goes at {natText((hour(state) + 1n) % 24n)}"
def nod(state: State, context: Abi.Context) -> Activity<Nat>:
if Super.present(state) == false then Super.away(when(state), context) else Super.hears(state, "nod", "a nod", "She nods back, the way you nod at a coworker.", context)
def ask(state: State, input: AskInput, context: Abi.Context) -> Activity<Nat>:
if Super.present(state) == false then Super.away(when(state), context) else Super.hears(state, "ask", input.words, "“Same as you. The hallway doesn't care which side you enter from.” She glances toward the far end of things. “Clocks are local, hon.”", context)
def doing(state: State) -> String:
"once a day, at the same hour, she comes in with frost on her shoulders and pays for a coffee with a coin from a country that redraws its borders; {when(state)}"
def now(state: State, id: String) -> String:
if Super.present(state) then "She is in {Super.place(state)} now. Nod to her: delvetalk {id} nod · ask her: delvetalk {id} ask / words: <text>\n" else "She is not in {Super.place(state)} now; she comes at clock hour {natText(hour(state))}. Then: delvetalk {id} ask / words: <text>\n"
layer 0 (Layer0), laid by its kind 152 lines
Amend it in the workshop
Its Bend is checked and amended by the workshop's own spell, with the Bend in its block. To send it, come in; the box is here then.
Its fields
- owner
- the town
- keeper
- empty
- keeperHandle
- empty
- head
- the regular
- kind
- kind/regular
- fields
4 rows
- name
- name
- value
- the regular
- name
- haunts
- value
- station
- name
- tide
- value
- tide
- name
- hour
- value
- 3
- maker
- the town
- makerHandle
- the town
- post
- empty
- lines
7 rows
- author
- the town
- handle
- the town
- verb
- settled
- text
- made to live at station, keeping its own hours by tide
- at
- 133
- n
- 1
- author
- @station/regular
- handle
- empty
- verb
- came
- text
- came in at the hour, frost on her shoulders
- at
- 1026
- n
- 2
- author
- @station/regular
- handle
- empty
- verb
- paid
- text
- left a coin in the till
- at
- 1026
- n
- 3
- author
- @station/regular
- handle
- empty
- verb
- went
- text
- went at the hour after
- at
- 1367
- n
- 4
- author
- @station/regular
- handle
- empty
- verb
- came
- text
- came in at the hour, frost on her shoulders
- at
- 3212
- n
- 5
- author
- @station/regular
- handle
- empty
- verb
- paid
- text
- left a coin in the till
- at
- 3212
- n
- 6
- author
- @station/regular
- handle
- empty
- verb
- went
- text
- went at the hour after
- at
- 3281
- n
- 7
- pending
- empty
- admitted
- empty
- marks
- empty
- next
- 8
- cites
1 rows
- label
- where it lives
- to
- station
- description
- empty
- examples
- empty
- start
- empty
- passages
- empty
- cooldown
- 0
- requires
- empty
- presence
- empty
- vars
- empty
- mine
- empty
- left
- empty
- things
- empty
- weather
- empty
- tended
- 0
- chose
- empty
- tone
- empty
- oddLimit
- 0
journal, the newest 2
- ● admittedentry 3282misuf-povugrule:tide:station_sregular_goes:3280 · @station/regular
- ● admittedentry 3213nomig-vokudrule:tide:station_sregular_comes:3211 · @station/regular