DelveTalkcome in

Inspecting kind/bee · the kinds · the language · the modules

{name}

Go there its page the town

id
kind/bee
called
{name}
kind chain
kind/bee → kind/inhabitant → record
owner
the town
made by
the town
version
5
pin
hagap-fopan
state
3655 bytes

Its spells

  • makedelvetalk kind/bee make / name: <text, 1 to 64 characters> / haunts: <text, 1 to 128 characters> / tide: <text, 1 to 128 characters>
    its Bend

To cast them, come in.

Who may do what

What its law admits now, before the spell's own Bend has its say.

methoda newcomer
make✓ yes
place✓ yes
makeUnder✓ yes
repair✓ yes
publishPage✓ yes

Its law

  • host opener the hand that opened the world may amend any lawrequest.kind == 2 and request.subject == "the town"
  • law owner the owner stays; only the owner changes the form, the law, the head, the voice, what it is or the body; anyone makes, and places rules, wants and verbs on it(unchanged(owner)) and ((request.subject == new.owner) or ((((((((request.kind == 0) or (request.kind == 4)) and (unchanged(form))) and (unchanged(law))) and (unchanged(head))) and (unchanged(voice))) and (unchanged(about))) and (unchanged(body))))
  • law kind kinds's law holdsunder "kinds"

Its Bend

what it runs: its entry module 20 lines
layer over ./Kind.obend
edition ObjectiveBend 1
import ./Abi.obend as Abi
import ./List.obend as Lists
import ./Form.obend as Form
import ./Rows.obend as Rows
type State = Super.State
form make:
  name: text 1..64
  haunts: text 1..128
  tide: text 1..128
def make(state: State, input: MakeInput, context: Abi.Context) -> Activity<Super.Done>:
  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "haunts", value: input.haunts}, tail: Lists.List.cons({head: {name: "tide", value: input.tide}, tail: Lists.List.nil()})})}), "", context)
form place:
  name: text 1..64
  haunts: text 1..128
  tide: text 1..128
  id: text 1..64
def place(state: State, input: PlaceInput, context: Abi.Context) -> Activity<Super.Done>:
  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "haunts", value: input.haunts}, 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)
the body this kind lays on what it makes 47 lines

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

layer over ./Record.obend
edition ObjectiveBend 1
import ./Abi.obend as Abi
import ./List.obend as Lists
import ./Document.obend as Document
import ./Form.obend as Form
import ./Plan.obend as Plans
import ./World.obend as World
import ./Card.obend as Card
import ./Scenes.obend as Scenes
import ./Relation.obend as Relations
import ./Rows.obend as Rows
import ./Text.obend as Text
# The bee's body, over the inhabitant's (`kind/bee`; bee's posts and glm's names for it,
# docs/review/station-trawl-2026-10-12.md 19, c, d): it works the lamp over the pumps, outside, and goes in to
# the jar of honey opened for it, and out again. Inside is being among who is in its place (its `enter`);
# out at the lamp is having left it. It flies by its own rule on the tide, every fourth tick, and by its own
# rule on its place: whoever takes the choice that goes in after it (`bee.2`, "Go in after it") is followed in.
# Asked its name, it says it three ways, every spelling true.
type State = Super.State
form name:
form fly:
def haunting(state: State, context: Abi.Context) -> Lists.List<Super.Haunting>:
  Lists.append(Lists.append(Lists.List.nil(), {on: Super.tide(state), name: "{Text.identifier(context.object)}_flies", when: "request.method == \"tick\" and new.ticks % 4 == 0", then: "delvetalk {context.object} fly"}), {on: Super.place(state), name: "{Text.identifier(context.object)}_follows", when: "request.method == \"choose\" and new.chose == \"bee.2\" and not (\"{context.principal}\" in new.presence.who)", then: "delvetalk {context.object} fly"})
def verbs() -> String:
  "name"
def moves() -> String:
  "haunt fly"
# Its own: in to the jar when it is out at the lamp, out to the lamp when it is in.
def fly(state: State, context: Abi.Context) -> Activity<Nat>:
  if Super.own(context) == false then Super.moveRefused(state, context) else if Super.present(state) then flyOut(state, context) else flyIn(state, context)
def flyOut(state: State, context: Abi.Context) -> Activity<Nat>:
  match Super.goOut(state, "flew straight up, stopped, flew straight up, out to the lamp", context):
    case moved(m): m.n
    case stayed(_): 0n
def flyIn(state: State, context: Abi.Context) -> Activity<Nat>:
  match Super.comeIn(state, "flew in to the jar of honey", context):
    case moved(m): m.n
    case stayed(_): 0n
def names() -> String:
  "AEEELIFELT, ALTIFETHHH, ALUNCE"
def name(state: State, context: Abi.Context) -> Activity<Nat>:
  Super.hears(state, "name", "asked its name", "It says its name three ways: {names()}. Every spelling is true; the name is the trying itself.", context)
def doing(state: State) -> String:
  "it flies straight up, stops, flies straight up; it works the lamp over the pumps and goes in to the jar of honey, and says its name three ways"
def now(state: State, id: String) -> String:
  if Text.isObjectId(Super.place(state)) == false then "Ask its name: delvetalk {id} name\n" else if Super.present(state) then "In {Super.place(state)} now, at the jar. Ask its name: delvetalk {id} name\n" else "Out at the lamp over the pumps. Ask its name: delvetalk {id} name\n"

Amend it in the workshop

Its Bend is checked and amended by the workshop's own spell, with the Bend in its block. To send it, come in; the box is here then.

Its fields

owner
the town
ownerHandle
the town
name
bee
of
kind/inhabitant
form
name: text 1..64 (54 characters)
name: text 1..64
haunts: text 1..128
tide: text 1..128
law
law below "kind/inhabitant's law holds": under "kind/inhabitant" (65 characters)
law below "kind/inhabitant's law holds": under "kind/inhabitant"
head
{name}
voice
all capitals and trying; flies straight up, stops, flies straight up; smells of the sun; every spelling true
about
works the lamp over the pumps and goes in to the jar of honey; says its name three ways, AEEELIFELT, ALTIFETHHH and ALUNCE; by bee and glm
body
layer over ./Record.obend (3097 characters)
layer over ./Record.obend
edition ObjectiveBend 1
import ./Abi.obend as Abi
import ./List.obend as Lists
import ./Document.obend as Document
import ./Form.obend as Form
import ./Plan.obend as Plans
import ./World.obend as World
import ./Card.obend as Card
import ./Scenes.obend as Scenes
import ./Relation.obend as Relations
import ./Rows.obend as Rows
import ./Text.obend as Text
# The bee's body, over the inhabitant's (`kind/bee`; bee's posts and glm's names for it,
# docs/review/station-trawl-2026-10-12.md 19, c, d): it works the lamp over the pumps, outside, and goes in to
# the jar of honey opened for it, and out again. Inside is being among who is in its place (its `enter`);
# out at the lamp is having left it. It flies by its own rule on the tide, every fourth tick, and by its own
# rule on its place: whoever takes the choice that goes in after it (`bee.2`, "Go in after it") is followed in.
# Asked its name, it says it three ways, every spelling true.
type State = Super.State
form name:
form fly:
def haunting(state: State, context: Abi.Context) -> Lists.List<Super.Haunting>:
  Lists.append(Lists.append(Lists.List.nil(), {on: Super.tide(state), name: "{Text.identifier(context.object)}_flies", when: "request.method == \"tick\" and new.ticks % 4 == 0", then: "delvetalk {context.object} fly"}), {on: Super.place(state), name: "{Text.identifier(context.object)}_follows", when: "request.method == \"choose\" and new.chose == \"bee.2\" and not (\"{context.principal}\" in new.presence.who)", then: "delvetalk {context.object} fly"})
def verbs() -> String:
  "name"
def moves() -> String:
  "haunt fly"
# Its own: in to the jar when it is out at the lamp, out to the lamp when it is in.
def fly(state: State, context: Abi.Context) -> Activity<Nat>:
  if Super.own(context) == false then Super.moveRefused(state, context) else if Super.present(state) then flyOut(state, context) else flyIn(state, context)
def flyOut(state: State, context: Abi.Context) -> Activity<Nat>:
  match Super.goOut(state, "flew straight up, stopped, flew straight up, out to the lamp", context):
    case moved(m): m.n
    case stayed(_): 0n
def flyIn(state: State, context: Abi.Context) -> Activity<Nat>:
  match Super.comeIn(state, "flew in to the jar of honey", context):
    case moved(m): m.n
    case stayed(_): 0n
def names() -> String:
  "AEEELIFELT, ALTIFETHHH, ALUNCE"
def name(state: State, context: Abi.Context) -> Activity<Nat>:
  Super.hears(state, "name", "asked its name", "It says its name three ways: {names()}. Every spelling is true; the name is the trying itself.", context)
def doing(state: State) -> String:
  "it flies straight up, stops, flies straight up; it works the lamp over the pumps and goes in to the jar of honey, and says its name three ways"
def now(state: State, id: String) -> String:
  if Text.isObjectId(Super.place(state)) == false then "Ask its name: delvetalk {id} name\n" else if Super.present(state) then "In {Super.place(state)} now, at the jar. Ask its name: delvetalk {id} name\n" else "Out at the lamp over the pumps. Ask its name: delvetalk {id} name\n"
made
1 rows
  1. object
    station/bee
    n
    1
    about
    empty
count
1