errand/3

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 errand's body, over RECORD (docs/OVERHAUL.md §2, an errand is a rule with a pay; TENURE §3B):
15# a record made with what it asks (`asks`), the thing it is about (`on`), the condition that does it
16# (`done`, in the law grammar, judged at each write on `on`) and the spell that pays (`pays`, which may
17# name the doer as `{request.subject}`), all fixed. As its kind finishes it, it places one rule on `on`
18# under its maker (`made`): when `done` holds of a write there, it casts `delvetalk <errand> settle / by:
19# {request.subject}`, the maker's turn.
20#
21# Its maker's `pay` rule occupies that name while open. `settle` takes the call from the maker's
22# rule on `on` alone: it replaces `pay` with the claimant's spell, marks `done` by them (a mark kept,
23# never dropped), and takes its rule off `on`, in one turn. Registration must succeed before the
24# claim is written; the pay fires at that write as `rule:<errand>:pay:<height>`. A second completion
25# pays nobody. The pay is judged by what it touches; refused, the claim stands and its receipt says
26# why. `repay` replaces or reconstructs the same rule for the recorded claimant.
27type State = Super.State
28sum Payment:
29  open: {}
30  claim: {by: String}
31  retry: {by: String}
32form arm:
33form repay:
34form settle:
35  by: text 1..128
36form write:
37  text: text 1..280
38form lines:
39  from: natural 0..1000000000
40form door:
41  label: text 1..32
42  to: text 1..128
43form undoor:
44  label: text 1..32
45def write(state: State, input: WriteInput, context: Abi.Context) -> Activity<Nat>:
46  Super.write(state, {text: input.text}, context)
47def lines(state: State, input: LinesInput, context: Abi.Context) -> Activity<Card.Replied>:
48  Super.lines(state, {from: input.from}, context)
49def door(state: State, input: DoorInput, context: Abi.Context) -> Activity<Card.Replied>:
50  Super.door(state, {label: input.label, to: input.to}, context)
51def undoor(state: State, input: UndoorInput, context: Abi.Context) -> Activity<Card.Replied>:
52  Super.undoor(state, {label: input.label}, context)
53def actions(state: State, context: Abi.Context) -> Lists.List<String>:
54  Lists.concat(if context.principal == state.owner then Text.words("settle write lines door undoor") else Text.words("settle write lines"), if context.principal == state.maker then Text.words("arm repay") else Text.words(""))
55def methods() -> Lists.List<String>:
56  Text.words("~made ~act")
57def on(state: State) -> String:
58  Super.field(state, "on")
59# The completion rule's name on `on`: the errand's id as an identifier.
60def settles(context: Abi.Context) -> String:
61  Text.identifier(context.object)
62def made(state: State, input: {}, context: Abi.Context) -> Activity<Bool>:
63  if context.caller != state.kind then false else replacingPay(state, Payment.open({}), context)
64def placing(state: State, context: Abi.Context) -> Activity<Bool>:
65  match world.rule({object: {world: context.world, object: on(state)}, name: settles(context), when: Super.field(state, "done"), then: "delvetalk {context.object} settle / by: {{request.subject}}"}):
66    case placed(_): Super.armedNow(state, context)
67    case refused(r): Super.unarmed(state, on(state), r.clause, r.reading, context)
68# Its maker replaces its rules while open.
69def arm(state: State, context: Abi.Context) -> Activity<Bool>:
70  if context.principal != state.maker then Super.armRefused(state, context) else if Super.marked(state, "done") then false else rearming(state, context)
71def rearming(state: State, context: Abi.Context) -> Activity<Bool>:
72  match world.unrule({object: {world: context.world, object: on(state)}, name: settles(context)}):
73    case _: replacingPay(state, Payment.open({}), context)
74# Its maker's rule on `on` settles it; anyone else, or another's rule there, is told what does. The
75# first to come claims it; a principal is one word (a DID, a handle, a thing's `@<id>`).
76def settle(state: State, input: SettleInput, context: Abi.Context) -> Activity<Bool>:
77  if Super.ruledFrom(state, on(state), context) == false then Card.refusing(false, {clause: "ruled", reading: ruled(state)}, context) else if Super.marked(state, "done") then false else if oneWord(input.by) == false then Card.refusing(false, {clause: "by", reading: "a doer is one principal"}, context) else claiming(state, input.by, context)
78def ruled(state: State) -> String:
79  "it settles when {Super.field(state, \"done\")} holds of a write on {on(state)}"
80def oneWord(by: String) -> Bool:
81  by != "" && Text.contains(by, " ") == false && Text.contains(by, "\n") == false && Text.contains(by, "{{") == false && Text.contains(by, "}}") == false
82# The rule's registration precedes the claim; a refused registration leaves completion open.
83def claiming(state: State, by: String, context: Abi.Context) -> Activity<Bool>:
84  replacingPay(state, Payment.claim({by: by}), context)
85# The maker removes any placed pay rule before registering the spell for this phase. The same
86# rule reserves the name while open, pays the claim, and casts a retry for its recorded hand.
87def replacingPay(state: State, payment: Payment, context: Abi.Context) -> Activity<Bool>:
88  match world.unrule({object: Plans.self(context), name: "pay"}):
89    case _: placingPay(state, payment, context)
90def placingPay(state: State, payment: Payment, context: Abi.Context) -> Activity<Bool>:
91  match world.rule({object: Plans.self(context), name: "pay", when: payWhen(), then: payFor(state, payment)}):
92    case placed(_): paymentPlaced(state, payment, context)
93    case refused(r): paymentRefused(state, payment, r, context)
94def paymentPlaced(state: State, payment: Payment, context: Abi.Context) -> Activity<Bool>:
95  match payment:
96    case open(_): placing(state, context)
97    case claim(c): claimed(state, c.by, context)
98    case retry(_): repaying(state, context)
99def paymentRefused(state: State, payment: Payment, refusal: Card.Refusal, context: Abi.Context) -> Activity<Bool>:
100  match payment:
101    case open(_): Super.unarmed(state, context.object, refusal.clause, refusal.reading, context)
102    case _: Card.refusing(false, refusal, context)
103def claimed(state: State, by: String, context: Abi.Context) -> Activity<Bool>:
104  let written(_) = write {marks: insert {name: "done", who: by, handle: "", at: context.height}}
105  unsettling(state, context)
106def unsettling(state: State, context: Abi.Context) -> Activity<Bool>:
107  match world.unrule({object: {world: context.world, object: on(state)}, name: settles(context)}):
108    case _: true
109# The pay fires at the claim and at each `repay`, never at another write.
110def payWhen() -> String:
111  "\"done\" in new.marks.name and (request.method == \"settle\" or request.method == \"repay\")"
112# The open rule holds the maker's spell; settlement and retry bind its recorded doer.
113def payFor(state: State, payment: Payment) -> String:
114  match payment:
115    case open(_): Super.field(state, "pays")
116    case claim(c): replaced(Super.field(state, "pays"), "{{request.subject}}", c.by)
117    case retry(r): replaced(Super.field(state, "pays"), "{{request.subject}}", r.by)
118def replaced(text: String, needle: String, by: String) -> String:
119  let at = Text.indexOf(text, needle)
120  if at == textLength(text) then text else "{textTake(text, at)}{by}{replaced(textDrop(text, at + textLength(needle)), needle, by)}"
121# The maker casts the pay again for the hand that claimed it (a pay refused, or one its maker owes again).
122def repay(state: State, context: Abi.Context) -> Activity<Bool>:
123  if context.principal != state.maker then Card.refusing(false, {clause: "notMaker", reading: "Only its maker pays it again"}, context) else retrying(state, context)
124def retrying(state: State, context: Abi.Context) -> Activity<Bool>:
125  match Relations.lookup(state.marks, {name: "done"}):
126    case some(m): replacingPay(state, Payment.retry({by: m.value.who}), context)
127    case none(_): Card.refusing(false, {clause: "open", reading: "Nobody has done it yet"}, context)
128def repaying(state: State, context: Abi.Context) -> Activity<Bool>:
129  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: "repay", text: "pay requested again", at: context.height, n: state.next}, next: add 1n}
130  true
131def doneBy(state: State, context: Abi.Context) -> String:
132  match Relations.lookup(state.marks, {name: "done"}):
133    case some(m): "done by {Card.shown(m.value.who, m.value.handle, context)} at entry {natText(m.value.at)}"
134    case none(_): "open"
135def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
136  let asks = Super.field(state, "asks")
137  let condition = Super.field(state, "done")
138  let pays = Super.field(state, "pays")
139  Document.text("ERRAND from {Card.shown(state.maker, state.makerHandle, context)}{Card.mine(state.maker, context)}, {doneBy(state, context)}: {asks}\nOn {on(state)}, done when: {condition}\nPays: {pays}\n{payLine(state, id)}{Super.inactiveLine(state, id)}")
140# Where its pay stands, once claimed: `rules` reads its firing and receipt, or why it did not fire.
141def payLine(state: State, id: String) -> String:
142  if Super.marked(state, "done") then "Its pay: delvetalk {id} rules\n" else ""

--- the entry module
+++ this layer
@@ -39 +39 @@
-  from: natural 0..1000000000
+  from: natural 1..1000000000

set it in type, all 142 lines