{name}

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  name: text 1..64
10  fills: text 1..400
11  segments: natural 1..24
12  move: text 1..400
13  tide: object 1..128
14def make(state: State, input: MakeInput, context: Abi.Context) -> Activity<Super.Done>:
15  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "fills", value: input.fills}, tail: Lists.List.cons({head: {name: "segments", value: natText(input.segments)}, tail: Lists.List.cons({head: {name: "move", value: input.move}, tail: Lists.List.cons({head: {name: "tide", value: input.tide}, tail: Lists.List.nil()})})})})}), "", context)
16form place:
17  name: text 1..64
18  fills: text 1..400
19  segments: natural 1..24
20  move: text 1..400
21  tide: object 1..128
22  id: object 1..64
23def place(state: State, input: PlaceInput, context: Abi.Context) -> Activity<Super.Done>:
24  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "fills", value: input.fills}, tail: Lists.List.cons({head: {name: "segments", value: natText(input.segments)}, tail: Lists.List.cons({head: {name: "move", value: input.move}, tail: Lists.List.cons({head: {name: "tide", value: input.tide}, tail: Lists.List.cons({head: {name: "id", value: input.id}, tail: Lists.List.nil()})})})})})}), "", context)

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 ./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 front's body, over RECORD (docs/OVERHAUL.md §2, a front is a rule held by a director under law;
15# TENURE §3C, a visible clock): a record made with a name, the condition that fills a segment
16# (`fills`, in the law grammar, judged on its tide at each tick: `new.ticks % 24 == 0` is a clock
17# day), how many segments its clock has (`segments`), the spell it casts when the clock is full
18# (`move`) and the tide it reads (`tide`); its owner can set the tide again. As its kind finishes it, it places two rules
19# under its maker (`made`): on the tide, `request.method == "tick" and (<fills>)` casts `delvetalk
20# <front> fill`; on itself, a fill that brings its count of segments to a whole clock casts `move`.
21# So the move is the maker's turn, judged by the law of whatever it touches, and the clock empties
22# when full. Its count of fills only rises: the record's variable `fills` (its lines are kept only so
23# many), with `full` set by a fill that fills the clock and cleared by the next, which is what the
24# move rule reads. Only its maker's rule on the tide fills: a hand's `fill` is refused by name. The
25# card shows the clock: "2 of 4".
26type State = Super.State
27form fill:
28form arm:
29form write:
30  text: text 1..280
31form lines:
32  from: natural 0..1000000000
33form door:
34  label: text 1..32
35  to: text 1..128
36form undoor:
37  label: text 1..32
38def write(state: State, input: WriteInput, context: Abi.Context) -> Activity<Nat>:
39  Super.write(state, {text: input.text}, context)
40def lines(state: State, input: LinesInput, context: Abi.Context) -> Activity<Card.Replied>:
41  Super.lines(state, {from: input.from}, context)
42def door(state: State, input: DoorInput, context: Abi.Context) -> Activity<Card.Replied>:
43  Super.door(state, {label: input.label, to: input.to}, context)
44def undoor(state: State, input: UndoorInput, context: Abi.Context) -> Activity<Card.Replied>:
45  Super.undoor(state, {label: input.label}, context)
46def actions(state: State, context: Abi.Context) -> Lists.List<String>:
47  Lists.concat(Lists.concat(if context.principal == state.owner then Text.words("fill write lines door undoor set") else Text.words("fill write lines"), if context.principal == state.maker then Text.words("arm") else Text.words("")), Super.repairAction(state, context))
48def lenses() -> Lists.List<Form.Field>:
49  Super.objectLenses("tide")
50def setArms() -> Bool:
51  true
52def methods() -> Lists.List<String>:
53  Text.words("~made ~act")
54def tide(state: State) -> String:
55  Super.field(state, "tide")
56def segments(state: State) -> Nat:
57  match Text.number(Super.field(state, "segments")):
58    case yes(n): if n.value == 0n then 1n else n.value
59    case no(_): 1n
60# The fills so far, ever: its variable `fills` (a front carried from before it kept one counts its
61# `fill` lines); a whole clock of them has filled and emptied it.
62def fills(state: State) -> Nat:
63  match Lists.find(state.vars, fn(v: Scenes.Var) -> Bool: v.name == "fills"):
64    case some(v): Text.digits(v.value.value, 0n)
65    case none(_): Lists.length(Lists.filter(Relations.rows(state.lines), fn(l: Rows.Line) -> Bool: l.verb == "fill"))
66def full(state: State) -> Bool:
67  Lists.any(state.vars, fn(v: Scenes.Var) -> Bool: v.name == "full")
68def made(state: State, input: {}, context: Abi.Context) -> Activity<Bool>:
69  if context.caller != state.kind then false else placing(state, context)
70def placing(state: State, context: Abi.Context) -> Activity<Bool>:
71  let fills = Super.field(state, "fills")
72  match world.rule({object: {world: context.world, object: tide(state)}, name: Text.identifier(context.object), when: "request.method == \"tick\" and ({fills})", then: "delvetalk {context.object} fill"}):
73    case placed(_): moving(state, context)
74    case refused(r): Super.unarmed(state, tide(state), r.clause, r.reading, context)
75def moving(state: State, context: Abi.Context) -> Activity<Bool>:
76  let n = natText(segments(state))
77  match world.rule({object: Plans.self(context), name: "move", when: moveWhen(segments(state)), then: Super.field(state, "move")}):
78    case placed(_): Super.armedNow(state, context)
79    case refused(r): Super.unarmed(state, context.object, r.clause, r.reading, context)
80# Its maker places its rules again (taken off first, where they stood).
81def arm(state: State, context: Abi.Context) -> Activity<Bool>:
82  if Super.mayArm(state, context) == false then Super.armRefused(state, context) else if Text.isObjectId(tide(state)) == false then Super.stranding(state, context) else rearming(state, context)
83def rearming(state: State, context: Abi.Context) -> Activity<Bool>:
84  match world.unrule({object: {world: context.world, object: tide(state)}, name: Text.identifier(context.object)}):
85    case _: unmoving(state, context)
86def unmoving(state: State, context: Abi.Context) -> Activity<Bool>:
87  match world.unrule({object: Plans.self(context), name: "move"}):
88    case _: placing(state, context)
89# A fill that fills the clock: each fill of a one-segment clock, else the fill that sets `full`.
90def moveWhen(n: Nat) -> String:
91  if n == 1n then "request.method == \"fill\"" else "request.method == \"fill\" and \"full\" in new.vars.name and not (\"full\" in old.vars.name)"
92# Its maker's rule on the tide fills a segment; anyone else, or another's rule there, is told what does.
93def fill(state: State, context: Abi.Context) -> Activity<Nat>:
94  let fills = Super.field(state, "fills")
95  let clock = if Text.isObjectId(tide(state)) then "a segment fills at a tick of {tide(state)} when {fills}: {Card.tideLine(tide(state))}" else Card.tideLine(tide(state))
96  if Super.ruledFrom(state, tide(state), context) == false then Card.refusing(0n, {clause: "ruled", reading: clock}, context) else filled(state, context)
97def filled(state: State, context: Abi.Context) -> Activity<Nat>:
98  let at = fills(state) % segments(state) + 1n
99  let written(_) = write {lines: insert {author: context.sender, handle: "", verb: "fill", text: "segment {natText(at)} of {natText(segments(state))}, at clock {natText(context.clock)}", at: context.height, n: state.next}, next: add 1n}
100  counting(state, at)
101# The count rises by one; `full` is set by the fill that fills a clock of more than one segment and
102# cleared by the next (one edit of `vars` a write).
103def counting(state: State, at: Nat) -> Activity<Nat>:
104  let written(_) = world.write(extend(keep(), {vars: counter(state)}))
105  marking(state, at)
106def marking(state: State, at: Nat) -> Activity<Nat>:
107  let written(_) = world.write(extend(keep(), {vars: fullness(state, at == segments(state) && segments(state) > 1n)}))
108  at
109def counter(state: State) -> Plans.Entries<Scenes.Var, Scenes.Var>:
110  match Lists.find(state.vars, fn(v: Scenes.Var) -> Bool: v.name == "fills"):
111    case some(v): Plans.Entries.amendItem({item: v.value, change: {name: "fills", value: natText(fills(state) + 1n)}})
112    case none(_): Plans.Entries.append({item: {name: "fills", value: natText(fills(state) + 1n)}})
113def fullness(state: State, filling: Bool) -> Plans.Entries<Scenes.Var, Scenes.Var>:
114  if filling == full(state) then Plans.Entries.keep({}) else if filling then Plans.Entries.append({item: {name: "full", value: ""}}) else Plans.Entries.removeItem({item: {name: "full", value: ""}})
115def clock(state: State) -> String:
116  let filled = fills(state) / segments(state)
117  let times = if filled == 0n then "it has not filled yet" else if filled == 1n then "it has filled once" else "it has filled {Text.countWord(filled)} times"
118  "{natText(fills(state) % segments(state))} of {natText(segments(state))}; {times}"
119def entry(state: State, context: Abi.Context, line: Rows.Line) -> Document.Document:
120  if line.verb == "fill" then Document.text("{line.text}\n") else Super.entry(state, context, line)
121def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
122  let name = if state.head == "" then "A FRONT" else state.head
123  let fills = Super.field(state, "fills")
124  let move = Super.field(state, "move")
125  let ticks = if Text.isObjectId(tide(state)) then "A segment fills at a tick of {tide(state)} when: {fills}\n  {Card.tideLine(tide(state))}" else Card.tideLine(tide(state))
126  Document.text("{name}, a front set by {Card.shown(state.maker, state.makerHandle, context)}{Card.mine(state.maker, context)}: a slow pressure with a clock that fills while its condition holds, and casts its move when full. Its clock: {clock(state)}.\n{ticks}\nWhen full: {move}\nIts move's firing and delivery receipt: delvetalk {id} rules\n{Super.inactiveLine(state, id)}")