The osen reference

Every name the language binds, in alphabetical order, with what it takes, what it answers, and an example.

The same entries are data in the register /_q: /_q/o/add answers /o/add’s entry as a bundle.

The names

/o/abs

(x) -> x without its sign

(-5) /o/abs
# -> : 5

/o/add

(a, b) -> their sum

Two ints or two floats; a mixed pair is refused as the wrong type of item.

(1, 2) /o/add
# -> : 3

/o/all

(sequence, predicate) -> 1 if the predicate answers non-zero for every item, else 0

((1, 2, 3), ({ (/x, 0) /o/gt }, ["/x"]) /o/defn) /o/all
# -> : 1

/o/and

(a, b) -> 1 if both are true, else 0

True is /o/true or a non-zero number, and false is /o/false or zero. A string is refused, although /o/if reads “1” as true.

(1, 0) /o/and
# -> : 0

(/o/true, 1) /o/and
# -> : 1

/o/any

(sequence, predicate) -> 1 if the predicate answers non-zero for any item, else 0

((1, 2, 3), ({ (/x, 2) /o/gt }, ["/x"]) /o/defn) /o/any
# -> : 1

/o/apply

(function, arguments) -> the function's result

A pointer is called on the spot; a function written in osen takes the frame road through /o/execlambdaapp. One of the evaluator’s own steps, also bound by name.

/o/assign

(bundle, value, "/address") -> a copy of the bundle with the value bound at that address

Replaces the element already at the address, or appends one. The bundle may be a literal or a name read.

((/y : 42), 99, "/y") /o/assign
# -> ( /y : 99 )

((/y : 42), 99, "/z") /o/assign
# -> ( /y : 42, /z : 99 )

/o/assign/toreg

("/_r", value, "/address") -> nothing; binds the value at that address in that register

The only way for a program to write into a register other than its own environment.

("/_x", 1, "/y") /o/assign/toreg, /y
# -> : [] : 1

/o/backtrace

(machine) -> a list: what each open frame still had to do, then what the machine itself was about to do

With the machine that halted held as /m, as a host with a debugger holds one, these three lines run in order:

/!/inner/trap
/x : 10, (/x, /z) /o/add
(/m) /o/backtrace -> : [ { : "/!/o/finalize/toplevelexec", : "/!/drop" }, { : "/!/os/F" }, { : "/!/os/E", : "", : "/!/os/C2", : "/o/add" } ]

/o/bind

("/name", value) -> nothing; the name bound in the environment

What a statement /name : value becomes. One of the evaluator’s own steps, also bound by name.

/o/blob/tohex

(blob) -> its bytes as a string of hex, two lowercase digits a byte

Given a second string, that goes between each byte and the next, for reading.

((5) /o/toblob/fromitem) /o/blob/tohex
# -> : "00000005"

(("/a") /o/toblob/fromitem, " ") /o/blob/tohex
# -> : "2f 61 00 00"

/o/bound

("/name") -> 1 if the name exists and carries a value, else 0

("/o/add") /o/bound
# -> : 1

/o/bundleitem/tobundleelem

(x) -> x as a bundle element if it arrived as a bundle item; anything else unchanged

A bundle read through a name arrives as one item of a message; this is the normalisation every sequence verb does, exposed.

(10) /o/bundleitem/tobundleelem
# -> : 10

/o/butlast

(sequence) -> the sequence without its last item

((1, 2, 3)) /o/butlast
# -> ( : 1, : 2 )

/o/complete

("word") -> a bundle whose addresses are what the word could become, your names first

What TAB at a prompt offers, and the same question for a program on a socket. The host binds /complete over the machines a typed line reaches: their names, then their /_x; a word starting with a register’s name completes in that register. One path segment at a time, as a shell completes directories; /prim/ and the evaluator’s own names only when the word starts with them. When one name is left and /_q has an entry for it, it carries what the entry says.

("/o/ad") /o/complete -> ( /o/add : "(/a, /b) -> their sum" )

/o/concat/blobs

(blob, blob) -> one blob, the second's bytes after the first's

((5) /o/toblob/fromitem, (6) /o/toblob/fromitem) /o/concat/blobs
# -> : "/,/b/\x00\x00\x00\x05\x00\x00\x00\x06"

/o/concat/elems

(a, b) -> one sequence: a's items followed by b's

Two lists make a list; two bundles make a bundle.

([1, 2], [3, 4]) /o/concat/elems
# -> : [ 1, 2, 3, 4 ]

((/a : 1), (/b : 2)) /o/concat/elems
# -> ( /a : 1, /b : 2 )

/o/concat/strings

(string, string) -> one string, the second after the first

("ab", "cd") /o/concat/strings
# -> : "abcd"

/o/count/items

(sequence) -> how many items it holds; the same function as /o/length

((/a : 1, /b : 2)) /o/count/items
# -> : 2

/o/db

(machine) -> one bundle showing it: /frames, /aboutto, /stack, /env, /pending, and /andyoucan

The whole of a halted machine at once; the prompt prints it like any other value, and the next line is ordinary osen against the same machine.

(() /o/machine/new) /o/db
# -> ( /frames : 0, /aboutto : (), /stack : (), /env : (), /pending : (), /andyoucan : ( : "(m) /o/backtrace what each frame still owes", : "(m, k) /o/frame one frame's four registers", : "(m, v, name) /o/machine/bind bind it everywhere", : "(m, v) /o/machine/store/value and carry on with it", : "(m) /o/machine/run run it again", : "(m, where) /o/machine/send send it away" ) )

/o/decat/blob/fromstart

(blob, n) -> [its first n bytes, the rest]

((5) /o/toblob/fromitem, 1) /o/decat/blob/fromstart
# -> : [ "/,/b/\x00", "/,/b/\x00\x00\x05" ]

/o/decat/string/fromstart

(string, n) -> [its first n characters, the rest]

("hello", 2) /o/decat/string/fromstart
# -> : [ "he", "llo" ]

/o/defn

({ body }, ["/params"...]) -> a function

The body is a brace bundle and the parameters a list of names; calling the function binds the arguments to those names and runs the body. The named form ( /body : { }, /args : [ ] ) is the same call. The optional named slots are /name, what the function calls itself; /captured, the names to close over now; /ambient; and /text and /doc, what it was written as and what it is for, which it carries and which change nothing about running it.

/f : ({ (/a, /b) /o/add }, ["/a", "/b"]) /o/defn, (1, 2) /f
# -> : 3

/y : 10, /f : ({ (/x, /y) /o/add }, ["/x"], /captured : ["/y"]) /o/defn, (5) /f
# -> : 15

/o/div

(a, b) -> a divided by b

Two ints divide as ints.

(7, 2) /o/div
# -> : 3

/o/drain

() -> nothing; what /o/out staged in the output register moves to the input and runs

A prompt drains after every line by itself.

() /o/drain
# -> ()

/o/each

(sequence, function) -> 0, after calling the function on each item for its effect

((1, 2, 3), ({ (/x) /o/println }, ["/x"]) /o/defn) /o/each
# -> : 1 : 2 : 3 : 0

/o/eql

(a, b) -> 1 if equal, else 0

Ints, floats, strings, lists and bundles compare; an int and a float with the same value are not equal.

(1, 1) /o/eql
# -> : 1

/o/eval

("source") -> what the host's evaluator makes of it

The host decides what evaluating is: a prompt hands the string to its own read-eval-print, a host without one to its evaluator. In the browser host (“(1, 2) /o/add”) /o/eval answers 3. At a prompt the evaluator is the prompt’s own, so the value is printed there, as the line would be if it were typed.

("(1, 2) /o/add") /o/eval

/o/exec

(bundle) -> a bundle of what its elements produced

Each element of the bundle is evaluated and the values come back in one bundle; an empty one stays empty. A lazy bundle is one value, so it comes back as itself: to run what it holds, make it a bundle element first, as Max’s codebox and serve objects do.

(15) /o/exec
# -> ( : 15 )

/q : { (1, 2) /o/add }, ((/q) /o/bundleitem/tobundleelem) /o/exec
# -> ( ( : 3 ) )

/o/exec/blob

(blob) -> a bundle of what the bundle inside the blob produced

An eager bracket the parser left encoded, converted and executed in one step. One of the evaluator’s own steps, also bound by name.

/o/exec/toplevel

(bundle) -> its elements run as a line at the top level

Runs a parsed line the way the prompt does. The board’s inner machine runs the same sequence.

/o/exec2

(bundle) -> its elements run, by the instruction language's exec2

It answers [ results, env ]. Max’s if object runs its parsed condition this way.

/o/execbranch

(branch) -> the branch running, as /o/if runs one

The same execution as /o/exec with /o/finalize/branch at the end. One of the evaluator’s own steps, also bound by name.

/o/execlambdaapp

(function, arguments) -> the body running in a new frame

Opens the frame a function call runs in. One of the evaluator’s own steps, also bound by name.

/o/exists

("/name") -> 1 if a message with that address is anywhere the lookup searches, else 0

Present with no value still counts; /o/bound asks for the value too.

("/o/add") /o/exists
# -> : 1

("/nope") /o/exists
# -> : 0

/o/false

a value -> false, the F type

Not a function: reading the name gives the value. The logical verbs read it as false and /o/true as true.

(/o/false) /o/typeof1
# -> : "/-/F"

(/o/true, /o/false) /o/and
# -> : 0

/o/fill

({ body }) -> the body with each /%/name replaced by that name's value now

What a brace bundle does to its /%/ holes when it is written; this is the same fill as a verb, for a body held in a value.

/x : 5, /t : ({ (/%/x, 1) /o/add }) /o/fill, /x : 100, ({ 0 }, /t, 1) /o/if
# -> : 6

/o/fill/all

({ body }) -> the body with every free name replaced by its value now

What %{ } does when it is written: every name that resolves is filled, except the vocabulary under /o/ and /prim/, which the receiver has. As a verb on a body already written with { } it does the same.

/x : 5, /t : %{ (/x, 1) /o/add }, /x : 100, ({ 0 }, /t, 1) /o/if
# -> : 6

/x : 5, /t : ({ (/x, 1) /o/add }) /o/fill/all, /x : 100, ({ 0 }, /t, 1) /o/if
# -> : 6

/o/filter

(sequence, predicate) -> a list of the items the predicate answers non-zero for

The predicate is a function of one argument.

((1, 2, 3, 4), ({ (/x, 2) /o/gt }, ["/x"]) /o/defn) /o/filter
# -> : [ 3, 4 ]

/o/finalize/branch

(a branch that has run) -> its values, unwrapped, on the caller's stack

A branch is part of the expression around it, so what it produced comes back as values rather than sealed in a bundle. One of the evaluator’s own steps, also bound by name.

/o/finalize/elem

(an element that has been evaluated) -> its value, bound if it was named

A statement /x : 5 binds after this step; a bare value stays on the stack. One of the evaluator’s own steps, also bound by name.

/o/finalize/exec

(a frame that has run) -> its results, the frame closed

Separates what the body produced from the environment beneath it and gives the caller its environment back. One of the evaluator’s own steps, also bound by name.

/o/finalize/execlambdaapp

(a function body that has run) -> its last value, the frame closed

A function answers with one value: the last the body produced, or nothing for an empty body. One of the evaluator’s own steps, also bound by name.

/o/finalize/toplevelexec

(a line that has run) -> its values, ready for the prompt to print

The last step of running a line at the top level, as /o/exec/toplevel does. A host that runs a line itself pushes it, as the board’s inner machine does.

/o/find

(sequence, predicate) -> the first item the predicate answers non-zero for

((1, 2, 3, 4), ({ (/x, 2) /o/gt }, ["/x"]) /o/defn) /o/find
# -> : 3

/o/first

(sequence) -> its first item

A sequence is a bundle, (1, 2, 3), or a list, [1, 2, 3]; a name read works too.

((1, 2, 3)) /o/first
# -> : 1

/o/fn/disarm

(x) -> x, every pointer in it written as its name

A pointer – a bound function, a handle – means something only in the process that made it, and carries the name it was bound under. Disarmed, it is that name alone, which may go anywhere and, applied, means what the name means where it is. Reaches every pointer in x, those inside a machine value’s registers included. A machine that is sent is disarmed on the way out without asking. Late bound over a verb the host provides.

((/f : /prim/add) /o/fn/disarm) /o/fn/live
# -> : 0

/o/fn/live

(x) -> how many live pointers x holds

x is not changed. A live pointer is written as its name when x is sent, so this need not be zero for x to travel. Late bound over a verb the host provides.

(/f : /prim/add) /o/fn/live
# -> : 1

/o/fn/named

(x) -> how many pointers by name x holds

x is not changed. After /o/fn/rearm, the ones whose names are bound to nothing here. Late bound over a verb the host provides.

((/f : /prim/add) /o/fn/disarm) /o/fn/named
# -> : 1

/o/fn/rearm

(x) -> x, each pointer by name replaced by what its name is bound to here

By the name each one carries, against this machine’s bindings, and not by the name of the binding holding it. Only a cache: a pointer by name is resolved when it is applied anyway. One whose name is bound to no pointer here stays by name. Late bound over a verb the host provides.

(((/f : /prim/add) /o/fn/disarm) /o/fn/rearm) /o/fn/live
# -> : 1

/o/fold

(sequence, init, fn) -> the last accumulator

fn is called as (acc, item) fn for each item, and its answer is the next accumulator; init is the first.

((1, 2, 3), 10, /o/add) /o/fold
# -> : 16

/o/foldrest

(a fold in progress) -> its next round

An evaluator step: /o/fold schedules it after each call of the step function.

/o/format

(x) -> x, and its printed form as a string

The form the prompt prints, one line, without a newline.

(5) /o/format
# -> : [ 5, ": 5" ]

/o/formatln

(x) -> x, and its printed form as a string ending in a newline

((1, 2, 3)) /o/formatln
# -> : [ ( : 1, : 2, : 3 ), "( : 1, : 2, : 3 ) " ]

/o/frame

(machine, k) -> frame k: what it saved, in the order /_i, /_e, /_s, /_c, omitting registers that were empty

With the machine that halted held as /m, as a host with a debugger holds one, these three lines run in order:

/!/inner/trap
/x : 10, (/x, /z) /o/add
(/m, 0) /o/frame -> ( ( : "/!/o/finalize/toplevelexec", : "/!/drop" ) )

/o/frames

(machine) -> how many frames it has open

(() /o/machine/new) /o/frames
# -> : 0

/o/funcall

(function, arguments) -> the function's result, from a quoted call

What a quoted call in a callback list resolves to. A module writes it into its callback lists as “/’/!/o/funcall”, as o.se.udp and o.se.serial do.

/o/gather

(bundle, "/address") -> a list of two bundles: the elements whose address matches, and the rest

((/a : 1, /b : 2), "/a") /o/gather
# -> : [ ( /a : 1 ), ( /b : 2 ) ]

/o/get

(bundle, (step, ...)) -> the value at the end of the path

Each step is an address, looked up, or an index, counted from 0. An address answers a message, and OSC does not tell one value from a list of one, so the step after an address is always an index into the message’s items: 0 is a lone item itself, and the 0 is never implied. /o/get reads the first of a repeated address.

((/a : (/b : 5)), ("/a", 0, "/b")) /o/get
# -> : 5

((1, 2, 3), (1)) /o/get
# -> : 2

((/a : [(/b : 5), (/b : 6)]), ("/a", 1, "/b")) /o/get
# -> : 6

((/a : (1, 2, 3)), ("/a", 0, 1)) /o/get
# -> : 2

((/a : [1, 2, 3]), ("/a")) /o/get
# -> : [ 1, 2, 3 ]

/o/get/addresses

(bundle) -> a list of its elements' addresses, in order

((/a : 1, /b : 2)) /o/get/addresses
# -> : [ "/a", "/b" ]

/o/gt

(a, b) -> 1 if a is greater than b, else 0

(1, 2) /o/gt
# -> : 0

/o/gte

(a, b) -> 1 if a is at least b, else 0

(2, 2) /o/gte
# -> : 1

/o/if

({ iffalse }, { iftrue }, condition) -> what the chosen branch produced

The branches are brace bundles and the condition an int, 0 choosing the first. What the branch left comes back as values, not wrapped in a bundle.

({ 0 }, { 1 }, 1) /o/if
# -> : 1

/o/infinitum

a value -> infinitum, the I type

(/o/infinitum) /o/typeof1
# -> : "/-/I"

/o/insert/fromend

(target, item, "/key") -> the same, reading the target as descending

(((/due : 30), (/due : 10)), (/due : 20), "/due") /o/insert/fromend
# -> ( ( /due : 30 ), ( /due : 20 ), ( /due : 10 ) )

/o/insert/fromstart

(target, item, "/key") -> a copy of the target with the item placed by the number at /key, reading the target as ascending

Every element of the target carries a number at /key. Equal keys keep their arrival order. An item with no such key, or a non-number there, is refused.

(((/due : 10), (/due : 30)), (/due : 20), "/due") /o/insert/fromstart
# -> ( ( /due : 10 ), ( /due : 20 ), ( /due : 30 ) )

/o/inspect

(x) -> its printed form as a string, with nothing collapsed

The prompt’s printer with the collapse off, answering a string a program can hold, compare or send.

((1, 2, 3)) /o/inspect
# -> : "( : 1, : 2, : 3 )"

/o/is/closure

(value) -> 1 if it is a function carrying captured bindings, else 0

/y : 10, /f : ({ (/x, /y) /o/add }, ["/x"], /captured : ["/y"]) /o/defn, (/f) /o/is/closure
# -> : 1

/o/is/lambda

(value) -> 1 if it is a function, else 0

A function is a bundle declaring /_i and /_p, as /o/defn makes one.

(/o/add) /o/is/lambda
# -> : 1

/o/is/machine

(value) -> 1 if it is a machine, else 0

A machine is a bundle declaring the five registers, whatever their order.

(() /o/machine/new) /o/is/machine
# -> : 1

/o/is/thunk

(value) -> 1 if it is a thunk, else 0

A thunk is a bundle declaring /_i and nothing else: a body with no parameters. A brace bundle held in a name is a blob, not a thunk, and answers 0.

((/_i : { 1 })) /o/is/thunk
# -> : 1

/o/is/type/string

(x) -> x, and 1 if it is one message holding one item that is a string, else 0

A message of several items answers 0, and so do several messages: the question is asked of one message with one item. To ask it of each message, map over them and keep the last of each answer.

("a") /o/is/type/string
# -> : [ "a", 1 ]

(["a", "b"]) /o/is/type/string
# -> : [ "a", "b", 0 ]

(["a", 1, "c"], ({ ((/x) /o/is/type/string) /o/last }, ["/x"]) /o/defn) /o/map
# -> : [ 1, 0, 1 ]

/o/last

(sequence) -> its last item

((1, 2, 3)) /o/last
# -> : 3

/o/length

(sequence) -> how many items it holds

A bundle’s elements or a list’s items; a literal and a name read count the same. /o/count/items is the same function.

((1, 2, 3)) /o/length
# -> : 3

/x : (1, 2, 3), (/x) /o/length
# -> : 3

/o/length/item

(string) -> how many characters it has

("hello") /o/length/item
# -> : 5

/o/lookup

(bundle, "/address") -> the message at that address, or the empty message

The bundle may be a literal or a name read; a name that is not there answers the empty message rather than raising.

((/a : 1, /b : 2), "/b") /o/lookup
# -> : 2

((/a : 1, /b : 2), "/c") /o/lookup
# -> : []

/o/lookup/inenv

("/name") -> the message the name is bound to, searched the way a name read is

Raises if the name is not bound; /o/exists asks without raising.

/x : 3, ("/x") /o/lookup/inenv
# -> : 3

/o/lt

(a, b) -> 1 if a is less than b, else 0

Numbers only; two strings are refused as the wrong type of item.

(1, 2) /o/lt
# -> : 1

/o/lte

(a, b) -> 1 if a is at most b, else 0

(2, 2) /o/lte
# -> : 1

/o/machine/bind

(machine, value, "/name") -> the machine with the name bound in every one of its environments

Unconditional: a frame that already had the name gets the new value, so use it for a name that is unbound everywhere. With the machine that halted held as /m, as a host with a debugger holds one, these three lines run in order:

/!/inner/trap
/x : 10, (/x, /z) /o/add, (/z, 100) /o/add
(((/m, 5, "/z") /o/machine/bind, 5) /o/machine/store/value, ("/_s")) /o/get -> : ( : 15, : 105 )

/o/machine/drive

("name", { code }) -> what the code produced on the named machine, as one bundle

Drives another machine in this process, reached by the name it was registered under: the code runs on it, and this machine answers any name it does not have. The code can name this machine’s values, a function’s arguments among them, as any { } block can. A verb bound as one that must run where it is bound runs here, in this machine. One request at a time: another thread waits, and a request from this one while another is waiting nests inside it. What outlasts a request lives in the machine’s registers – write one with /o/assign/toreg, read it as /r/name – since the code is a { } block, applied: its bindings are its frame’s, seen by the rest of it and gone after, and they are not in the answer. A name nothing is registered as raises. (“name”, (/a : 7), { code }) gives the code named values first, as a function is given its parameters. Late bound over a verb the host provides.

/o/machine/fault

() -> the machine as it faulted, a value

The machine at this run’s first raise, as it was before any handler ran: the failed step on its stack under the errno, and its handler about to run – the shape /o/machine/use/value and store/value restart. Kept in the faulted-machine register, /_f, only by a machine that has one; see /o/machine/fault/keep. Raises outside a handler, or when nothing was kept, rather than answering an empty machine. Sending it is what /o/machine/send does; restarting in place is /continue/as. Late bound over a verb the host provides.

/exception : { (() /o/machine/fault, "udp://10.0.0.4:9999") /o/machine/send }

/o/machine/fault/keep

(size) -> nothing

This machine keeps its faults from now on: makes its faulted-machine register, /_f, size bytes, if it has none, for /o/machine/fault to read. A fault bigger than that is not kept, and says so. A host may have made one already. Late bound over a verb the host provides.

(4096) /o/machine/fault/keep

/o/machine/free

("name") -> nothing

Gives a machine made with /o/machine/make back, now or, if a request is using it, when the last such request ends; its name goes at once, and making it again makes a new machine. A machine may free itself, as a reference count reaching zero would. Late bound over a verb the host provides.

/o/machine/make

("name", files..., { code }) -> the name

Makes a machine other machines in this process can drive by name, registered as name, and loads it in one request: each file with the /load of the machine making it, then at most one { } block – the place to make the registers it keeps its state in. The machine starts bare: a name it does not have is answered by whichever machine drives it, and whether it gets the language is up to what it loads. A name already registered is answered as it is, and nothing runs, so any number of machines may make the same one. A ( ) of instruction strings would be evaluated here, where it is written: give code as { }. Late bound over a verb the host provides.

/o/machine/new

() -> an empty machine, as a value

Five empty registers in a bundle, a value like any other: put things in it with /o/put, send it, or hand it to a host that runs machines.

(() /o/machine/new) /o/is/machine
# -> : 1

/o/machine/x

("name") -> a copy of that machine's /_x, as one bundle

Reads a machine made with /o/machine/make, under its lock, as a drive would: its /_x, every binding in it, copied. A machine made to hold a library is how one load is shared – each machine that wants it appends the copy to its own /_x and owns it from then on. Also how to look at what a library machine holds. Late bound over a verb the host provides.

/o/make/register

(size, "/_r") -> nothing; a register of that many bytes made under that name

A name already in use is refused.

(1024, "/_z") /o/make/register
# -> : []

/o/map

(sequence, function) -> a list of the function's answers, one per item

Addresses are not kept: a bundle of named elements maps to a plain list.

((1, 2, 3), ({ (/x, 10) /o/mul }, ["/x"]) /o/defn) /o/map
# -> : [ 10, 20, 30 ]

/o/match

("one", "other") -> [the two strings, and 1 if they are the same string, else 0]

A plain comparison: neither string is read as a pattern, so “/a/*” does not match “/a/b”. /o/pmatch matches a pattern.

("/a/b", "/a/b") /o/match
# -> : [ "/a/b", "/a/b", 1 ]

("/a/b", "/a/*") /o/match
# -> : [ "/a/b", "/a/*", 0 ]

/o/max

(a, b) -> the larger

(1, 2) /o/max
# -> : 2

/o/min

(a, b) -> the smaller

(1, 2) /o/min
# -> : 1

/o/mod

(a, b) -> the remainder of a divided by b

(7, 3) /o/mod
# -> : 1

/o/mul

(a, b) -> their product

(3, 4) /o/mul
# -> : 12

/o/neg

(x) -> x with its sign flipped

(5) /o/neg
# -> : -5

/o/neq

(a, b) -> 1 if they differ, else 0

(1, 2) /o/neq
# -> : 1

/o/nfill

(x, n) -> a list of n copies of x

(7, 3) /o/nfill
# -> : [ 7, 7, 7 ]

/o/nil

a value -> nil, the N type

(/o/nil) /o/typeof1
# -> : "/-/N"

/o/not

(x) -> 1 if x is false or zero, else 0

True and false are read as and and or read them: /o/false and zero are false.

(0) /o/not
# -> : 1

(/o/false) /o/not
# -> : 1

/o/nth

(sequence, n) -> item n, counting from 0

An n outside the sequence raises.

((10, 20, 30), 1) /o/nth
# -> : 20

/o/or

(a, b) -> 1 if either is true, else 0

(1, 0) /o/or
# -> : 1

/o/out

("/channel", value...) -> nothing; appends /channel : value... to the output register

The register is /_o, a bundle of messages addressed by channel; emitting appends, so repeated channels keep their order. What the host does with a channel is its own: a prompt drains the register into the input after each line, so (“/println”, 1) /o/out prints 1 there. The register must exist, and one is made with (65536, “/_o”) /o/make/register.

("/println", 1) /o/out -> : 1

/o/parse

("source") -> [the program the source parses to, 0]

The program is a bundle of what the parser emitted, unrun. A syntax error raises instead.

("(1, 2) /o/add") /o/parse
# -> : [ ( : <thunk> ), 0 ]

/o/pmatch

("/address", "/pattern") -> [what is left of the address after the match, the pattern, 1 if the address was fully matched, 1 if the pattern was]

A partial match: the pattern may match a prefix of the address.

("/a/b/c", "/a") /o/pmatch
# -> : [ "/b/c", "/a", 0, 1 ]

/o/pop

(sequence) -> [the sequence without its last item, that item]

((1, 2, 3)) /o/pop
# -> : [ ( : 1, : 2 ), 3 ]

/o/pop/all/drop/bundle

(sequence) -> a bundle of its items, last first

((1, 2, 3)) /o/pop/all/drop/bundle
# -> ( : 3, : 2, : 1 )

/o/pow

(a, b) -> a to the power b

(2, 10) /o/pow
# -> : 1024

/o/print

(x, ...) -> x, printed without a newline; several, as one string

One argument prints in the form the prompt uses. Several are one string, printed and answered: each that is a string as it is, anything else as the prompt prints it, with nothing between (/osen/format/args).

("hi") /o/print
# -> : "hi"

/o/println

(x, ...) -> x, printed with a newline; several, as one string

("hi") /o/println
# -> : "hi"

("from ", "127.0.0.1", ": ", 92) /o/println
# -> : "from 127.0.0.1: 92"

/o/push

(sequence, x) -> the sequence with x appended

((1, 2), 3) /o/push
# -> ( : 1, : 2, : 3 )

/o/put

(bundle, value, (step, ...)) -> a copy of the bundle with the value at the end of the path

The write side of /o/get; the same steps, and the first of a repeated address is the one replaced.

((/a : (/b : 5)), 9, ("/a", 0, "/b")) /o/put
# -> ( /a : { /b : 9 } )

((1, 2, 3), 9, (1)) /o/put
# -> ( : 1, : 9, : 3 )

((/a : [(/b : 5), (/b : 6)]), 9, ("/a", 1, "/b")) /o/put
# -> ( /a : [ ( /b : 5 ), ( /b : 9 ) ] )

/o/range

(start : 0, end, step : 1) -> the list of ints from start up to but not including end

A position always means the same parameter, so an end on its own is named: a bare (5) fills start and raises for the missing end. A negative step counts down, and a range that cannot be walked is empty.

(/end : 5) /o/range
# -> : [ 0, 1, 2, 3, 4 ]

(2, 6) /o/range
# -> : [ 2, 3, 4, 5 ]

(0, 10, 3) /o/range
# -> : [ 0, 3, 6, 9 ]

(/end : 10, /step : 3) /o/range
# -> : [ 0, 3, 6, 9 ]

(10, 0, -3) /o/range
# -> : [ 10, 7, 4, 1 ]

/o/register/flags

("/_r") -> a bundle of that register's flags, each 0 or 1

("/_x") /o/register/flags
# -> ( /flag/local : 1, /flag/temp : 0 )

/o/register/flags/set

("/_r", (/flag/name : 0 or 1, ...)) -> how many of the flag names it understood

An unknown flag name is ignored, not an error, so a program can tell a host that predates the flag from one that set it.

(1024, "/_z") /o/make/register, ("/_z", (/flag/temp : 1)) /o/register/flags/set
# -> : [] : 1

/o/rest

(sequence) -> the sequence without its first item

A bundle stays a bundle and a list a list.

((1, 2, 3)) /o/rest
# -> ( : 2, : 3 )

/o/reverse

(sequence) -> the sequence with its items in the opposite order

((1, 2, 3)) /o/reverse
# -> ( : 3, : 2, : 1 )

/o/route

(bundle, "/address") -> a bundle of two: the matching elements with the matched part taken off their addresses, then the rest

((/a : 1, /b : 2), "/a") /o/route
# -> ( ( : 1 ), ( /b : 2 ) )

/o/select

(bundle, ["/address", ...]) -> a bundle of one bundle per address, last address first, and the unmatched rest at the end

((/a : 1, /b : 2, /c : 3), ["/a", "/c"]) /o/select
# -> ( ( /c : 3 ), ( /a : 1 ), ( /b : 2 ) )

/o/send

(arguments...) -> whatever the host's send answers

Late bound: a host without a send of its own answers through its unbound-name handler.

/o/set/nth

(sequence, new, n) -> a copy of the sequence with item n replaced by new

Counts from 0. The write side of /o/nth, for a bundle or a list.

((10, 20, 30), 99, 1) /o/set/nth
# -> ( : 10, : 99, : 30 )

([10, 20, 30], 99, 1) /o/set/nth
# -> : [ 10, 99, 30 ]

/o/sort

(list) -> the list with its items in ascending order

Ints, floats or strings; a bundle of elements comes back as it was.

([3, 1, 2]) /o/sort
# -> : [ 1, 2, 3 ]

/o/sortidxs

(list) -> the positions its items would be taken from to sort it

([3, 1, 2]) /o/sortidxs
# -> : [ 1, 2, 0 ]

/o/split/string/fromend

(string, separator) -> [the tail from the last separator, the head before it, the separator]

A separator that does not occur answers [the string, the separator].

("a.b.c", ".") /o/split/string/fromend
# -> : [ ".c", "a.b", "." ]

/o/sub

(a, b) -> a minus b

(5, 2) /o/sub
# -> : 3

/o/toblob/fromelem

(element) -> the element's bytes as a blob

A bundle so encoded prints in braces; /o/toelem/fromblob decodes it.

((1, 2)) /o/toblob/fromelem
# -> : { : 1, : 2 }

/o/toblob/fromitem

(item) -> the item's bytes as a blob

(5) /o/toblob/fromitem
# -> : "/,/b/\x00\x00\x00\x05"

/o/todouble

(number) -> the same number as a double

(3) /o/todouble
# -> : 3.000000

/o/toelem/fromblob

(blob) -> the bundle element the blob's bytes encode

The inverse of /o/toblob/fromelem.

(((1, 2)) /o/toblob/fromelem) /o/toelem/fromblob
# -> ( : 1, : 2 )

/o/tofloat

(number) -> the same number as a float

(3) /o/tofloat
# -> : 3.0

/o/toint16

(number) -> the same number as an int16

The prompt has no printer for this type; /o/typeof1 shows what came back.

((300) /o/toint16) /o/typeof1
# -> : "/-/u"

/o/toint32

(number or "digits") -> the same as an int32

A float is truncated.

(3.7) /o/toint32
# -> : 3

/o/toint64

(number) -> the same number as an int64

((3) /o/toint64) /o/typeof1
# -> : "/-/h"

/o/toint8

(number) -> the same number as an int8

((300) /o/toint8) /o/typeof1
# -> : "/-/c"

/o/tostring

(x) -> its text as a string

(42) /o/tostring
# -> : "42"

/o/tosymbol

(x) -> its text as a symbol

(42) /o/tosymbol
# -> : "/,/S/42"

/o/totimetag

(int) -> that many seconds from 1900, as a timetag

(42) /o/totimetag
# -> : "/,/t/1900-01-01T00:00:42.000000Z"

/o/touint16

(number) -> the same number as a uint16

((3) /o/touint16) /o/typeof1
# -> : "/-/U"

/o/touint32

(number) -> the same number as a uint32

((3) /o/touint32) /o/typeof1
# -> : "/-/k"

/o/touint64

(number) -> the same number as a uint64

((3) /o/touint64) /o/typeof1
# -> : "/-/H"

/o/touint8

(number) -> the same number as a uint8

((3) /o/touint8) /o/typeof1
# -> : "/-/C"

/o/true

a value -> true, the T type

Not a function: reading the name gives the value.

(/o/true) /o/typeof1
# -> : "/-/T"

/o/typeof0

(x) -> "/-" for a message, "/|" for a bundle

((1, 2)) /o/typeof0
# -> : "/|"

/o/typeof1

(x) -> its type one level down: the element's kind, then its items' typetags

(1) /o/typeof1
# -> : "/-/i"

(["a", 1, 2.5]) /o/typeof1
# -> : "/-/sif"

/o/typeof2

(x) -> its type to full depth

(("a", 1, 2.5)) /o/typeof2
# -> : "/|/-/s/-/i/-/f"

/o/typetag/set

(item, code) -> the item with its typetag replaced by the character code; the bytes stay

A reinterpretation, not a conversion: 105 is ‘i’, and 1.5’s bits read as an int.

(1.5, 105) /o/typetag/set
# -> : 1069547520

/o/unpack/drop

(bundle) -> its elements, each on the stack by itself

((1, 2, 3)) /o/unpack/drop
# -> : [ 1, 2, 3 ]

/o/unwrap

two names on the stack, an instruction and the /o/ name to bind -> nothing; the /o/ name bound as the instruction with the argument bundle unpacked first

The bootstrap the wrappers are written with, at the instruction level, as the line below binds /o/eval.

/,/s//!/eval /,/s//o/eval /!/o/unwrap

/o/whence

("/name") -> the register the name resolves in, or "" if nowhere

The name is a string and is not looked up, so asking never moves a program elsewhere.

("/o/add") /o/whence
# -> : "/_x"

/o/wire/check

(x) -> 0 if x may arrive from outside, else why not

The rule a host applies to bytes that arrive, as a verb: nonzero is the error number, and a live pointer is the usual one. x is not changed. Late bound over a verb the host provides.

((/f : /prim/add) /o/fn/disarm) /o/wire/check
# -> : 0

/o/wrap

("/verb", "/o/name") -> "/o/name"; binds /o/name to the host verb /verb, called with its arguments unpacked

A module’s own verb, reached from OSEN without writing instructions. Name the verb as the module binds it, and the name to call it by; the answer is the name that was bound.

("/hello", "/o/hello") /o/wrap -> : "/o/hello"

/o/zipwith

((sequence, ...), fn) -> a list of fn applied across the sequences, item by item

The sequences travel as one bundle; fn takes one argument per sequence. A bundle’s messages go by position as their values, whatever they are called.

(((1, 2, 3), (4, 5, 6)), /o/add) /o/zipwith
# -> : [ 5, 7, 9 ]

(((/y : 1, /x : 2), (/x : 10, /y : 20)), ({ (/x, /y) /o/sub }, ["/x", "/y"]) /o/defn) /o/zipwith
# -> : [ -9, -18 ]

/o/zipwithrest

(a zipwith in progress) -> its next round

An evaluator step: /o/zipwith schedules it between calls of the function it is applying.