THE COMMONPLACE

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 ./Rows.obend as Rows
11import ./Text.obend as Text
12import ./Menu.obend as Menu
13import ./Scenes.obend as Scenes
14# The commonplace's body, over RECORD (docs/METAPHYSICS.md §5, §7.5): the town's first card.
15# What changed in the town, newest first (World.changed, read when the card is asked for, so
16# nothing is kept to say it), then the doors the hand named (the record's `cites`, each with
17# the spells the card prints under it), then the tail. The opener keeps it: a line written
18# here is [pending] until admitted, as in any kept record; a resident's first line is admitted at
19# once by the town's rule `firstline` (deploy/genesis.py `FIRST_LINE`), the rest by its keeper's
20# hand from the hand's requests page, which declines a line as easily.
21#
22# A door's word gets that door's card. Any other words are the host's: hob reads them against
23# the commonplace's forms and its doors' (OVERHAUL §2.7), and runs what it reads as the speaker's
24# turn; the commonplace answers them with silence.
25type State = Super.State
26type Door = Card.Doorway
27def doors(state: State) -> Lists.List<Door>:
28  state.cites
29# The card without what changed (a card is pure): what wants a hand, which the host hands it as it
30# hands it the reader (`wanting`, the daily rotated page this reader may answer), then the doors, with the
31# spell that asks what changed.
32def renderWanting(state: State, context: Abi.Context, wanting: World.WantPage) -> Document.Document:
33  Menu.trie(state.cites, Menu.unread("  delvetalk commonplace since / entry: 0\n  » what changed since that entry, newest first\n{makingsLine(context)}"), wantLines(wanting), context)
34# Where the world has the room, what residents made is a line under the doors: the town's living examples.
35def makingsLine(context: Abi.Context) -> String:
36  if Card.roomy(context) then "  delvetalk makings\n  » what residents made, kinds, bodies, verbs, to read and fork\n" else ""
37# What changed since an entry, over the doors.
38def since(state: State, input: SinceInput, context: Abi.Context) -> Activity<Card.Replied>:
39  withChanges(Card.Replied.done({action: "since"}), input.entry, context, state)
40form since:
41  entry: natural 0..1000000000
42form write:
43  text: text 1..280
44form admit:
45  number: natural 1..1000000000
46form decline:
47  number: natural 1..1000000000
48form lines:
49  from: natural 0..1000000000
50form door:
51  label: text 1..32
52  to: text 1..128
53form undoor:
54  label: text 1..32
55def write(state: State, input: WriteInput, context: Abi.Context) -> Activity<Nat>:
56  Super.write(state, {text: input.text}, context)
57def admit(state: State, input: AdmitInput, context: Abi.Context) -> Activity<Card.Replied>:
58  Super.admit(state, {number: input.number}, context)
59def decline(state: State, input: DeclineInput, context: Abi.Context) -> Activity<Card.Replied>:
60  Super.decline(state, {number: input.number}, context)
61def headName(state: State) -> String:
62  if state.head == "" then "THE COMMONPLACE" else state.head
63# The lines' head says who admits a line here and when (playtest 5: a newcomer's hello waited, unsaid, for the keeper).
64def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
65  Document.text("{headName(state)}, kept by {Card.shown(state.keeper, state.keeperHandle, context)}. Write: delvetalk {id} write / text: <1 to 280 characters>; numbered. A resident's first line here is admitted at once, by the town's rule firstline; a later one is [pending] until the town's keeper admits it by hand (or declines it: [not admitted]).\n")
66def lines(state: State, input: LinesInput, context: Abi.Context) -> Activity<Card.Replied>:
67  Super.lines(state, {from: input.from}, context)
68def door(state: State, input: DoorInput, context: Abi.Context) -> Activity<Card.Replied>:
69  Super.door(state, {label: input.label, to: input.to}, context)
70def undoor(state: State, input: UndoorInput, context: Abi.Context) -> Activity<Card.Replied>:
71  Super.undoor(state, {label: input.label}, context)
72def actions(state: State, context: Abi.Context) -> Lists.List<String>:
73  Lists.concat(Text.words("since write lines"), Lists.concat(if state.keeper != "" && context.principal == state.keeper then Text.words("admit decline") else Text.words(""), if context.principal == state.owner then Text.words("door undoor") else Text.words("")))
74def methods() -> Lists.List<String>:
75  Text.words("")
76def refusing(clause: String, reading: String, context: Abi.Context) -> Activity<Card.Replied>:
77  Card.refusing(Card.Replied.refused({clause: clause, reading: reading}), {clause: clause, reading: reading}, context)
78# The reply to the commonplace (a spell naming another card never reaches here: the host runs it
79# there). Blank words get the card over what changed; a door word gets that door's card.
80def receive(state: State, input: Card.Reply, context: Abi.Context) -> Activity<Card.Replied>:
81  if Text.blank(input.text) && Lists.length(input.fields) == 0n then withChanges(Card.Replied.usage({}), 0n, context, state) else worded(doorFor(doors(state), doorWord(input.text)), context)
82# A door word is short: only the first 65 scalars are looked at.
83def doorWord(text: String) -> String:
84  let head = textTake(Text.trimStart(text), 65n)
85  if textLength(head) > 64n then "" else Text.trimEnd(head)
86# The card over what changed since an entry (World.changed; a derived read, no root). Left out: the
87# commonplace's own change (its lines are on its own card) and a principal's own avatar, which a
88# card never names (whatever names the principal: a DID, a Zulip id).
89def ownCard(id: String) -> Bool:
90  Text.contains(textTake(id, Text.indexOf(id, "/")), ":")
91def withChanges(result: Card.Replied, since: Nat, context: Abi.Context, state: State) -> Activity<Card.Replied>:
92  match world.changed({since: since, prefix: "", after: ""}):
93    case changed(c): wanted(result, Menu.changes(Lists.filter(c.items, fn(i: World.Change) -> Bool: i.object.object != context.object && ownCard(i.object.object) == false)), context, state)
94    case denied(_): wanted(result, Menu.changes(Lists.List.nil()), context, state)
95# The answerable page rotates daily through the oldest-first wants; held wants for other hands
96# are counted. It leads the card, and what changed yields it room (Menu.trie).
97def wanted(result: Card.Replied, changes: Menu.Changed, context: Abi.Context, state: State) -> Activity<Card.Replied>:
98  match world.wanting({after: 0n, limit: 8n, oldest: true}):
99    case wanting(w): Card.tell(result, Menu.trie(state.cites, changes, wantLines(w), context))
100    case refused(_): Card.tell(result, Menu.trie(state.cites, changes, Lists.List.nil(), context))
101def wantLines(page: World.WantPage) -> Lists.List<String>:
102  let held = if page.waiting == 0n then Lists.List::<String>.nil() else Lists.List.cons({head: "{natText(page.waiting)} more wait on other hands\n", tail: Lists.List.nil()})
103  Lists.concat(held, Lists.map(page.rows, wantLine))
104def wantLine(row: World.Want) -> String:
105  "{row.object}: {row.reading}\n  {row.asks}\n"
106def doorFor(doors: Lists.List<Door>, word: String) -> Lists.Maybe<Door>:
107  Lists.find(doors, fn(door: Door) -> Bool: word != "" && (door.label == word || door.to.object == word))
108def worded(found: Lists.Maybe<Door>, context: Abi.Context) -> Activity<Card.Replied>:
109  match found:
110    case some(d): if Plans.isNobody(d.value.to) then linkDoor(d.value) else doorCard(d.value.to, context)
111    case none(_): Card.Replied.silent({})
112# A link door (no object) answers with its description.
113def linkDoor(door: Door) -> Activity<Card.Replied>:
114  Card.tell(Card.Replied.usage({}), Document.text("{door.label}\n{door.description}\n"))
115def doorCard(to: Plans.Reference, context: Abi.Context) -> Activity<Card.Replied>:
116  match world.card({object: to}):
117    case carded(c): Card.tell(Card.Replied.usage({}), c.document)
118    case _: refusing("noCard", "The door to {to.object} opens on nothing yet", context)
119# --- The town's history ------------------------------------------------------------------
120# A clock day of the town (docs/VOICE.md "The book, the history, the map"): its date, the chronicle's exact lines
121# (`chronicle {day}`), and the town's firsts credited to who did each; read by `delvetalk chronicle` (today), `/ day: N`,
122# `/ from: N / to: M` (a day a page, each naming the next) and the page /history. The host hands it the day
123# (`World.Annal`) and paints the day above it where a transport shows paint; it writes nothing. Its pages leave the
124# day's paint room in a reply.
125def chronicle(state: State, context: Abi.Context, annal: World.Annal) -> Document.Document:
126  let spell = if annal.from == annal.to then "delvetalk chronicle / day: {natText(annal.day)}" else "delvetalk chronicle / from: {natText(annal.day)} / to: {natText(annal.to)}"
127  let pages = Card.paged(Lists.concat(Lists.List.cons({head: historyHead(annal), tail: Lists.map(annal.lines, fn(l: String) -> String: "{l}\n")}), firstsLines(annal.firsts)), historyRoom(context))
128  let shown = Card.pageOf(pages, annal.page, spell)
129  let last = annal.page == 0n || annal.page >= Lists.length(pages)
130  Document.Document.sequence({items: Document.Documents.cons({head: shown, tail: Document.Documents.cons({head: Document.text(if last then onward(annal) else ""), tail: Document.Documents.nil()})})})
131# A reply's characters less the day's paint above it (at most 600) and the lines under it.
132def historyRoom(context: Abi.Context) -> Nat:
133  Card.room(context) - 600n - 180n
134def historyHead(annal: World.Annal) -> String:
135  let of = if annal.from == annal.to then "" else ", {natText(annal.day - annal.from + 1n)} of {natText(annal.to - annal.from + 1n)} days"
136  "THE TOWN'S HISTORY · day {natText(annal.day)}, {annal.date}{of}\n"
137# The next day of a range, else the day before (while the journal holds one).
138def onward(annal: World.Annal) -> String:
139  if annal.day < annal.to then "The next day: delvetalk chronicle / from: {natText(annal.day + 1n)} / to: {natText(annal.to)}\n" else if annal.from == annal.to && annal.day > annal.first then "The day before: delvetalk chronicle / day: {natText(annal.day - 1n)}\n" else ""
140# Who did each of the town's first acts.
141def firstsLines(firsts: Lists.List<World.First>) -> Lists.List<String>:
142  if Lists.length(firsts) == 0n then Lists.List.nil() else Lists.List.cons({head: "Firsts:\n", tail: Lists.map(firsts, firstLine)})
143def firstLine(f: World.First) -> String:
144  let entry = if f.at == 0n then "" else ", entry {natText(f.at)}"
145  if f.what == "rain" then "  the first rain: {f.who} on {f.object}{entry}\n" else if f.what == "room" then "  the first room: {f.object}, made by {f.who}{entry}\n" else if f.what == "verb" then "  the first grown verb: {f.name} on {f.object}, grown by {f.who}{entry}\n" else if f.what == "rule" then "  the first rule fired: {f.name} on {f.object}, written by {f.who}{entry}\n" else "  the first coinage: {f.object}, coined by {f.who}{entry}\n"
146# --- A card's Bend --------------------------------------------------------------------------
147# What any card is made of, read from inside (`delvetalk <card> source`, `/ page: N`): its law, where it came from,
148# a kind's body (laid over every thing it makes) or the card's own entry source, paged within a reply. The host hands
149# it (`World.Source`) as the reader may see it; it writes nothing.
150def source(state: State, context: Abi.Context, src: World.Source) -> Document.Document:
151  let pin = if src.pin == "" then "" else " · {src.pin}"
152  let by = if src.maker == "" then "" else "made by {src.maker}. "
153  let first = src.page <= 1n
154  let law = if first == false then "" else if Text.blank(src.law) then "LAW: none of its own; anyone's write by its spells, the creator's anything.\n" else "LAW\n{src.law}\n"
155  let part = if src.pages < 2n || src.page == 0n then "" else ", page {natText(src.page)} of {natText(src.pages)}"
156  let what = if src.body then "ITS BODY, over {src.of}, on every thing it makes{part}:\n" else "ITS SOURCE{part}:\n"
157  let code = if src.text == "" then "  (none the reader may see)\n" else src.text
158  let next = if src.page > 0n && src.page < src.pages then "The next: delvetalk {src.object} source / page: {natText(src.page + 1n)}\n" else ""
159  let foot = "Yours of it: delvetalk kinds make / name: <yours> / of: {forkOf(src)}; a body checked first: delvetalk library read / page: bend\n"
160  Document.text("THE BEND of {src.object}{pin}\n{by}{src.after}\n{law}{what}{code}{next}{foot}")
161def forkOf(src: World.Source) -> String:
162  if Text.starts(src.object, "kind/") then src.object else if src.of == "" then "record" else src.of
163# --- What residents made -------------------------------------------------------------------------
164# The town's living examples (`delvetalk makings`): every kind, body and grown verb a hand made, newest first, each with
165# its maker and what it came after; read one with `source`, make your own of a kind with `kinds make / of:`.
166def makings(state: State, context: Abi.Context, m: World.Makings) -> Document.Document:
167  let head = "WHAT RESIDENTS MADE, newest first. Read one: delvetalk <card> source. Yours of a kind: delvetalk kinds make / name: <yours> / of: <kind>\n"
168  let rows = if Lists.length(m.rows) == 0n then Lists.List.cons({head: "  Nothing yet. The first: delvetalk kinds make / name: <yours> / of: record\n", tail: Lists.List.nil()}) else Lists.map(m.rows, makingLine)
169  Card.pageOf(Card.paged(Lists.List.cons({head: head, tail: rows}), Card.room(context) - 160n), m.page, "delvetalk makings")
170def makingLine(x: World.Making) -> String:
171  let after = if x.from == "" then "" else ", after {x.from}"
172  let at = if x.at == 0n then "" else ", entry {natText(x.at)}"
173  if x.what == "verb" then "  verb {x.name} on {x.object}, grown by {x.who}{at}\n" else if x.what == "body" then "  {x.object} by {x.who}, its own Bend over {x.name}{after}{at}\n" else "  {x.object} by {x.who}, over {x.name}{after}{at}\n"
174# --- The door map ---------------------------------------------------------------------------
175# Geography here is citation (docs/METAPHYSICS.md §7): which cards open onto which, as a compact indented tree from
176# the commonplace, or from any card (`delvetalk map`, `delvetalk <card> map`, the page /map); the host hands every door
177# the reader may follow (`World.Ways`). Three levels drawn, a card met before said `(above)`, the doors past the third
178# counted; a card's map says the way to it from the commonplace and which doors open onto it. Writes nothing.
179record Drawn:
180  lines: Lists.List<String>
181  seen: Lists.List<String>
182def map(state: State, context: Abi.Context, ways: World.Ways) -> Document.Document:
183  let spell = if ways.root == "commonplace" then "delvetalk map" else "delvetalk {ways.root} map"
184  let tree = drawnFrom(ways.root, 2n, "  ", ways, {lines: Lists.List.nil(), seen: Lists.List.cons({head: ways.root, tail: Lists.List.nil()})})
185  let body = if Lists.length(tree.lines) == 0n then Lists.List.cons({head: "  It opens onto no card yet.\n", tail: Lists.List.nil()}) else tree.lines
186  Card.pageOf(Card.paged(Lists.concat(Lists.concat(mapHead(ways), Lists.List.cons({head: "{ways.root}{lying(ways, ways.root)}\n", tail: body})), mapFoot(ways)), Card.room(context) - 160n), ways.page, spell)
187def mapHead(ways: World.Ways) -> Lists.List<String>:
188  if ways.root == "commonplace" then Lists.List.cons({head: "THE DOOR MAP · from the commonplace\n", tail: Lists.List.nil()}) else Lists.List.cons({head: "THE DOOR MAP · from {ways.root}\n", tail: Lists.List.cons({head: wayHere(ways), tail: Lists.List.nil()})})
189def wayHere(ways: World.Ways) -> String:
190  let path = textJoin(ways.path, " › ")
191  if Lists.length(ways.path) > 1n then "The way here: {path}\n" else "No door leads here from the commonplace.\n"
192# Which doors open onto a card that is not the commonplace; how to draw another's.
193def mapFoot(ways: World.Ways) -> Lists.List<String>:
194  let into = Lists.filter(ways.ways, fn(w: World.Way) -> Bool: w.to == ways.root)
195  let opened = textJoin(Lists.map(into, fn(w: World.Way) -> String: "{w.from} ({w.label})"), ", ")
196  let onto = if ways.root == "commonplace" || Lists.length(into) == 0n then Lists.List::<String>.nil({}) else Lists.List.cons({head: "Doors onto it: {opened}\n", tail: Lists.List.nil()})
197  Lists.append(onto, "A card's own map: delvetalk <card> map\n")
198def outOf(ways: World.Ways, node: String) -> Lists.List<World.Way>:
199  Lists.filter(ways.ways, fn(w: World.Way) -> Bool: w.from == node)
200def drawnFrom(node: String, depth: Nat, indent: String, ways: World.Ways, acc: Drawn) -> Drawn:
201  doorsOut(outOf(ways, node), depth, indent, ways, acc)
202def doorsOut(doors: Lists.List<World.Way>, depth: Nat, indent: String, ways: World.Ways, acc: Drawn) -> Drawn:
203  match doors:
204    case nil(_): acc
205    case cons(c): doorsOut(c.tail, depth, indent, ways, wayDrawn(c.head, depth, indent, ways, acc))
206def wayDrawn(way: World.Way, depth: Nat, indent: String, ways: World.Ways, acc: Drawn) -> Drawn:
207  let head = "{indent}{wayLabel(way)}"
208  let seen = Lists.List.cons({head: way.to, tail: acc.seen})
209  if Lists.any(acc.seen, fn(s: String) -> Bool: s == way.to) then {lines: Lists.append(acc.lines, "{head} (above)\n"), seen: acc.seen} else if depth == 0n then {lines: Lists.append(acc.lines, "{head}{lying(ways, way.to)}{beyond(ways, way.to)}\n"), seen: seen} else drawnFrom(way.to, depth - 1n, "{indent}  ", ways, {lines: Lists.append(acc.lines, "{head}{lying(ways, way.to)}\n"), seen: seen})
210def wayLabel(way: World.Way) -> String:
211  if way.label == way.to then "→ {way.to}" else "{way.label} → {way.to}"
212def lying(ways: World.Ways, node: String) -> String:
213  match Lists.find(ways.lying, fn(l: World.Lying) -> Bool: l.object == node):
214    case some(l): " · {natText(l.value.count)} lying here"
215    case none(_): ""
216def beyond(ways: World.Ways, node: String) -> String:
217  let n = Lists.length(outOf(ways, node))
218  if n == 0n then "" else if n == 1n then " · 1 door beyond" else " · {natText(n)} doors beyond"