{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
10def make(state: State, input: MakeInput, context: Abi.Context) -> Activity<Super.Done>:
11  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.nil()}), "", context)
12form place:
13  name: text 1..64
14  id: text 1..64
15def place(state: State, input: PlaceInput, context: Abi.Context) -> Activity<Super.Done>:
16  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, 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 ./Card.obend as Card
9import ./World.obend as World
10import ./Scenes.obend as Scenes
11import ./Relation.obend as Relations
12import ./Rows.obend as Rows
13import ./Text.obend as Text
14# The garden's body, over RECORD (docs/METAPHYSICS.md §7.2): a record that makes bells and
15# cisterns under itself (`makes`: kind/bell, kind/cistern) and holds what it made among its
16# `things`, newest first on its card. `plant` and `dig` are make by another word: each hands its
17# fields to the kind (Record.making), which makes garden/<kind>/<n> with a door home. The weather
18# the garden cites writes its `weather` line, shown under the head; it rains while the garden is
19# tended, and planting or digging tends it.
20type State = Super.State
21form plant:
22  colour: Rows.Colour
23  seed: text 1..80
24form dig:
25  name: text 0..120
26form write:
27  text: text 1..280
28form chime:
29form lines:
30  from: natural 0..1000000000
31form door:
32  label: text 1..32
33  to: text 1..128
34form undoor:
35  label: text 1..32
36def makes(state: State) -> Lists.List<String>:
37  Text.words("kind/bell kind/cistern")
38def colourName(c: Rows.Colour) -> String:
39  match c:
40    case red(_): "red"
41    case orange(_): "orange"
42    case yellow(_): "yellow"
43    case green(_): "green"
44    case cyan(_): "cyan"
45    case blue(_): "blue"
46    case violet(_): "violet"
47    case amber(_): "amber"
48    case silver(_): "silver"
49    case magenta(_): "magenta"
50    case purple(_): "purple"
51    case pink(_): "pink"
52# "an amber bell", "a green bell".
53def article(colour: String) -> String:
54  if colour == "amber" || colour == "orange" then "an" else "a"
55def fieldOf(name: String, value: String) -> Rows.Field:
56  {name: name, value: value}
57# The planter is the turn's principal (the kind seeds it as the bell's maker); a planting tends the
58# garden, which is what its weather reads; the card says where it grew and how to rain on it.
59def plant(state: State, input: PlantInput, context: Abi.Context) -> Activity<Super.Made>:
60  Super.making(state, "kind/bell", Lists.append(Lists.append(Lists.List.nil(), fieldOf("colour", colourName(input.colour))), fieldOf("seed", input.seed)), context, fn(object: String) -> Document.Document: planted(object, colourName(input.colour), input.seed, Relations.count(state.things) + 1n, context), fn(m: Super.Made) -> Super.Made: m)
61def dig(state: State, input: DigInput, context: Abi.Context) -> Activity<Super.Made>:
62  Super.making(state, "kind/cistern", Lists.List.nil(), context, dug, fn(m: Super.Made) -> Super.Made: m)
63def planted(object: String, colour: String, seed: String, count: Nat, context: Abi.Context) -> Document.Document:
64  Document.text("Planted, {Card.name(context.principal, context)}: {article(colour)} {colour} bell, “{seed}”, at {object}; {natText(count)} planted.\nRain on it:\n\n    delvetalk {object} rain\n    text: <1 to 200 characters>\n\nAnother:\n\n{plantSpell(Card.called(context, \"garden\"))}")
65def dug(object: String) -> Document.Document:
66  Document.text("The cistern is dug at {object}; it takes refusals.\n")
67def plantSpell(id: String) -> String:
68  "    delvetalk {id} plant\n    seed: <what might grow here, 1 to 80 characters>\n    colour: <red to violet, silver, magenta, purple or pink>\n"
69def write(state: State, input: WriteInput, context: Abi.Context) -> Activity<Nat>:
70  Super.write(state, {text: input.text}, context)
71# Its bells rung together (RECORD's `ringTogether`): every bell it planted, the first sixteen.
72def chime(state: State, context: Abi.Context) -> Activity<Nat>:
73  Super.ringTogether(state, context)
74def lines(state: State, input: LinesInput, context: Abi.Context) -> Activity<Card.Replied>:
75  Super.lines(state, {from: input.from}, context)
76def door(state: State, input: DoorInput, context: Abi.Context) -> Activity<Card.Replied>:
77  Super.door(state, {label: input.label, to: input.to}, context)
78def undoor(state: State, input: UndoorInput, context: Abi.Context) -> Activity<Card.Replied>:
79  Super.undoor(state, {label: input.label}, context)
80def actions(state: State, context: Abi.Context) -> Lists.List<String>:
81  if context.principal == state.owner then Text.words("plant dig chime lines door undoor") else Text.words("plant dig chime lines")
82# Derived views (`viewDerived {object, view}`): what grows here, by kind, one row a kind.
83def views() -> Lists.List<String>:
84  Text.words("byKind")
85record Tally:
86  kind: String
87  count: Nat
88def byKind(state: State, context: Abi.Context) -> Relations.Relation<Tally>:
89  Relations.Relation.rows({items: Lists.map(Relations.group(state.things, fn(t: Plans.Reference) -> String: kindIn(t.object)), fn(g: Relations.Group<Plans.Reference, String>) -> Tally: {kind: Relations.groupKey(g), count: Lists.length(Relations.groupRows(g))})})
90# garden/bell/3 is a bell: the segment before the number.
91def kindIn(id: String) -> String:
92  let rest = textDrop(id, textBreak(id, "/") + 1n)
93  textTake(rest, textBreak(rest, "/"))
94# The head: the garden's name, its weather, the count, the plant spell and what comes back; then
95# what grows here, newest first, within the card's room.
96def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
97  let title = if state.head == "" then "A GARDEN" else state.head
98  let weather = if state.weather == "" then "" else "Weather: {state.weather}\n"
99  Document.text("✾ {title}\n\n{weather}{natText(Relations.count(state.things))} planted. Plant one:\n\n{plantSpell(id)}\n» a bell, {id}/bell/N; its colour is its tone. Or words; what is read is planted.\n{Super.chimed(state, id)}\nNewest first:\n")
100def thingLine(t: Plans.Reference) -> Document.Document:
101  Document.text("- {t.object}\n")
102def render(state: State, context: Abi.Context) -> Document.Document:
103  let id = Card.called(context, "garden")
104  let head = headLine(state, context, id)
105  let doors = Card.doorLines(state.cites)
106  Document.Document.sequence({items: Document.Documents.cons({head: head, tail: Lists.concat(Card.clippedWithin(Lists.map(Lists.reverse(Relations.rows(state.things)), thingLine), 8n, Card.left(context, Document.size(head) + Document.size(Document.Document.sequence({items: doors})))), doors)})})