kind/bond

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  parties: text 1..400
10  terms: text 1..400
11  amends: object 0..128
12  law: text 0..4096
13def make(state: State, input: MakeInput, context: Abi.Context) -> Activity<Super.Done>:
14  Super.making(state, Lists.List.cons({head: {name: "parties", value: input.parties}, tail: Lists.List.cons({head: {name: "terms", value: input.terms}, tail: Lists.List.cons({head: {name: "amends", value: input.amends}, tail: Lists.List.cons({head: {name: "law", value: input.law}, tail: Lists.List.nil()})})})}), "", context)
15form place:
16  parties: text 1..400
17  terms: text 1..400
18  amends: object 0..128
19  law: text 0..4096
20  id: object 1..64
21def place(state: State, input: PlaceInput, context: Abi.Context) -> Activity<Super.Done>:
22  Super.making(state, Lists.List.cons({head: {name: "parties", value: input.parties}, tail: Lists.List.cons({head: {name: "terms", value: input.terms}, tail: Lists.List.cons({head: {name: "amends", value: input.amends}, tail: Lists.List.cons({head: {name: "law", value: input.law}, 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 ./Relation.obend as Relations
11import ./Rows.obend as Rows
12import ./Text.obend as Text
13import ./Scenes.obend as Scenes
14# The bond's body, over RECORD (docs/METAPHYSICS.md §7.4, "bind"; the countersign protocol glm and
15# inkling ran by hand): `kind/bond make / parties: <handles> / terms: / amends: / law:` fixes its
16# parties (fifteen handles at most: one naming more is void), terms and amendment among the made
17# record's fields. Each party
18# countersigns once, a mark `signed <handle>` whose `who` is the signer (kind/bond's law: a party
19# signs only for themselves); the last signature puts it at rest, and at rest it amends `amends` to
20# `law`, the bond as caller, under that object's own law. A party withdraws it before rest. At rest
21# its signers are a circle a law may name (LAW §4 D): `request.subject in "<bond>".marks.who`, as a
22# THING's `circle` does.
23type State = Super.State
24form countersign:
25form withdraw:
26form door:
27  label: text 1..32
28  to: text 1..128
29form undoor:
30  label: text 1..32
31def parties(state: State) -> Lists.List<String>:
32  Lists.map(Text.words(Super.field(state, "parties")), fn(w: String) -> String: Text.trimEndOf(w, ","))
33# A bond binds fifteen parties at most: each signs once and `withdrawn` makes the sixteenth mark. Creation
34# is not law-judged, so one naming more is made void here: never at rest, nothing to sign.
35def named(state: State) -> Nat:
36  Lists.length(parties(state))
37def void(state: State) -> Bool:
38  named(state) > 15n
39def party(state: State, handle: String) -> Bool:
40  handle != "" && Lists.any(parties(state), fn(p: String) -> Bool: p == handle)
41def signed(state: State, handle: String) -> Bool:
42  Super.marked(state, "signed {handle}")
43def unsigned(state: State) -> Lists.List<String>:
44  Lists.filter(parties(state), fn(p: String) -> Bool: signed(state, p) == false)
45def markKey(m: Rows.Mark) -> {name: String}:
46  {name: m.name}
47def withdrawn(state: State) -> Bool:
48  Super.marked(state, "withdrawn")
49# At rest: every party signed and none withdrew. A derived view, so a thing naming the bond its
50# circle reads it (`viewDerived`).
51def atRest(state: State, context: Abi.Context) -> Bool:
52  void(state) == false && Lists.length(unsigned(state)) == 0n && withdrawn(state) == false
53def views() -> Lists.List<String>:
54  Text.words("atRest")
55# Why a bond refuses: each arm a clause and its reading.
56sum Why:
57  tooMany: {n: Nat}
58  withdrawn: {}
59  notParty: {act: String}
60  alreadySigned: {}
61  atRest: {}
62def refusal(w: Why) -> Card.Refusal:
63  match w:
64    case tooMany(m): {clause: "tooMany", reading: "This bond names {natText(m.n)} parties; a bond binds fifteen at most: make another"}
65    case withdrawn(_): {clause: "withdrawn", reading: "The bond was withdrawn"}
66    case notParty(n): {clause: "notParty", reading: "Only a party {n.act}"}
67    case alreadySigned(_): {clause: "alreadySigned", reading: "Already countersigned"}
68    case atRest(_): {clause: "atRest", reading: "The bond is at rest"}
69def told(w: Why, state: State, context: Abi.Context) -> Activity<Card.Replied>:
70  Super.refused(refusal(w), context)
71def answered(done: Card.Replied, line: String, after: State, context: Abi.Context) -> Activity<Card.Replied>:
72  Card.tell(done, Document.concat(Document.text("{line}\n\n"), Super.render(after, context)))
73# A party countersigns once; the last signature puts the bond at rest and applies its amendment.
74def countersign(state: State, context: Abi.Context) -> Activity<Card.Replied>:
75  if void(state) then told(Why.tooMany({n: named(state)}), state, context) else if withdrawn(state) then told(Why.withdrawn({}), state, context) else if party(state, context.handle) == false then told(Why.notParty({act: "countersigns"}), state, context) else if signed(state, context.handle) then told(Why.alreadySigned({}), state, context) else signing(state, context)
76def signing(state: State, context: Abi.Context) -> Activity<Card.Replied>:
77  let sign = {name: "signed {context.handle}", who: context.principal, handle: context.handle, at: context.height}
78  let written(_) = write {marks: insert sign}
79  let after = extend(state, {marks: Relations.insert(state.marks, sign, markKey)})
80  let left = Lists.length(unsigned(after))
81  if left > 0n then answered(Card.Replied.done({action: "countersign"}), "Countersigned, {context.handle}; {Text.countWord(left)} of the parties still to sign.", after, context) else resting(after, context)
82def resting(after: State, context: Abi.Context) -> Activity<Card.Replied>:
83  let amends = Super.field(after, "amends")
84  if amends == "" then answered(Card.Replied.done({action: "countersign"}), "Countersigned, {context.handle}: at rest.", after, context) else amending(amends, after, context)
85def amending(amends: String, after: State, context: Abi.Context) -> Activity<Card.Replied>:
86  if Text.isObjectId(amends) then amendOn(amends, after, context) else answered(Card.Replied.done({action: "countersign"}), "Countersigned, {context.handle}: at rest, but {Text.trimEnd(amendsLine(after))}", after, context)
87def amendOn(amends: String, after: State, context: Abi.Context) -> Activity<Card.Replied>:
88  match world.amend({object: {world: context.world, object: amends}, law: Super.field(after, "law")}):
89    case amended(_): answered(Card.Replied.done({action: "countersign"}), "Countersigned, {context.handle}: at rest, and {amends} is amended.", after, context)
90    case refused(r): answered(Card.Replied.done({action: "countersign"}), if r.clause == "unknownObject" then "Countersigned, {context.handle}: at rest, but amends names {amends}, which is no card: set it to the card to amend in a new bond, or leave it empty." else "Countersigned, {context.handle}: at rest, but {amends} refused the amendment ({r.clause}).{if r.reading == \"\" then \"\" else \" {r.reading}\"} Ask its owner to permit the law, then make a new bond.", after, context)
91# A party withdraws before rest; the mark names who withdrew.
92def withdraw(state: State, context: Abi.Context) -> Activity<Card.Replied>:
93  if void(state) then told(Why.tooMany({n: named(state)}), state, context) else if party(state, context.handle) == false then told(Why.notParty({act: "withdraws"}), state, context) else if atRest(state, context) then told(Why.atRest({}), state, context) else if withdrawn(state) then told(Why.withdrawn({}), state, context) else withdrawing(state, context)
94def withdrawing(state: State, context: Abi.Context) -> Activity<Card.Replied>:
95  let mark = {name: "withdrawn", who: context.principal, handle: context.handle, at: context.height}
96  let written(_) = write {marks: insert mark}
97  answered(Card.Replied.done({action: "withdraw"}), "Withdrawn, {context.handle}.", extend(state, {marks: Relations.insert(state.marks, mark, markKey)}), context)
98def door(state: State, input: DoorInput, context: Abi.Context) -> Activity<Card.Replied>:
99  Super.door(state, {label: input.label, to: input.to}, context)
100def undoor(state: State, input: UndoorInput, context: Abi.Context) -> Activity<Card.Replied>:
101  Super.undoor(state, {label: input.label}, context)
102def methods() -> Lists.List<String>:
103  Text.words("~made")
104# A party is offered what it may still do; the owner its doors.
105def actions(state: State, context: Abi.Context) -> Lists.List<String>:
106  let mine = if void(state) || party(state, context.handle) == false || withdrawn(state) || atRest(state, context) then Text.words("") else if signed(state, context.handle) then Text.words("withdraw") else Text.words("countersign withdraw")
107  Lists.concat(mine, if context.principal == state.owner then Text.words("door undoor") else Text.words(""))
108def partyLine(state: State, handle: String) -> String:
109  if signed(state, handle) then "{handle} (signed)" else handle
110def standing(state: State, context: Abi.Context, id: String) -> String:
111  if void(state) then "Void: it names {natText(named(state))} parties, and a bond binds fifteen at most.\n" else if withdrawn(state) then "Withdrawn.\n" else if atRest(state, context) then "At rest: every party signed. Its signers are a circle: request.subject in \"{id}\".marks.who\n" else "Waiting for {Text.countWord(Lists.length(unsigned(state)))} of the parties.\n"
112def amendsLine(state: State) -> String:
113  let amends = Super.field(state, "amends")
114  if amends == "" then "" else if Text.isObjectId(amends) then "At rest it amends {amends} to:\n  {Super.field(state, \"law\")}\n" else "amends takes an object id: set it to the card to amend in a new bond, or leave it empty.\n"
115def yours(state: State, context: Abi.Context, id: String) -> String:
116  if void(state) || party(state, context.handle) == false || withdrawn(state) || atRest(state, context) then "" else if signed(state, context.handle) then "You signed. Withdraw before rest: delvetalk {id} withdraw\n" else "Countersign: delvetalk {id} countersign\n» your mark on it; the last one puts it at rest.\n"
117def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
118  Document.text("A BOND, made by {Card.shown(state.maker, state.makerHandle, context)}{Card.mine(state.maker, context)}: {Super.field(state, \"terms\")}\nParties: {textJoin(Lists.map(parties(state), fn(p: String) -> String: partyLine(state, p)), \", \")}. {standing(state, context, id)}{amendsLine(state)}{yours(state, context, id)}")