kind/bell

1layer over ./Kind.obend
2edition ObjectiveBend 1
3import ./Abi.obend as Abi
4import ./List.obend as Lists
5import ./Form.obend as Form
6import ./Rows.obend as Rows
7type State = Super.State
8form make:
9  colour: red | orange | yellow | green | cyan | blue | violet | amber | silver | magenta | purple | pink
10  seed: text 1..80
11def make(state: State, input: MakeInput, context: Abi.Context) -> Activity<Super.Done>:
12  Super.making(state, Lists.List.cons({head: {name: "colour", value: makeColourText(input.colour)}, tail: Lists.List.cons({head: {name: "seed", value: input.seed}, tail: Lists.List.nil()})}), "", context)
13def makeColourText(c: MakeColour) -> String:
14  match c:
15    case red(_): "red"
16    case orange(_): "orange"
17    case yellow(_): "yellow"
18    case green(_): "green"
19    case cyan(_): "cyan"
20    case blue(_): "blue"
21    case violet(_): "violet"
22    case amber(_): "amber"
23    case silver(_): "silver"
24    case magenta(_): "magenta"
25    case purple(_): "purple"
26    case pink(_): "pink"
27form place:
28  colour: red | orange | yellow | green | cyan | blue | violet | amber | silver | magenta | purple | pink
29  seed: text 1..80
30  id: text 1..64
31def place(state: State, input: PlaceInput, context: Abi.Context) -> Activity<Super.Done>:
32  Super.making(state, Lists.List.cons({head: {name: "colour", value: placeColourText(input.colour)}, tail: Lists.List.cons({head: {name: "seed", value: input.seed}, tail: Lists.List.cons({head: {name: "id", value: input.id}, tail: Lists.List.nil()})})}), "", context)
33def placeColourText(c: PlaceColour) -> String:
34  match c:
35    case red(_): "red"
36    case orange(_): "orange"
37    case yellow(_): "yellow"
38    case green(_): "green"
39    case cyan(_): "cyan"
40    case blue(_): "blue"
41    case violet(_): "violet"
42    case amber(_): "amber"
43    case silver(_): "silver"
44    case magenta(_): "magenta"
45    case purple(_): "purple"
46    case pink(_): "pink"

Each thing of this kind runs this layer over what the kind is of.

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 ./Card.obend as Card
8import ./Scenes.obend as Scenes
9import ./Plan.obend as Plans
10import ./Relation.obend as Relations
11import ./Rows.obend as Rows
12import ./Text.obend as Text
13import ./Harmony.obend as Harmony
14# The bell's body, over RECORD (docs/CATALOGUE.md §5): a bell is a record whose lines are rains,
15# 768 of them at 1 to 200 characters (within the host's 256 KiB), and whose one mark is `rung`.
16# `kind/bell` makes a record with the fields colour and seed and grafts this on it; what a bell
17# does of itself is its kind's text, carried to every bell by `under` and owned by the kind's
18# owner: rule `seven` rings it at its seventh rain, rule `rang` notes its planter's avatar when it
19# rings, and it wants a first rain, a rain from a second hand, and tending when it has gone quiet.
20#
21# A hand's rain tends the bell; untended for `quietAfter()` minutes it goes quiet and takes `tend`
22# alone, as kind/bell's law says (`alive`), and its card says for how many days, by the clock the
23# law reads (never, when made before the clock was set). A rain a thing
24# sends (the weather's) is that thing's line and tends nothing, so a bell nobody visits goes quiet
25# under any weather; a quiet bell takes a thing's rain as nothing.
26#
27# Its colour is its tone (docs/HARMONIC.md): RECORD's `tone`, given at its making from the colour, which its card says
28# beside its sound; its `complement` (a view) is the light that mixes with its own to white, computed on the CIE
29# observer, and the interval that lands on.
30type State = Super.State
31def relations() -> Relations.Decls:
32  Super.relationsWith(768n)
33form rain:
34  text: text 1..200
35form write:
36  text: text 1..200
37form ring:
38form tend:
39form lines:
40  from: natural 0..1000000000
41form door:
42  label: text 1..32
43  to: text 1..128
44form undoor:
45  label: text 1..32
46def rain(state: State, input: RainInput, context: Abi.Context) -> Activity<Nat>:
47  if context.sender != "" then sent(state, input.text, context) else if quiet(state, context) then hushed(context) else Super.inscribe(state, "rain", input.text, context)
48# A bell's lines are its rains: a write on it is a rain, under the same bound and the same tending
49# (Record's own `write` would take a line of any length that tends nothing).
50def write(state: State, input: WriteInput, context: Abi.Context) -> Activity<Nat>:
51  rain(state, {text: input.text}, context)
52def sent(state: State, text: String, context: Abi.Context) -> Activity<Nat>:
53  if quiet(state, context) then 0n else sentWritten(state, text, context)
54def sentWritten(state: State, text: String, context: Abi.Context) -> Activity<Nat>:
55  let written(_) = write {lines: insert {author: context.sender, handle: context.sender, verb: "rain", text: text, at: context.height, n: state.next}, next: add 1n}
56  state.next
57def hushed(context: Abi.Context) -> Activity<Nat>:
58  let id = Card.called(context, "bell")
59  Card.refusing(0n, {clause: "alive", reading: "{aliveReading()}; tend it: delvetalk {id} tend"}, context)
60# How long a bell answers untended, in clock minutes: the window kind/bell's `alive` clause names.
61def quietAfter() -> Nat:
62  1440n
63def aliveReading() -> String:
64  "answers while tended within {natText(quietAfter())} minutes"
65def quiet(state: State, context: Abi.Context) -> Bool:
66  context.clock > state.tended + quietAfter()
67# Since which clock minute a quiet bell has been untended (0 for one never tended); 0 while it answers.
68def quietSince(state: State, context: Abi.Context) -> Nat:
69  if quiet(state, context) then state.tended else 0n
70# How long a quiet bell has been untended, in whole days of the clock; one tended at clock 0, before
71# the transport set the clock (made at a genesis), was never tended.
72def untended(state: State, context: Abi.Context) -> String:
73  let days = (context.clock - state.tended) / 1440n
74  if state.tended == 0n then "never tended" else if days == 1n then "untended a day" else "untended {Text.countWord(days)} days"
75def views() -> Lists.List<String>:
76  Text.words("quietSince complement")
77def complement(state: State) -> String:
78  Harmony.complement(Super.field(state, "colour"))
79def tend(state: State, context: Abi.Context) -> Activity<Card.Replied>:
80  Super.tend(state, context)
81def lines(state: State, input: LinesInput, context: Abi.Context) -> Activity<Card.Replied>:
82  Super.lines(state, {from: input.from}, context)
83def door(state: State, input: DoorInput, context: Abi.Context) -> Activity<Card.Replied>:
84  Super.door(state, {label: input.label, to: input.to}, context)
85def undoor(state: State, input: UndoorInput, context: Abi.Context) -> Activity<Card.Replied>:
86  Super.undoor(state, {label: input.label}, context)
87# A bell rings once: its mark `rung`, by whoever rang it; rung again, it says when it rang and writes nothing.
88def ring(state: State, context: Abi.Context) -> Activity<Bool>:
89  match Relations.lookup(state.marks, {name: "rung"}):
90    case some(m): Card.tell(false, Document.text("Already rung, by {Card.shown(m.value.who, m.value.handle, context)} at entry {natText(m.value.at)}.\n"))
91    case none(_): Super.mark(state, "rung", context)
92def methods() -> Lists.List<String>:
93  Text.words("~act")
94def actions(state: State, context: Abi.Context) -> Lists.List<String>:
95  if context.principal == state.owner then Text.words("rain tend ring lines door undoor") else Text.words("rain tend ring lines")
96# A rain on the card: who, and what (the record's number is the order, not shown); a grown
97# verb's line says its verb.
98def entry(state: State, context: Abi.Context, line: Rows.Line) -> Document.Document:
99  let verb = if line.verb == "rain" then "" else " ({line.verb})"
100  Document.text("{Card.shown(line.author, line.handle, context)}{Card.mine(line.author, context)}{verb}: {line.text}\n")
101def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
102  let colour = Super.field(state, "colour")
103  let article = if colour == "amber" || colour == "orange" then "An" else "A"
104  let sound = if quiet(state, context) then "quiet, {untended(state, context)}" else if Super.marked(state, "rung") then "rung" else "silent"
105  let seed = Super.field(state, "seed")
106  let next = if quiet(state, context) then "Tend it:\n  delvetalk {id} tend\n" else "Rain on it:\n  delvetalk {id} rain / text: <1 to 200 characters>\n"
107  Document.text("{article} {colour} bell, planted by {Card.shown(state.maker, state.makerHandle, context)}{Card.mine(state.maker, context)}: “{seed}” — {sound}. {next}{Super.ringing(state)}")