Standard library reference on Xo Language

std/adler32

Mon, 01 Jan 0001 00:00:00 +0000

Index

fn checksum
fn update

Functions

checksum

fn checksum(data: Bytes) -> Int

The Adler-32 of data, 0 to 2^32 - 1 (Go’s Checksum); 1 for empty data.

Source: std/adler32.xo:7

update

fn update(sum: Int, data: Bytes) -> Int

The Adler-32 of what sum was the checksum of, followed by data (Go’s Write on a digest at that state): update(checksum(a), b) == checksum(a + b), and update(1, d) == checksum(d).

Source: std/adler32.xo:11

std/amqp

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Value
type AmqpErr
type Role
type SenderSettleMode
type ReceiverSettleMode
type WireError
type DeliveryState
type Source
type Target
type Open
type Begin
type Attach
type Flow
type Transfer
type Disposition
type Detach
type End
type Close
type SaslMechanisms
type SaslInit
type SaslChallenge
type SaslResponse
type SaslOutcome
type FrameBody
type Frame
type Sasl
type ConnOptions
type Transport
type ConnState
type Connection
- method Connection.peer_container_id
- method Connection.peer_max_frame_size
- method Connection.peer_channel_max
- method Connection.peer_idle_timeout_ms
- method Connection.peer_properties
- method Connection.keepalive
- method Connection.send
- method Connection.recv
- method Connection.close
- method Connection.abort
- method Connection.begin
- method Connection.end_session
- method Connection.new_sender
- method Connection.new_receiver
type SessionOptions
type Session
type Header
type Properties
type Body
type Message
type SessState
type Delivery
type LinkState
type SenderOptions
type ReceiverOptions
type Sender
- method Sender.send
- method Sender.close
- method Sender.remote_attach
type Receiver
- method Receiver.receive
- method Receiver.remote_attach
- method Receiver.issue_credit
- method Receiver.drain
- method Receiver.accept
- method Receiver.reject
- method Receiver.release
- method Receiver.modify
- method Receiver.close
fn encode
fn decode
fn encode_frame
fn decode_frame
fn dial
fn encode_message
fn decode_message
fn cbs_put_token

Types

Value

enum Value {
 Null
 Bool(v: Bool)
 UByte(v: UInt8)
 UShort(v: UInt16)
 UInt(v: UInt32)
 ULong(v: UInt64)
 Byte(v: Int8)
 Short(v: Int16)
 Int(v: Int32)
 Long(v: Int64)
 Float(v: Float32)
 Double(v: Float)
 Decimal32(bits: UInt32)
 Decimal64(bits: UInt64)
 Decimal128(bits: Bytes)
 Char(v: Rune)
 Timestamp(ms: Int)
 Uuid(bytes: Bytes)
 Binary(v: Bytes)
 Str(v: Str)
 Symbol(v: Str)
 List(items: List[Value])
 Map(pairs: List[(Value, Value)])
 Array(items: List[Value])
 Described(descriptor: Value, value: Value)
}

An AMQP 1.0 value (section 1.6 of the specification): the primitive types, the compound types, and a described value.

std/amqptest

Mon, 01 Jan 0001 00:00:00 +0000

Index

type QueueOptions
type FakeMsg
type FakeSession
type FakeQueue
type FakeFail
type FakePart
type FakeHub
type HubOwner
type BrokerState
type Broker
- method Broker.serve
- method Broker.queue
- method Broker.event_hub
- method Broker.event_hub_geo_factor
- method Broker.events
- method Broker.topic
- method Broker.subscription
- method Broker.put
- method Broker.ready
- method Broker.locked
- method Broker.dead_letters
- method Broker.scheduled
- method Broker.deferred
- method Broker.tokens
- method Broker.attaches
- method Broker.reject_token
- method Broker.require_token
- method Broker.session_state
- method Broker.fail_next
- method Broker.fail
- method Broker.clear_failures
- method Broker.slow_management
- method Broker.detach_links
- method Broker.disconnect_all
type SvLink
type SvSession
type SvConn
fn new

Types

QueueOptions

struct QueueOptions {
 sessions: Bool = false
 lock_ms: Int = 60000
 max_delivery_count: Int = 10
}

One entity’s settings.

Source: std/amqptest.xo:8

FakeMsg

struct FakeMsg {
 seq: Int
 m: amqp.Message
 delivery_count: Int = 0
 lock_token: Bytes = b""
 locked_until: Int = 0
 lock_conn: Int = 0
 scheduled_ms: Int = 0
 enqueued_ms: Int = 0
 session: Str = ""
 deferred: Bool = false
 dead_reason: Str = ""
 dead_description: Str = ""
}

A message held by a queue. Internal: use the Broker’s methods.

std/archive

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Entry
type ArchiveErr
- method ArchiveErr.display
type ZipFile
type ZipReader
- method ZipReader.files
- method ZipReader.read
type ZipWriter
- method ZipWriter.add
- method ZipWriter.create
- method ZipWriter.write
- method ZipWriter.close
fn file
fn dir
fn gzip
fn gunzip
fn tar
fn untar
fn zip
fn unzip
fn zip_reader
fn zip_open
fn zip_writer

Types

Entry

struct Entry {
 path: Str
 data: Bytes
 mode: Int
 is_dir: Bool
 modified: Time
}

A file or directory of an archive. path uses /; a directory’s data is empty (unzip and untar of an entry whose mode says directory return no data for it, even when the archive stores some, decision 0164).

std/backoff

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Backoff
- method Backoff.delay
fn retry
fn retry_notify
fn always

Types

Backoff

struct Backoff {
 initial: Duration = 500ms
 multiplier: Float = 1.5
 randomization: Float = 0.5
 max_interval: Duration = 60s
 max_elapsed: Duration = 15m
 max_tries: Int = 0
}

The schedule (cenkalti/backoff v4’s defaults): the first delay is initial, each next one multiplier times the last up to max_interval, each randomized within randomization of itself.

Source: std/backoff.xo:10

Backoff.delay

fn (b: Backoff) delay(attempt: Int, rand: Rand) -> Duration uses rand

The delay before retry number attempt (0 for the first retry): initial times multiplier attempt times, capped at max_interval, randomized with one rand.float().

std/base32

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Base32
type DecodeErr
- method DecodeErr.display
fn encode
fn decode

Types

Base32

enum Base32 {
 Std
 Hex
 RawStd
 RawHex
}

RFC 4648 section 6 (Std, A-Z2-7) and section 7 (Hex, 0-9A-V); the Raw forms write and read no = padding.

Source: std/base32.xo:7

DecodeErr

struct DecodeErr {
 at: Int
}

Displays as Go’s CorruptInputError: illegal base32 data at input byte 4.

Source: std/base32.xo:15

DecodeErr.display

fn (e: DecodeErr) display() -> Str

Source: std/base32.xo:19

Functions

encode

fn encode(data: Bytes, enc: Base32 = Base32.Std) -> Str

Source: std/base32.xo:21

std/base64

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Base64
type DecodeErr
- method DecodeErr.display
fn encode
fn decode

Types

Base64

enum Base64 {
 Std
 Url
 RawStd
 RawUrl
}

RFC 4648 section 4 (Std, +/) and section 5 (Url, -_); the Raw forms write and read no = padding.

Source: std/base64.xo:8

DecodeErr

struct DecodeErr {
 at: Int
}

Displays as Go’s CorruptInputError: illegal base64 data at input byte 4.

Source: std/base64.xo:16

DecodeErr.display

fn (e: DecodeErr) display() -> Str

Source: std/base64.xo:20

Functions

encode

fn encode(data: Bytes, enc: Base64 = Base64.Std) -> Str

Source: std/base64.xo:22

std/bcrypt

Mon, 01 Jan 0001 00:00:00 +0000

Index

const MIN_COST
const MAX_COST
const DEFAULT_COST
type BcryptErr
- method BcryptErr.display
fn hash
fn compare
fn cost

Constants

MIN_COST

const MIN_COST: Int = 4

The lowest cost hash accepts; a lower one is replaced by DEFAULT_COST (Go’s MinCost).

Source: std/bcrypt.xo:11

MAX_COST

const MAX_COST: Int = 31

The highest cost (Go’s MaxCost).

Source: std/bcrypt.xo:13

DEFAULT_COST

const DEFAULT_COST: Int = 10

The cost hash uses by default and for a cost below MIN_COST (Go’s DefaultCost).

Source: std/bcrypt.xo:16

Types

BcryptErr

enum BcryptErr {
 Mismatch
 HashTooShort
 VersionTooNew(version: Int)
 InvalidPrefix(byte: Int)
 InvalidCost(cost: Int)
 PasswordTooLong
 Corrupt(msg: Str)
}

Go’s errors, with Go’s texts as display(): crypto/bcrypt: hashedPassword is not the hash of the given password, crypto/bcrypt: hashedSecret too short to be a bcrypted password, crypto/bcrypt: bcrypt algorithm version '3' requested is newer than current version '2', crypto/bcrypt: bcrypt hashes must start with '$', but hashedSecret started with 'x', crypto/bcrypt: cost 3 is outside allowed inclusive range 4..31, bcrypt: password length exceeds 72 bytes; Corrupt is a cost or salt that is not valid text (Go’s strconv and base64 errors).

std/big

Mon, 01 Jan 0001 00:00:00 +0000

Index

type BigInt
- method BigInt.add
- method BigInt.sub
- method BigInt.mul
- method BigInt.quo
- method BigInt.rem
- method BigInt.quo_rem
- method BigInt.div
- method BigInt.mod
- method BigInt.div_mod
- method BigInt.exp
- method BigInt.gcd
- method BigInt.mod_inverse
- method BigInt.sqrt
- method BigInt.neg
- method BigInt.abs
- method BigInt.sign
- method BigInt.cmp
- method BigInt.cmp_abs
- method BigInt.lsh
- method BigInt.rsh
- method BigInt.and
- method BigInt.or
- method BigInt.xor
- method BigInt.and_not
- method BigInt.not
- method BigInt.bit
- method BigInt.bit_len
- method BigInt.trailing_zeros
- method BigInt.probably_prime
- method BigInt.text
- method BigInt.bytes
- method BigInt.fill_bytes
- method BigInt.to_int
- method BigInt.to_float
- method BigInt.display
- method BigInt.debug
type BigErr
- method BigErr.display
fn from_int
fn parse
fn from_bytes

Types

BigInt

struct BigInt {
 key: List[Int]
} derive Eq, Ord, Hash

An integer of any size. key encodes it so that the derived order is the numeric one: zero is [0]; a number of n 64 bit limbs is n (-n when negative), then its limbs from the most significant, each xor the sign bit (xor 2^63 - 1 when negative). Build one with the functions below, not a literal.

std/binary

Mon, 01 Jan 0001 00:00:00 +0000

Index

fn u16_be
fn u32_be
fn u64_be
fn u16_le
fn u32_le
fn u64_le
fn get_u16_be
fn get_u32_be
fn get_u64_be
fn get_u16_le
fn get_u32_le
fn get_u64_le
fn get_i16_be
fn get_i32_be
fn get_i16_le
fn get_i32_le
fn uvarint
fn varint
fn get_uvarint
fn get_varint

Functions

u16_be

fn u16_be(n: Int) -> Bytes

The low 16 bits of n, big endian (2 bytes); also the 32 (4 bytes) and 64 bit (8 bytes) forms and little endian ones.

Source: std/binary.xo:9

u32_be

fn u32_be(n: Int) -> Bytes

Source: std/binary.xo:10

u64_be

fn u64_be(n: Int) -> Bytes

Source: std/binary.xo:11

u16_le

fn u16_le(n: Int) -> Bytes

Source: std/binary.xo:12

u32_le

fn u32_le(n: Int) -> Bytes

Source: std/binary.xo:13

u64_le

fn u64_le(n: Int) -> Bytes

Source: std/binary.xo:14

std/bufio

Mon, 01 Jan 0001 00:00:00 +0000

Index

type BufErr
- method BufErr.display
type Reader
- method Reader.read
- method Reader.read_until
- method Reader.read_line
- method Reader.read_exact
- method Reader.peek
- method Reader.buffered
fn reader

Types

BufErr

enum BufErr {
 Net(err: NetErr)
 TooLong
 UnexpectedEof
}

Why a read failed: the stream’s own error (a timeout, a cancellation, a reset), a record longer than the limit given (a caller closes the connection), or the stream ending before read_exact had its bytes. Displays as the stream’s error text, bufio: record too long and bufio: unexpected EOF.

std/cbor

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Value
- method Value.to_int
- method Value.get
- method Value.diagnostic
- method Value.to_json
type CborErr
- method CborErr.display
type Unm
fn from_int
fn encode
fn decode
fn decode_prefix
fn well_formed
fn from_json
fn marshal
fn unmarshal
fn unmarshal_prefix
fn unm_new
fn dec_error
fn is_null
fn to_str
fn to_int
fn to_float
fn to_bool
fn to_bytes
fn items
fn pairs
fn key_text
fn key_int
fn unknown_key
fn sorted_keys
fn to_value
fn from_value
fn to_time
fn to_duration
fn from_time
fn from_duration
fn put_head
fn put_int
fn put_float
fn put_text
fn put_bytes
fn put_value
fn det_keys
fn bad_arity
fn bad_variant

Types

Value

enum Value {
 Uint(n: UInt64)
 Nint(n: UInt64)
 ByteString(b: Bytes)
 TextString(s: Str)
 Array(items: List[Value])
 Map(pairs: List[(Value, Value)])
 Tag(num: UInt64, v: Value)
 Simple(n: Int)
 Bool(b: Bool)
 Null
 Undefined
 Float(f: Float)
}

A CBOR data item. Integers keep the full range of the format: Uint(n) is n (0 to 2^64-1) and Nint(n) is -1-n (-1 down to -2^64), so Nint(0) is -1. A map keeps its pairs in order, with any key. Simple(n) is a simple value other than false, true, null and undefined (n is 0 to 19 or 32 to 255). A decoded half, single or double float is a Float; encode writes the shortest of the three that holds the value.

std/charset

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Charset
type CharsetErr
- method CharsetErr.display
fn decode
fn encode
fn lookup
fn utf16_units
fn from_utf16_units

Types

Charset

enum Charset {
 Utf8
 Utf16Le
 Utf16Be
 Utf16Bom
 Latin1
 Windows1252
} derive Eq, Display

The encodings. Utf16Le and Utf16Be write and read no byte order mark (a U+FEFF at the start is an ordinary character, x/text’s IgnoreBOM). Utf16Bom reads a mark (FF FE little endian, FE FF big endian) and drops it, little endian when there is none, and writes little endian with a mark (x/text’s UseBOM and a little endian default; Excel’s Unicode Text). Latin1 is ISO 8859-1 (a byte is the code point of the same value); Windows1252 is the WHATWG windows-1252 table (0x80 to 0x9F are the printable characters Microsoft put there, and the five it left unassigned, 0x81, 0x8D, 0x8F, 0x90 and 0x9D, are U+0081, U+008D, U+008F, U+0090 and U+009D).

std/cli

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Command
type Flag
type Arg
type Parsed
- method Parsed.command
- method Parsed.bool
- method Parsed.str
- method Parsed.str_opt
- method Parsed.int
- method Parsed.int_opt
- method Parsed.duration
- method Parsed.duration_opt
- method Parsed.float
- method Parsed.float_opt
- method Parsed.strs
- method Parsed.is_set
- method Parsed.arg
- method Parsed.arg_opt
- method Parsed.rest
type CliErr
- method CliErr.display
- method CliErr.exit_code
fn command
fn bool_flag
fn str_flag
fn int_flag
fn duration_flag
fn float_flag
fn choice_flag
fn strs_flag
fn arg
fn rest
fn parse
fn parse_or_exit
fn help
fn completion

Types

Command

struct Command {}

A command: a name, a help line, flags, positional arguments, and subcommands (std.md 14.1).

Source: std/cli.xo:16

Flag

struct Flag {}

A flag (--name value, -n value, --verbose).

Source: std/cli.xo:18

Arg

struct Arg {}

A positional argument.

std/compress

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Level
type CompressErr
- method CompressErr.display
type Format
type Compressor
- method Compressor.write
- method Compressor.flush
- method Compressor.finish
type Decompressor
- method Decompressor.write
- method Decompressor.finish
fn gzip
fn gunzip
fn deflate
fn inflate
fn zlib
fn unzlib
fn compressor
fn decompressor

Types

Level

enum Level {
 NoCompression
 BestSpeed
 Default
 BestCompression
 HuffmanOnly
 Of(n: Int)
}

A compression level: Go’s -2 (HuffmanOnly) to 9 (BestCompression); Of(n) for any of them, a fault outside -2 to 9.

Source: std/compress.xo:9

CompressErr

struct CompressErr {
 msg: Str
}

Go’s error texts (gzip: invalid header, flate: corrupt input before offset 5, zlib: invalid checksum, unexpected EOF), or gzip: output exceeds max_size (N bytes) (flate, zlib likewise).

std/cookiejar

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Entry
type JarState
type Jar
- method Jar.set_cookies
- method Jar.cookies
- method Jar.clear
fn new

Types

Entry

struct Entry {
 name: Str
 value: Str
 quoted: Bool
 domain: Str
 path: Str
 secure: Bool
 persistent: Bool
 host_only: Bool
 expires: Time
 creation: Time
 last_access: Time
 seq: Int
}

One stored cookie (net/http/cookiejar’s entry). Internal: use the jar.

Source: std/cookiejar.xo:10

JarState

struct JarState {
 entries: Map[Str, Map[Str, Entry]]
 next_seq: Int
}

A jar’s state. Internal: use the methods.

Source: std/cookiejar.xo:27

Jar

struct Jar {
 st: Mutex[JarState]
}

A cookie jar. A handle: copies share the cookies, and tasks may use it at once.

std/crc32

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Poly
fn checksum
fn update

Types

Poly

enum Poly {
 Ieee
 Castagnoli
}

The polynomial: Go’s IEEE (0xedb88320) and Castagnoli (0x82f63b78) tables, both reversed as Go’s are.

Source: std/crc32.xo:8

Functions

checksum

fn checksum(data: Bytes, poly: Poly = Poly.Ieee) -> Int

The CRC-32 of data, 0 to 2^32 - 1 (Go’s ChecksumIEEE, and Checksum with MakeTable(Castagnoli)).

Source: std/crc32.xo:15

update

fn update(crc: Int, data: Bytes, poly: Poly = Poly.Ieee) -> Int

The CRC-32 of what crc was the checksum of, followed by data (Go’s Update): update(checksum(a), b) == checksum(a + b), and update(0, d) == checksum(d).

std/crc64

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Poly
fn checksum
fn update

Types

Poly

enum Poly {
 Iso
 Ecma
 Nvme
}

The polynomial: Go’s ISO (0xd800000000000000) and ECMA (0xc96c5795d7870f42) tables, both reversed as Go’s are, and NVMe’s (0x9a6c9329ac4bc9b5 reversed, CRC-64/NVME: Amazon S3’s default flexible checksum; checksum(b"123456789", Poly.Nvme) is 0xae8b14860a799888 as a Go uint64).

Source: std/crc64.xo:11

Functions

checksum

fn checksum(data: Bytes, poly: Poly = Poly.Iso) -> Int

The CRC-64 of data: the Int’s bits are Go’s uint64, so a checksum past 2^63 is negative (Go’s Checksum with MakeTable(poly)).

std/cron

Mon, 01 Jan 0001 00:00:00 +0000

Index

type CronErr
- method CronErr.display
type Schedule
- method Schedule.next
- method Schedule.zone
fn parse

Types

CronErr

struct CronErr {
 msg: Str
}

Why a spec did not parse; msg is robfig/cron’s text, for example expected exactly 5 fields, found 3: [* * *].

Source: std/cron.xo:9

CronErr.display

fn (e: CronErr) display() -> Str

Source: std/cron.xo:13

Schedule

struct Schedule {
 _every: Int
 _minute: Int
 _hour: Int
 _dom: Int
 _month: Int
 _dow: Int
 _dom_star: Bool
 _dow_star: Bool
 _loc: time.Zone
}

A parsed schedule: a value, never changes.

Source: std/cron.xo:16

std/crypto

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Hash
- method Hash.size
type Hasher
- method Hasher.write
- method Hasher.sum
- method Hasher.written
type Aead
- method Aead.nonce_size
- method Aead.overhead
type AeadKey
- method AeadKey.alg
- method AeadKey.seal_random
- method AeadKey.open_random
- method AeadKey.seal
- method AeadKey.open
type AeadErr
- method AeadErr.display
type PemBlock
type KeyErr
- method KeyErr.display
type KeyAlg
type PublicKey
- method PublicKey.alg
type PrivateKey
- method PrivateKey.alg
- method PrivateKey.public_key
fn sha256
fn hmac_sha256
fn equal
fn random_bytes
fn token
fn hash_password_argon2id
fn hash_password
fn verify_password
fn ed25519_public_key
fn ed25519_sign
fn ed25519_verify
fn digest
fn hmac
fn hasher
fn hmac_hasher
fn aead_key
fn hkdf_extract
fn hkdf_expand
fn hkdf
fn parse_public_key
fn marshal_public_key
fn jwk_public_key
fn parse_private_key
fn marshal_private_key
fn ecdsa_private_key
fn pem_decode
fn pem_encode
fn verify
fn verify_pss
fn verify_raw_ecdsa
fn sign
fn sign_pss
fn sign_raw_ecdsa
fn generate_key

Types

Hash

enum Hash {
 Md5
 Sha1
 Sha224
 Sha256
 Sha384
 Sha512
 Sha3_256
 Sha3_512
}

The hashes of digest, hmac, and Hasher (decision 0279). Md5 and Sha1 are broken for collision resistance; they are here for protocols that require them (HMAC-SHA1 signatures, TOTP, Postgres MD5 authentication, Content-MD5).

std/csv

Mon, 01 Jan 0001 00:00:00 +0000

Index

type CsvErr
- method CsvErr.display
type Reader
- method Reader.read
fn parse
fn reader
fn parse_maps
fn format
fn valid_sep
fn valid_comment

Types

CsvErr

struct CsvErr {
 start_line: Int
 line: Int
 column: Int
 msg: Str
}

Where and why the text is not valid CSV (Go’s csv.ParseError): the line the record starts on, the line and 1-based byte column of the error, and Go’s message (bare " in non-quoted-field, extraneous or missing " in quoted-field, wrong number of fields). Displays as Go’s Error(): parse error on line 1, column 5: bare " in non-quoted-field, record on line 2; parse error on line 3, column 1: ..., record on line 4: wrong number of fields.

std/debug

Mon, 01 Jan 0001 00:00:00 +0000

Index

fn router
fn heap_start
fn mem_budget
fn mem_label
fn mem_mapped
fn mem_peak
fn mem_total
fn mem_trim

Functions

router

fn router(clock: Clock, auth: fn(http.Request) -> Bool) -> http.Router uses clock

The router of the debug routes, to mount under a prefix of the server’s own (r.mount("/debug", debug.router(clock, auth))):

GET /profile?seconds=N&hz=H: a CPU profile of the next N seconds (default 30, at most 300) at H samples per second of CPU time (default 100, at most 1000), answered as decision 0240’s container (Content-Type: application/x-xo-profile; xo prof URL converts it to pprof files and a text summary). One profile runs at a time (409 while one does); 501 where profiles cannot be taken (a build without --profile-support, windows, wasm). On the Go backend the answer is a pprof profile of Go’s runtime/pprof.
GET /heap: the sampled heap profile, in the same container; 409 until the sampler runs (XO_PROF=heap, or heap_start()).
GET /sched: the scheduler’s counters as name value lines (the counts of XO_RTSTATS, zero until they are on: ?on=1 turns them on), and on the native backends heap_live, the blocks allocated and not yet freed, when the heap counts (XO_LEAKCHECK, XO_HEAPSTATS or XO_RTSTATS at start), and on Linux and macOS fds_open, the process’s open file descriptors (files, sockets, pipes, the poller’s own), and on the native backends timers_pending, the event loop’s timers (sleeps, deadlines, timeouts), heap_chunks, the 4 MiB chunks the heap’s size classes were carved from, and heap_cache_bytes, the bytes of freed large blocks kept mapped for reuse.

A request for which auth answers false gets 403.

std/deque

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Deque
- method Deque.push_back
- method Deque.push_front
- method Deque.pop_front
- method Deque.pop_back
- method Deque.front
- method Deque.back
- method Deque.get
- method Deque.len
- method Deque.is_empty
- method Deque.to_list
fn new

Types

Deque

struct Deque[T] {}

A double ended queue. A value, as List: a copy shares the elements until one of them is written, which then copies the ring once (O(n)).

Source: std/deque.xo:10

Deque.push_back

fn (var d: Deque[T]) push_back(x: T)

Source: std/deque.xo:13

Deque.push_front

fn (var d: Deque[T]) push_front(x: T)

Source: std/deque.xo:14

Deque.pop_front

fn (var d: Deque[T]) pop_front() -> T?

The first element, removed; None when empty.

Source: std/deque.xo:16

Deque.pop_back

fn (var d: Deque[T]) pop_back() -> T?

The last element, removed; None when empty.

std/dns

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Mx
type Srv
type Resolver
- method Resolver.lookup_mx
- method Resolver.lookup_txt
- method Resolver.lookup_srv
- method Resolver.lookup_addr
fn lookup_mx
fn lookup_txt
fn lookup_srv
fn lookup_addr

Types

Mx

struct Mx {
 host: Str
 pref: Int
}

A mail exchanger (Go’s net.MX): its host, rooted (“mx1.example.com.”), and its preference (lower first).

Source: std/dns.xo:9

Srv

struct Srv {
 target: Str
 port: Int
 priority: Int
 weight: Int
}

A service location (Go’s net.SRV): the target host (rooted), its port, priority (lower first) and weight (a share within one priority).

Source: std/dns.xo:16

std/embed

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Dir
- method Dir.read
- method Dir.read_text
- method Dir.contains
- method Dir.paths
- method Dir.sub
- method Dir.len
- method Dir.fs

Types

Dir

struct Dir {
 files: Map[Str, Bytes]
}

Files embedded at build time, keyed by their slash path relative to the directory of the file that declares the constant.

Source: std/embed.xo:9

Dir.read

fn (d: Dir) read(path: Str) -> Bytes?

The bytes of the file at path, or None.

Source: std/embed.xo:14

Dir.read_text

fn (d: Dir) read_text(path: Str) -> Str?

The text of the file at path, or None when there is none or it is not valid UTF-8.

std/fnv

Mon, 01 Jan 0001 00:00:00 +0000

Index

fn sum32
fn sum32a
fn sum64
fn sum64a
fn sum128
fn sum128a
fn update32
fn update32a
fn update64
fn update64a
fn update128
fn update128a

Functions

sum32

fn sum32(data: Bytes) -> Int

FNV-1 of data, 0 to 2^32 - 1 (Go’s New32().Sum32()).

Source: std/fnv.xo:8

sum32a

fn sum32a(data: Bytes) -> Int

FNV-1a of data, 0 to 2^32 - 1 (Go’s New32a).

Source: std/fnv.xo:10

sum64

fn sum64(data: Bytes) -> Int

FNV-1 of data, 64 bits: the Int’s bits are Go’s uint64, so a sum past 2^63 is negative (Go’s New64).

Source: std/fnv.xo:13

sum64a

fn sum64a(data: Bytes) -> Int

FNV-1a of data, 64 bits as sum64 (Go’s New64a).

std/go

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Error
- method Error.display
- method Error.message
- method Error.go_type
type Any
- method Any.display
- method Any.type_name
- method Any.is_nil
- method Any.as_int
- method Any.as_float
- method Any.as_bool
- method Any.as_str
- method Any.as_bytes
- method Any.as_list
- method Any.as_map
- method Any.as_handle
type Out
- method Out.any
- method Out.get
type Recv
- method Recv.recv
- method Recv.try_recv
- method Recv.each
fn error
fn any
fn out

Types

Error

struct Error {}

An error returned by a Go function: the error of a Go (T, error) result, which a binding maps to T ! go.Error. Its text is captured at the boundary, so display performs no Go call.

Source: std/go.xo:10

Error.display

fn (e: Error) display() -> Str

The Go error’s Error() text.

std/grpc

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Code
- method Code.number
type FrameErr
type Status
- method Status.display
type Call
type RecvState
type Recv
- method Recv.next
type Send
- method Send.send
- method Send.set_trailer
type Server
- method Server.with_max_recv
- method Server.unary
- method Server.stream
- method Server.router
type Client
- method Client.with_gzip
- method Client.unary
- method Client.call
type ClientCall
- method ClientCall.send
- method ClientCall.close_send
- method ClientCall.recv
type CallState
fn code_from
fn frame
fn unframe
fn encode_timeout
fn decode_timeout
fn encode_message
fn encode_message_bytes
fn decode_message
fn decode_message_bytes
fn bin_encode
fn bin_decode
fn server
fn client

Types

Code

enum Code {
 Ok
 Canceled
 Unknown
 InvalidArgument
 DeadlineExceeded
 NotFound
 AlreadyExists
 PermissionDenied
 ResourceExhausted
 FailedPrecondition
 Aborted
 OutOfRange
 Unimplemented
 Internal
 Unavailable
 DataLoss
 Unauthenticated
} derive Display

The 17 canonical status codes (their numbers are the wire values of grpc-status).

std/heap

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Heap
- method Heap.push
- method Heap.pop
- method Heap.peek
- method Heap.get
- method Heap.remove
- method Heap.fix
- method Heap.len
- method Heap.is_empty
- method Heap.to_list
fn new
fn tracked
fn from_list

Types

Heap

struct Heap[T] {
 _items: List[T]
 _less: fn(T, T) -> Bool
 _moved: fn(T, Int)
}

A binary heap: the element for which less holds against all others comes out first. A value, as List: a copy shares the elements until one of them is written. Equal elements come out in no particular order.

Source: std/heap.xo:11

Heap.push

fn (var h: Heap[T]) push(x: T)

Adds x in O(log n) (heap.Push).

std/html

Mon, 01 Jan 0001 00:00:00 +0000

Functions

escape_string

fn escape_string(s: Str) -> Str

html.EscapeString: <, >, &, ' and " as <, >, &, ' and ".

Source: std/html.xo:9

unescape_string

fn unescape_string(s: Str) -> Str

html.UnescapeString: every entity reference unescaped (named, the legacy names without a semicolon such as &amp and &copy, decimal Δ and hexadecimal λ numeric references, the C1 control code points replaced as browsers do, invalid ones as U+FFFD); unescape_string(escape_string(s)) == s always, the converse not.

Source: std/html.xo:15

std/htmlent

Mon, 01 Jan 0001 00:00:00 +0000

Index

fn entity_of
fn entity2_of

Functions

entity_of

fn entity_of(name: Str) -> Str

The character of an entity name without &, "" for none (amp; and the semicolon-less forms of Go’s table).

Source: std/htmlent.xo:6

entity2_of

fn entity2_of(name: Str) -> Str

The two character expansion of an entity name, "" for none.

Source: std/htmlent.xo:9

std/htmltok

Mon, 01 Jan 0001 00:00:00 +0000

Index

type TokenType
type Attribute
type Token
type Pend
type Tokenizer
- method Tokenizer.next
- method Tokenizer.token
- method Tokenizer.raw
- method Tokenizer.err
- method Tokenizer.allow_cdata
- method Tokenizer.next_is_not_raw_text
- method Tokenizer.set_max_buf
- method Tokenizer.buffered
fn tokenizer
fn tokenizer_fragment

Types

TokenType

enum TokenType {
 Error
 Text
 StartTag
 EndTag
 SelfClosingTag
 Comment
 Doctype
} derive Eq

Go’s TokenType.

Source: std/htmltok.xo:10

Attribute

struct Attribute {
 key: Str
 val: Str
} derive Eq

Go’s Attribute without its namespace (the tokenizer never sets one): the key lower cased, the value unescaped.

Source: std/htmltok.xo:22

Token

struct Token {
 typ: TokenType
 data: Str
 attrs: List[Attribute]
} derive Eq

Go’s Token: data is the lower cased tag name of a tag, the unescaped text of a text, comment or doctype; attrs are a tag’s attributes in order, duplicates (by lower cased key) and empty keys dropped.

std/http

Mon, 01 Jan 0001 00:00:00 +0000

Index

const CONTINUE
const SWITCHING_PROTOCOLS
const PROCESSING
const EARLY_HINTS
const OK
const CREATED
const ACCEPTED
const NON_AUTHORITATIVE_INFO
const NO_CONTENT
const RESET_CONTENT
const PARTIAL_CONTENT
const MULTI_STATUS
const ALREADY_REPORTED
const IM_USED
const MULTIPLE_CHOICES
const MOVED_PERMANENTLY
const FOUND
const SEE_OTHER
const NOT_MODIFIED
const USE_PROXY
const TEMPORARY_REDIRECT
const PERMANENT_REDIRECT
const BAD_REQUEST
const UNAUTHORIZED
const PAYMENT_REQUIRED
const FORBIDDEN
const NOT_FOUND
const METHOD_NOT_ALLOWED
const NOT_ACCEPTABLE
const PROXY_AUTH_REQUIRED
const REQUEST_TIMEOUT
const CONFLICT
const GONE
const LENGTH_REQUIRED
const PRECONDITION_FAILED
const REQUEST_ENTITY_TOO_LARGE
const REQUEST_URI_TOO_LONG
const UNSUPPORTED_MEDIA_TYPE
const REQUESTED_RANGE_NOT_SATISFIABLE
const EXPECTATION_FAILED
const TEAPOT
const MISDIRECTED_REQUEST
const UNPROCESSABLE_ENTITY
const LOCKED
const FAILED_DEPENDENCY
const TOO_EARLY
const UPGRADE_REQUIRED
const PRECONDITION_REQUIRED
const TOO_MANY_REQUESTS
const REQUEST_HEADER_FIELDS_TOO_LARGE
const UNAVAILABLE_FOR_LEGAL_REASONS
const INTERNAL_SERVER_ERROR
const NOT_IMPLEMENTED
const BAD_GATEWAY
const SERVICE_UNAVAILABLE
const GATEWAY_TIMEOUT
const HTTP_VERSION_NOT_SUPPORTED
const VARIANT_ALSO_NEGOTIATES
const INSUFFICIENT_STORAGE
const LOOP_DETECTED
const NOT_EXTENDED
const NETWORK_AUTHENTICATION_REQUIRED
type Router
- method Router.handle
- method Router.handle_stream
- method Router.wrap
- method Router.mount
- method Router.not_found
- method Router.method_not_allowed
- method Router.call
type Next
type Status
type StatusError
type Request
- method Request.param
- method Request.param_opt
- method Request.param_int
- method Request.query
- method Request.query_all
- method Request.form
- method Request.multipart_form
- method Request.header
- method Request.json
- method Request.with_header
- method Request.with_timeout
- method Request.with_host
- method Request.with_expect_continue
- method Request.with_idle_timeout
- method Request.with_body_reader
- method Request.with_trailers
- method Request.header_values
- method Request.host
- method Request.tls
- method Request.tls_state
- method Request.raw_query
- method Request.escaped_path
- method Request.add_header
- method Request.client_ip
- method Request.with_value
- method Request.value
- method Request.cookie
- method Request.cookies
- method Request.with_cookie
type ProxyHeader
type TlsState
type Cookie
- method Cookie.display
type SameSite
type CookieErr
- method CookieErr.display
type Key
- method Key.name
type Response
- method Response.with_trailer_names
- method Response.with_full_duplex
- method Response.with_header
- method Response.header
- method Response.header_values
- method Response.add_header
- method Response.with_cookie
- method Response.cookies
- method Response.text
- method Response.decode_json
type BodyReader
- method BodyReader.read
- method BodyReader.read_all
- method BodyReader.multipart
- method BodyReader.trailers
type PartReader
- method PartReader.next
- method PartReader.read
type StreamPart
- method StreamPart.header_values
type BodyWriter
- method BodyWriter.write
- method BodyWriter.flush
- method BodyWriter.set_trailer
type PipeWriter
- method PipeWriter.write
- method PipeWriter.close
- method PipeWriter.close_with_error
type Server
- method Server.serve
- method Server.addr
- method Server.with_tls
- method Server.with_client_auth
- method Server.with_read_timeout
- method Server.with_read_header_timeout
- method Server.with_idle_timeout
- method Server.with_max_header_bytes
- method Server.with_max_body
- method Server.with_protocols
- method Server.with_h2_config
type Protocol
type H2Config
type TlsCert
type TlsErr
- method TlsErr.display
type HttpErr
- method HttpErr.display
type Client
- method Client.get
- method Client.send
- method Client.post_json
- method Client.with_roots
- method Client.with_server_name
- method Client.with_verify_conn
- method Client.with_verify
- method Client.tls_options
- method Client.with_cert
- method Client.with_protocols
- method Client.with_h2_config
- method Client.open
- method Client.with_redirects
type TlsOptions
type ReverseProxy
- method ReverseProxy.with_rewrite
- method ReverseProxy.serve
type ResponseHead
type ClientStream
- method ClientStream.head
- method ClientStream.read
- method ClientStream.read_all
- method ClientStream.close
- method ClientStream.trailers
type ClientErr
- method ClientErr.display
type Url
type UrlErr
- method UrlErr.display
fn router
fn serve_component
fn parse_cookie
fn parse_set_cookie
fn key
fn new_request
fn json
fn serve_content
fn text
fn empty
fn redirect
fn status_text
fn error_page
fn not_found
fn error_html
fn stream
fn pipe
fn server
fn max_body
fn tls_cert
fn client
fn reverse_proxy
fn parse_url
fn gzip_responses

Constants

CONTINUE

const CONTINUE: Status = Status(100)

The codes Go’s net/http names (std.md 4).

std/idna

Mon, 01 Jan 0001 00:00:00 +0000

Index

type IdnaErr
- method IdnaErr.display
type Profile
fn unicode_version
fn to_ascii
fn to_unicode

Types

IdnaErr

struct IdnaErr {
 code: Str
 msg: Str
}

Why a name was rejected. code is the UTS 46 status code x/net/idna reports (P1 a disallowed rune, V2 and V3 hyphens, C a joiner, B the Bidi rule, A3 and P4 punycode, A4 length, …) and msg its text, for example idna: invalid label "-a".

Source: std/idna.xo:9

IdnaErr.display

fn (e: IdnaErr) display() -> Str

Source: std/idna.xo:14

Profile

enum Profile {
 Lookup
 Registration
 Display
 Punycode
}

x/net/idna’s profiles.

std/jpeg

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Model
type Subsample
type Image
- method Image.chroma_width
- method Image.chroma_height
- method Image.to_rgba
type Config
type JpegErr
- method JpegErr.display
fn decode
fn decode_config
fn encode

Types

Model

enum Model {
 Gray
 YCbCr
 CMYK
 RGBA
} derive Eq, Display

The image types image/jpeg decodes to: Gray (pix, 1 byte a pixel), YCbCr (the y, cb and cr planes with the chroma subsample ratio), CMYK (pix, 4 bytes a pixel, Go’s image.CMYK: 255 is full ink) and RGBA (pix, 4 bytes a pixel with alpha 255; Go’s decoder returns it for an RGB JPEG, one with an Adobe marker that says RGB or components named R, G and B).

std/json

Mon, 01 Jan 0001 00:00:00 +0000

Index

type DecodeErr
type Patch
- method Patch.apply_to
- method Patch.apply_opt
type Value
- method Value.encode
- method Value.get
type Decoder
- method Decoder.write
- method Decoder.finish
type Token
type TokenReader
- method TokenReader.write
- method TokenReader.finish
- method TokenReader.next
- method TokenReader.more
- method TokenReader.offset
- method TokenReader.skip
- method TokenReader.value
type JsonWriter
- method JsonWriter.object_start
- method JsonWriter.object_end
- method JsonWriter.array_start
- method JsonWriter.array_end
- method JsonWriter.key
- method JsonWriter.str
- method JsonWriter.int
- method JsonWriter.float
- method JsonWriter.number
- method JsonWriter.bool
- method JsonWriter.null
- method JsonWriter.raw
- method JsonWriter.value
- method JsonWriter.finish
fn encode
fn encode_str
fn encode_indent
fn encode_indent_str
fn indent
fn compact
fn decode
fn decode_str
fn to_value
fn parse_value
fn decoder
fn from_value
fn token_reader
fn tokens
fn json_writer

Types

DecodeErr

struct DecodeErr {
 path: Str
 msg: Str
} derive Display

Displays as “at $.user.email: expected string”.

Source: std/json.xo:22

Patch

enum Patch[T] {
 Absent
 Null
 Value(v: T)
} derive Json

Source: std/json.xo:30

std/jwt

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Alg
type Key
type Header
type Options
type JwtErr
- method JwtErr.display
fn sign
fn verify_with
fn verify
fn peek_header
fn jwks

Types

Alg

enum Alg {
 HS256
 HS384
 HS512
 RS256
 RS384
 RS512
 PS256
 PS384
 PS512
 ES256
 ES384
 ES512
 EdDSA
}

The signature algorithms (RFC 7518 3.1). There is no none.

Source: std/jwt.xo:8

Key

enum Key {
 Hmac(secret: Secret[Bytes])
 Public(key: crypto.PublicKey)
 Private(key: crypto.PrivateKey)
}

A key. Hmac for HS*, a public key (or a private key, whose public half verifies) for RS*, PS*, ES* and EdDSA, a private key to sign them.

std/log

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Logger
- method Logger.with
- method Logger.debug
- method Logger.info
- method Logger.warn
- method Logger.error
type Level
type Format
type Record
fn debug
fn info
fn warn
fn error
fn enabled
fn configure
fn with

Types

Logger

struct Logger {}

A logger that adds fields to every record it writes (log/slog’s Logger.With; decision 0413): a value, so a handler can make one per request and pass it on. A record’s own fields override a logger’s of the same name. A logger made in a dependency’s code keeps that dependency as its records’ module (decision 0173).

std/mail

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Address
- method Address.display
type MailErr
- method MailErr.display
type Message
- method Message.header
fn parse_address
fn parse_address_list
fn read_message
fn parse_date
fn compose

Types

Address

struct Address {
 name: Str
 address: Str
}

A mail address: the display name (decoded) and local@domain.

Source: std/mail.xo:6

Address.display

fn (a: Address) display() -> Str

"Ann Lee" <ann@example.com>, the name quoted or RFC 2047 encoded as needed (Address.String).

Source: std/mail.xo:26

MailErr

struct MailErr {
 msg: Str
}

Go’s error texts: mail: no address, mail: missing @ in addr-spec, …

Source: std/mail.xo:12

MailErr.display

fn (e: MailErr) display() -> Str

Source: std/mail.xo:16

std/metrics

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Series
type QSample
type QStream
type QState
type Sample
type Kind
type Family
type Registry
- method Registry.counter
- method Registry.gauge
- method Registry.histogram
- method Registry.summary
- method Registry.gauge_func
- method Registry.counter_func
- method Registry.collector
- method Registry.text
- method Registry.handler
- method Registry.handler_at
- method Registry.middleware
type Counter
- method Counter.inc
- method Counter.add
- method Counter.child
- method Counter.remove
- method Counter.reset
type Gauge
- method Gauge.set
- method Gauge.add
- method Gauge.child
- method Gauge.remove
- method Gauge.reset
type Histogram
- method Histogram.observe
- method Histogram.child
- method Histogram.remove
- method Histogram.reset
type Summary
- method Summary.child
- method Summary.observe
- method Summary.remove
- method Summary.reset
type CounterChild
- method CounterChild.inc
- method CounterChild.add
type GaugeChild
- method GaugeChild.set
- method GaugeChild.add
type HistogramChild
- method HistogramChild.observe
type SummaryChild
- method SummaryChild.observe
fn registry
fn latency_buckets

Types

Series

struct Series {
 values: List[Str]
 cells: List[Atomic[Int]]
 q: List[Mutex[QState]]
}

One series of an instrument: its label values and its cells (atomic integers in one list, so reading a series out of the registry shares one object, not one per field): cell 0 a counter’s or gauge’s float (its bits), 1 the observation count, 2 the sum (bits), 3 and on a histogram’s bucket counts, one bucket each. Internal: use the instruments.

std/mime

Mon, 01 Jan 0001 00:00:00 +0000

Index

type MediaType
type MimeErr
- method MimeErr.display
fn parse_media_type
fn format_media_type
fn type_by_extension
fn extensions_by_type
fn detect_content_type

Types

MediaType

struct MediaType {
 kind: Str
 params: Map[Str, Str]
}

A media type: the type and subtype in lower case (“text/html”) and its parameters, names in lower case.

Source: std/mime.xo:8

MimeErr

struct MimeErr {
 msg: Str
}

Go’s error texts: mime: no media type, mime: invalid media parameter, …

Source: std/mime.xo:14

MimeErr.display

fn (e: MimeErr) display() -> Str

Source: std/mime.xo:18

Functions

parse_media_type

fn parse_media_type(v: Str) -> MediaType ! MimeErr

text/html; charset=utf-8 into its parts (mime.ParseMediaType): RFC 2231 continuations and charsets (utf-8, us-ascii) decoded.

std/multipart

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Part
type Form
type MultipartErr
- method MultipartErr.display
fn parse
fn parse_form
fn write
fn form_data_content_type
fn random_boundary

Types

Part

struct Part {
 name: Str
 filename: Str?
 headers: Map[Str, Str]
 data: Bytes
}

One part. name is the form field (Content-Disposition form-data’s name, else “”); filename its file name, the last path element as Go’s FileName; headers the first value of each header, keys in canonical form (Content-Type).

Source: std/multipart.xo:11

Form

struct Form {
 values: url.Values
 files: Map[Str, List[Part]]
}

A form: the fields without a file name, and the file parts by field.

std/netip

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Addr
- method Addr.is_4
- method Addr.is_6
- method Addr.is_4in6
- method Addr.unmap
- method Addr.is_loopback
- method Addr.is_private
- method Addr.is_unspecified
- method Addr.is_link_local_unicast
- method Addr.is_multicast
- method Addr.bytes
- method Addr.display
type Prefix
- method Prefix.contains
- method Prefix.masked
- method Prefix.display
type ParseErr
- method ParseErr.display
fn parse_addr
fn lookup
fn parse_prefix
fn addr_from_bytes

Types

Addr

struct Addr {
 bits: Int
 hi: Int
 lo: Int
 zone: Str
} derive Ord

An IP address: bits is 32 for IPv4, 128 for IPv6, 0 for the zero value; hi and lo its 16 bytes as two words (an IPv4 address as ::ffff:a.b.c.d); zone an IPv6 zone. The order is Go’s Addr.Compare.

std/norm

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Form
fn unicode_version
fn normalize
fn is_normalized

Types

Form

enum Form {
 Nfc
 Nfd
 Nfkc
 Nfkd
} derive Display

A normalization form.

Source: std/norm.xo:8

Functions

unicode_version

fn unicode_version() -> Str

The Unicode version of the tables (15.0.0).

Source: std/norm.xo:21

normalize

fn normalize(s: Str, f: Form) -> Str

s in the form f (Form.String). ASCII text is returned as it is.

Source: std/norm.xo:24

is_normalized

fn is_normalized(s: Str, f: Form) -> Bool

Whether s is already in the form f (Form.IsNormalString).

Source: std/norm.xo:26

std/otlp

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Resource
type ExportErr
- method ExportErr.display
type Exporter
- method Exporter.with_headers
- method Exporter.with_backoff
- method Exporter.send_traces
- method Exporter.send_metrics
fn encode_traces
fn encode_metrics
fn exporter

Types

Resource

struct Resource {
 service: Str
 attributes: List[(Str, Str)] = []
 scope: Str = "std/trace"
 version: Str = ""
}

What an export says about the program that made the spans: the service.name resource attribute, more resource attributes, and the instrumentation scope name (and version) the spans are filed under.

Source: std/otlp.xo:12

ExportErr

enum ExportErr {
 Transport(msg: Str)
 Rejected(status: Int, body: Str)
 GaveUp(status: Int, tries: Int)
}

Why an export failed: the transport (no response), a status the collector will not take (400 and the like: a retry would send the same bytes), or retries that ran out with the last answer.

std/otp

Mon, 01 Jan 0001 00:00:00 +0000

Index

fn hotp
fn totp
fn verify
fn generate_secret
fn uri

Functions

hotp

fn hotp(secret: Bytes, counter: Int, digits: Int = 6, algo: crypto.Hash = crypto.Hash.Sha1) -> Str

The HOTP code (RFC 4226) of counter: digits decimal digits (6 to 8, zero padded), HMAC over algo (Sha1, Sha256 or Sha512), the 8 byte big endian counter and the dynamic truncation of section 5.3. A fault for other digits or algo, or a negative counter.

Source: std/otp.xo:11

totp

fn totp(secret: Bytes, unix: Int, period: Int = 30, digits: Int = 6, algo: crypto.Hash = crypto.Hash.Sha1) -> Str

The TOTP code (RFC 6238) at unix seconds: hotp of unix / period. A fault for a period under 1 or a negative unix, and hotp’s.

std/path

Mon, 01 Jan 0001 00:00:00 +0000

Index

type PathErr
- method PathErr.display
fn join
fn split
fn dir
fn base
fn ext
fn clean
fn is_abs
fn is_match

Types

PathErr

struct PathErr {
 pattern: Str
}

A path pattern is_match cannot parse (Go’s path.ErrBadPattern).

Source: std/path.xo:14

PathErr.display

fn (e: PathErr) display() -> Str

Source: std/path.xo:18

Functions

join

fn join(a: Str, b: Str) -> Str

Source: std/path.xo:5

split

fn split(p: Str) -> (Str, Str)

Source: std/path.xo:6

dir

fn dir(p: Str) -> Str

Source: std/path.xo:7

base

fn base(p: Str) -> Str

Source: std/path.xo:8

ext

fn ext(p: Str) -> Str

Source: std/path.xo:9

clean

fn clean(p: Str) -> Str

Source: std/path.xo:10

is_abs

fn is_abs(p: Str) -> Bool

Source: std/path.xo:11

is_match

fn is_match(pattern: Str, name: Str) -> Bool ! PathErr

Whether name matches the shell pattern: * any sequence of non-/ characters, ? one non-/ character, [a-z] and [^a-z] a byte class, \c the character c. The pattern must match all of name.

std/png

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Model
- method Model.bytes_per_pixel
type Image
- method Image.at
type Config
type Compression
type PngErr
- method PngErr.display
fn image
fn decode
fn decode_config
fn encode

Types

Model

enum Model {
 Gray
 Gray16
 Paletted
 RGBA
 NRGBA
 RGBA64
 NRGBA64
} derive Eq, Display

The image types image/png decodes to and encodes, each with Go’s pix layout (rows of width * bytes with no padding): Gray (1 byte a pixel), Gray16 (2, big endian), Paletted (1, an index into palette), RGBA (4, alpha premultiplied; decode makes it from opaque truecolor, so alpha is 255), NRGBA (4, not premultiplied), RGBA64 (8, big endian 16 bit channels, premultiplied), NRGBA64 (8).

std/protobuf

Mon, 01 Jan 0001 00:00:00 +0000

Index

const VARINT
const FIXED64
const BYTES
const START_GROUP
const END_GROUP
const FIXED32
const MAX_GROUP_DEPTH
type ProtoErr
fn append_varint
fn append_tag
fn append_fixed32
fn append_fixed64
fn append_bytes
fn put_varint
fn put_tag
fn put_fixed32
fn put_fixed64
fn put_bytes
fn size_varint
fn encode_zigzag
fn decode_zigzag
fn read_varint
fn read_tag
fn read_fixed32
fn read_fixed64
fn read_bytes
fn skip_field
fn marshal
fn unmarshal

Constants

VARINT

const VARINT: Int = 0

A field’s wire type (the low three bits of its tag).

Source: std/protobuf.xo:5

FIXED64

const FIXED64: Int = 1

Source: std/protobuf.xo:6

BYTES

const BYTES: Int = 2

Source: std/protobuf.xo:7

START_GROUP

const START_GROUP: Int = 3

Source: std/protobuf.xo:8

END_GROUP

const END_GROUP: Int = 4

Source: std/protobuf.xo:9

std/protodesc

Mon, 01 Jan 0001 00:00:00 +0000

Index

const LABEL_OPTIONAL
const LABEL_REQUIRED
const LABEL_REPEATED
const TYPE_DOUBLE
const TYPE_FLOAT
const TYPE_INT64
const TYPE_UINT64
const TYPE_INT32
const TYPE_FIXED64
const TYPE_FIXED32
const TYPE_BOOL
const TYPE_STRING
const TYPE_GROUP
const TYPE_MESSAGE
const TYPE_BYTES
const TYPE_UINT32
const TYPE_ENUM
const TYPE_SFIXED32
const TYPE_SFIXED64
const TYPE_SINT32
const TYPE_SINT64
type ReservedRange
type ExtensionRange
type OneofDesc
type FieldDesc
type EnumValueDesc
type EnumDesc
type MessageDesc
type MethodDesc
type ServiceDesc
type FileDesc
fn encode
fn decode

Constants

LABEL_OPTIONAL

const LABEL_OPTIONAL: Int = 1

FieldDescriptorProto.Label.

Source: std/protodesc.xo:12

LABEL_REQUIRED

const LABEL_REQUIRED: Int = 2

Source: std/protodesc.xo:13

LABEL_REPEATED

const LABEL_REPEATED: Int = 3

Source: std/protodesc.xo:14

TYPE_DOUBLE

const TYPE_DOUBLE: Int = 1

FieldDescriptorProto.Type.

Source: std/protodesc.xo:17

TYPE_FLOAT

const TYPE_FLOAT: Int = 2

Source: std/protodesc.xo:18

TYPE_INT64

const TYPE_INT64: Int = 3

Source: std/protodesc.xo:19

std/protojson

Mon, 01 Jan 0001 00:00:00 +0000

Index

type JsonErr
- method JsonErr.display
type Opts
type Registry
type MsgInfo
fn registry
fn registry_from_set
fn marshal
fn unmarshal

Types

JsonErr

struct JsonErr {
 text: Str
}

Why a conversion failed; text is protojson’s message.

Source: std/protojson.xo:16

JsonErr.display

fn (e: JsonErr) display() -> Str

Source: std/protojson.xo:20

Opts

struct Opts {
 proto_names: Bool = false
 emit_defaults: Bool = false
 enum_numbers: Bool = false
 discard_unknown: Bool = false
}

Go’s MarshalOptions and UnmarshalOptions: proto_names writes the proto field names (UseProtoNames), emit_defaults writes default valued fields (EmitDefaultValues), enum_numbers writes enums as numbers (UseEnumNumbers); discard_unknown skips unknown fields and enum names when reading (DiscardUnknown).

std/protoparse

Mon, 01 Jan 0001 00:00:00 +0000

Index

type ParseErr
type Kind
type Token
type Field
type EnumValue
type Enum
type Message
type Rpc
type Service
type File
fn tokens
fn parse
fn gen

Types

ParseErr

struct ParseErr {
 line: Int
 col: Int
 msg: Str
} derive Display

Where and why a parse failed; the position is 1 based.

Source: std/protoparse.xo:5

Kind

enum Kind {
 Ident
 Int
 Float
 Str
 Sym
}

A token kind: an identifier (dots allowed inside, as in foo.Bar), an integer, a float, a string literal (unquoted, escapes decoded), or one symbol character.

std/protowkt

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Timestamp
type Duration
type Empty
type FieldMask
type Any
type DoubleValue
type FloatValue
type Int64Value
type UInt64Value
type Int32Value
type UInt32Value
type BoolValue
type StringValue
type BytesValue
type Value
type Struct
type ListValue
fn encode_timestamp
fn decode_timestamp
fn encode_duration
fn decode_duration
fn encode_empty
fn decode_empty
fn encode_field_mask
fn decode_field_mask
fn encode_any
fn decode_any
fn encode_double_value
fn decode_double_value
fn encode_float_value
fn decode_float_value
fn encode_int64_value
fn decode_int64_value
fn encode_uint64_value
fn decode_uint64_value
fn encode_int32_value
fn decode_int32_value
fn encode_uint32_value
fn decode_uint32_value
fn encode_bool_value
fn decode_bool_value
fn encode_string_value
fn decode_string_value
fn encode_bytes_value
fn decode_bytes_value
fn encode_value
fn decode_value
fn encode_struct
fn decode_struct
fn encode_list_value
fn decode_list_value

Types

Timestamp

struct Timestamp {
 seconds: Int = 0
 nanos: Int = 0
} derive Eq

Source: std/protowkt.xo:12

Duration

struct Duration {
 seconds: Int = 0
 nanos: Int = 0
} derive Eq

Source: std/protowkt.xo:17

std/rate

Mon, 01 Jan 0001 00:00:00 +0000

Index

const INF
type LimitState
type Limiter
- method Limiter.limit
- method Limiter.burst
- method Limiter.tokens
- method Limiter.allow
- method Limiter.allow_n
- method Limiter.reserve
- method Limiter.reserve_n
- method Limiter.wait
- method Limiter.wait_n
- method Limiter.set_limit
- method Limiter.set_burst
type Reservation
- method Reservation.ok
- method Reservation.delay
- method Reservation.cancel
type RateErr
- method RateErr.display
fn new
fn every

Constants

INF

const INF: Float = 1.7976931348623157e308

A limit that allows every event (rate.Inf).

Source: std/rate.xo:9

Types

LimitState

struct LimitState {
 limit: Float
 burst: Int
 tokens: Float
 last: Time
 last_event: Time
}

A limiter’s state. Internal: use the methods.

Source: std/rate.xo:12

Limiter

struct Limiter {
 st: Mutex[LimitState]
 clock: Clock
}

A token bucket: limit tokens a second, at most burst at once. A handle: copies share the bucket, and tasks may use it at once.

std/regexp

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Regex
- method Regex.pattern
- method Regex.is_match
- method Regex.find
- method Regex.find_index
- method Regex.find_all
- method Regex.captures
- method Regex.named
- method Regex.replace_all
- method Regex.replace_all_literal
- method Regex.split
type RegexErr
- method RegexErr.display
fn compile
fn must
fn quote

Types

Regex

struct Regex {}

A compiled expression: an immutable compiled value, comparable (not a handle, decision 0112 addendum).

Source: std/regexp.xo:8

Regex.pattern

fn (r: Regex) pattern() -> Str

Source: std/regexp.xo:24

Regex.is_match

fn (r: Regex) is_match(s: Str) -> Bool

Source: std/regexp.xo:25

Regex.find

fn (r: Regex) find(s: Str) -> Str?

The leftmost match.

Source: std/regexp.xo:27

Regex.find_index

fn (r: Regex) find_index(s: Str) -> (Int, Int)?

The byte offsets (start, end) of the leftmost match.

Source: std/regexp.xo:29

Regex.find_all

fn (r: Regex) find_all(s: Str) -> List[Str]

Every match, left to right, not overlapping.

std/smtp

Mon, 01 Jan 0001 00:00:00 +0000

Index

type SmtpErr
- method SmtpErr.display
type Auth
type Security
fn send

Types

SmtpErr

struct SmtpErr {
 code: Int
 msg: Str
}

A failed send: the server’s reply code and text (550 5.1.1 no such user), or code 0 for an error found before or outside a reply (a connection error, a CR or LF in an address, smtp: server doesn't support STARTTLS).

Source: std/smtp.xo:10

SmtpErr.display

fn (e: SmtpErr) display() -> Str

CODE MSG (net/textproto’s Error), or MSG alone for code 0 (decision 0358).

std/sql

Mon, 01 Jan 0001 00:00:00 +0000

Index

type SqlValue
type Isolation
type SqlErr
- method SqlErr.display
type ExecResult
type Db
- method Db.query
- method Db.rows
- method Db.each
- method Db.copy_from
- method Db.query_one
- method Db.exec
- method Db.query_as
- method Db.query_one_as
- method Db.begin
- method Db.ping
- method Db.close
type Tx
- method Tx.query
- method Tx.rows
- method Tx.each
- method Tx.copy_from
- method Tx.query_one
- method Tx.exec
- method Tx.query_as
- method Tx.query_one_as
- method Tx.commit
- method Tx.rollback
type Row
- method Row.columns
- method Row.decode
- method Row.value
- method Row.is_null
- method Row.int
- method Row.str
- method Row.float
- method Row.bool
- method Row.time
- method Row.int_opt
- method Row.str_opt
- method Row.float_opt
- method Row.bool_opt
- method Row.time_opt
- method Row.bytes
- method Row.bytes_opt
- method Row.json
- method Row.ints
- method Row.strs
- method Row.items
type Rows
- method Rows.columns
- method Rows.next
- method Rows.next_as
- method Rows.close
type Driver
type DriverConn
type DriverRows
type DriverCursor
fn null
fn int
fn str
fn float
fn bool
fn time
fn bytes
fn json
fn array
fn quote_ident
fn open
fn memory
fn open_driver

Types

SqlValue

enum SqlValue {
 Null
 Integer(n: Int)
 Text(s: Str)
 Real(f: Float)
 Flag(b: Bool)
 At(t: Time)
 Blob(b: Bytes)
 JsonText(s: Str)
 Array(items: List[SqlValue])
}

A query parameter. $1 is args[0].

std/sqlite

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Config
fn driver
fn config
fn version

Types

Config

struct Config {
 path: Str
 uri: Bool
 keys: List[Str]
 busy_ms: Int
 pragmas: List[Str]
}

A parsed DSN (see the module comment).

Source: std/sqlite.xo:30

Functions

driver

fn driver(fs: Fs) -> sql.Driver[fs]

The driver, opening database files through fs; its Db’s operations perform fs.

Source: std/sqlite.xo:40

config

fn config(dsn: Str) -> Config ! sql.SqlErr

The DSN’s parts; Param for an unknown _ key or a bad value.

Source: std/sqlite.xo:43

version

fn version() -> Str uses fs

The SQLite library’s version, e.g. “3.54.1”.

std/tabwriter

Mon, 01 Jan 0001 00:00:00 +0000

Index

const FILTER_HTML
const STRIP_ESCAPE
const ALIGN_RIGHT
const DISCARD_EMPTY_COLUMNS
const TAB_INDENT
const DEBUG
const ESCAPE
type TabWriter
- method TabWriter.write
- method TabWriter.flush
fn writer

Constants

FILTER_HTML

const FILTER_HTML: Int = 1

Flags (Go’s FilterHTML, StripEscape, AlignRight, DiscardEmptyColumns, TabIndent, Debug), added together.

Source: std/tabwriter.xo:8

STRIP_ESCAPE

const STRIP_ESCAPE: Int = 2

Source: std/tabwriter.xo:9

ALIGN_RIGHT

const ALIGN_RIGHT: Int = 4

Source: std/tabwriter.xo:10

DISCARD_EMPTY_COLUMNS

const DISCARD_EMPTY_COLUMNS: Int = 8

Source: std/tabwriter.xo:11

TAB_INDENT

const TAB_INDENT: Int = 16

Source: std/tabwriter.xo:12

DEBUG

const DEBUG: Int = 32

Source: std/tabwriter.xo:13

ESCAPE

const ESCAPE: Int = 255

The byte that starts and ends an escaped text (Go’s Escape): its bytes pass through as one piece of the cell, tabs and all.

std/task

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Timed
type Isolated
type Fault
type Budgeted
type Budget
type Group
- method Group.spawn
- method Group.spawn_background
type Semaphore
- method Semaphore.with
type Once
- method Once.get
fn budget
fn with_budget
fn with_timeout
fn isolate
fn is_canceled
fn stop_requested
fn stopping
fn deadline
fn map_concurrent
fn map_concurrent_until
fn semaphore
fn once

Types

Timed

enum Timed[E] {
 TimedOut
 Failed(from E)
} derive Display

Source: std/task.xo:5

Isolated

enum Isolated[E] {
 Faulted(info: Fault)
 Failed(from E)
} derive Display

Source: std/task.xo:10

Fault

struct Fault {
 msg: Str
 location: Str
 frames: List[Str]
} derive Display

Source: std/task.xo:15

Budgeted

enum Budgeted[E] {
 Exceeded(resource: Str)
 Failed(from E)
} derive Display

The outcome of task.with_budget (decision 0173): a ceiling was passed (resource is “cpu”, “alloc”, or “steps”), or f failed.

std/template

Mon, 01 Jan 0001 00:00:00 +0000

Index

type TemplateErr
- method TemplateErr.display
type TemplateFn
type Template
- method Template.add
- method Template.missing_key
- method Template.render
- method Template.render_named
type Parsed
fn parse
fn parse_html
fn html
fn css
fn js
fn jsstr
fn url
fn attr
fn srcset

Types

TemplateErr

struct TemplateErr {
 msg: Str
}

A parse or execution error, with Go’s text (template: t:1: function "nope" not defined).

Source: std/template.xo:9

TemplateErr.display

fn (e: TemplateErr) display() -> Str

The message, Go’s text (decision 0358).

Source: std/template.xo:14

TemplateFn

type TemplateFn = fn(List[json.Value]) -> json.Value ! Str

A template function (FuncMap, decision 0408): its arguments as the executor’s values, its result a value the template prints or passes on (escaped by the html mode’s context); Err text is the call’s error, error calling NAME: text. Pure: a function with effects cannot be called from a render.

std/term

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Painter
- method Painter.bold
- method Painter.dim
- method Painter.underline
- method Painter.red
- method Painter.green
- method Painter.yellow
- method Painter.blue
- method Painter.magenta
- method Painter.cyan
- method Painter.gray
fn color_enabled
fn painter
fn strip

Types

Painter

struct Painter {
 on: Bool
}

Wraps text in ANSI styles when on, else returns it unchanged. Make one with painter; Painter{on: false} in tests.

Source: std/term.xo:10

Painter.bold

fn (p: Painter) bold(s: Str) -> Str

Source: std/term.xo:21

Painter.dim

fn (p: Painter) dim(s: Str) -> Str

Source: std/term.xo:22

Painter.underline

fn (p: Painter) underline(s: Str) -> Str

Source: std/term.xo:23

Painter.red

fn (p: Painter) red(s: Str) -> Str

Source: std/term.xo:24

Painter.green

fn (p: Painter) green(s: Str) -> Str

Source: std/term.xo:25

Painter.yellow

fn (p: Painter) yellow(s: Str) -> Str

Source: std/term.xo:26

std/testing

Mon, 01 Jan 0001 00:00:00 +0000

Index

type TestOs
type Expect
type FakeNet
- method FakeNet.listen
- method FakeNet.dial
- method FakeNet.dial_timeout
- method FakeNet.lookup_host
- method FakeNet.interfaces
- method FakeNet.only
- method FakeNet.handle
- method FakeNet.handle_tls
- method FakeNet.fail
- method FakeNet.fail_next
- method FakeNet.clear_failures
- method FakeNet.requests
type FakeClock
- method FakeClock.now
- method FakeClock.sleep
- method FakeClock.sleep_or_cancel
- method FakeClock.since
- method FakeClock.advance
- method FakeClock.set
- method FakeClock.sleeps
type FsOp
type MemFs
- method MemFs.sub
- method MemFs.cwd
- method MemFs.cwd_path
- method MemFs.read_only
- method MemFs.write_only
- method MemFs.case_sensitive
- method MemFs.stat
- method MemFs.exists
- method MemFs.disk_usage
- method MemFs.read
- method MemFs.read_text
- method MemFs.read_dir
- method MemFs.walk
- method MemFs.write
- method MemFs.create_temp
- method MemFs.rename
- method MemFs.remove
- method MemFs.remove_all
- method MemFs.create_dir_all
- method MemFs.set_modified
- method MemFs.open
- method MemFs.create
- method MemFs.open_append
- method MemFs.open_rw
- method MemFs.create_new
- method MemFs.append
- method MemFs.copy
- method MemFs.mode
- method MemFs.set_mode
- method MemFs.symlink
- method MemFs.read_link
- method MemFs.glob
- method MemFs.lock
- method MemFs.try_lock
- method MemFs.fail_next
- method MemFs.set_case_sensitive
- method MemFs.set_disk_usage
- method MemFs.files
type FakeEnv
- method FakeEnv.get
- method FakeEnv.vars
- method FakeEnv.args
- method FakeEnv.program
- method FakeEnv.home
- method FakeEnv.only
- method FakeEnv.config_dir
- method FakeEnv.cache_dir
- method FakeEnv.hostname
- method FakeEnv.set
- method FakeEnv.set_args
type FakeStdio
- method FakeStdio.print
- method FakeStdio.println
- method FakeStdio.eprint
- method FakeStdio.eprintln
- method FakeStdio.write
- method FakeStdio.read_line
- method FakeStdio.read_all
- method FakeStdio.lines
- method FakeStdio.stdin_is_tty
- method FakeStdio.stdout_is_tty
- method FakeStdio.stderr_is_tty
- method FakeStdio.width
- method FakeStdio.read_secret
- method FakeStdio.read_bytes
- method FakeStdio.read_all_bytes
- method FakeStdio.set_input
- method FakeStdio.set_tty
- method FakeStdio.set_input_bytes
- method FakeStdio.output
- method FakeStdio.errors
type FakeProc
- method FakeProc.exit
- method FakeProc.set_grace
- method FakeProc.run
- method FakeProc.only
- method FakeProc.cmd
- method FakeProc.pipeline
- method FakeProc.exit_code
- method FakeProc.signal_after
- method FakeProc.on_run
- method FakeProc.kill
- method FakeProc.notify
- method FakeProc.stop_notify
- method FakeProc.request_stop
- method FakeProc.pid
- method FakeProc.ppid
- method FakeProc.usage
- method FakeProc.children_usage
- method FakeProc.killed
fn expect
fn gen
fn logs
fn fake_db
fn run_main

Types

TestOs

struct TestOs {
 net: FakeNet
 fs: MemFs
 clock: FakeClock
 rand: Rand
 env: FakeEnv
 stdio: FakeStdio
 proc: FakeProc
 tasks: task.Group
}

Source: std/testing.xo:17

std/time

Mon, 01 Jan 0001 00:00:00 +0000

Index

const RFC3339
const RFC1123
const DATE
const TIME
const RFC3339_LAYOUT
const RFC1123_LAYOUT
const DATE_LAYOUT
const TIME_LAYOUT
type Zone
- method Zone.display
- method Zone.name
- method Zone.offset_at
- method Zone.abbreviation_at
type ZoneErr
- method ZoneErr.display
type Date
- method Date.weekday
- method Date.add_days
- method Date.add_months
- method Date.days_until
- method Date.display
type ClockTime
type Civil
type Weekday
- method Weekday.number
type Ambiguity
type CivilErr
- method CivilErr.display
type Ticker
- method Ticker.wait
- method Ticker.reset
type Layout
- method Layout.display
- method Layout.format
- method Layout.parse
type ParseErr
- method ParseErr.display
type LayoutErr
- method LayoutErr.display
fn utc
fn zone
fn fixed
fn local
fn civil
fn instant
fn date
fn weekday_from
fn truncate
fn round
fn ticker
fn layout
fn format
fn parse
fn check_layout

Constants

RFC3339

const RFC3339: Str = "{year}-{month}-{day}T{hour}:{minute}:{second}{frac}{offset}"

Source: std/time.xo:146

RFC1123

const RFC1123: Str = "{weekday:short}, {day} {month:short} {year} {hour}:{minute}:{second} {zone}"

HTTP dates.

std/timego

Mon, 01 Jan 0001 00:00:00 +0000

Index

const ANSIC
const UNIX_DATE
const RUBY_DATE
const RFC822
const RFC822Z
const RFC850
const RFC1123
const RFC1123Z
const RFC3339
const RFC3339_NANO
const KITCHEN
const STAMP
const STAMP_MILLI
const STAMP_MICRO
const STAMP_NANO
const DATE_TIME
const DATE_ONLY
const TIME_ONLY
type Layout
- method Layout.format
- method Layout.parse
fn layout
fn format
fn parse

Constants

ANSIC

const ANSIC: Str = "Mon Jan _2 15:04:05 2006"

Go’s layout constants (time/format.go).

Source: std/timego.xo:7

UNIX_DATE

const UNIX_DATE: Str = "Mon Jan _2 15:04:05 MST 2006"

Source: std/timego.xo:8

RUBY_DATE

const RUBY_DATE: Str = "Mon Jan 02 15:04:05 -0700 2006"

Source: std/timego.xo:9

RFC822

const RFC822: Str = "02 Jan 06 15:04 MST"

Source: std/timego.xo:10

std/tls

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Verify
type Roots
type TlsErr
- method TlsErr.display
type TlsCert
type ClientAuth
type TlsConn
- method TlsConn.read
- method TlsConn.write
- method TlsConn.close
- method TlsConn.set_deadline
- method TlsConn.set_read_deadline
- method TlsConn.set_write_deadline
- method TlsConn.alpn
- method TlsConn.version
- method TlsConn.peer_certificates
fn roots
fn roots_of
fn cert
fn client
fn pin_sha1
fn pin_sha256

Types

Verify

enum Verify {
 Full
 ChainOnly
 None
} derive Display

How the server’s certificate is checked (std.md 27).

Source: std/tls.xo:9

Roots

struct Roots {}

Certificates a client trusts (std.md 27); a handle.

Source: std/tls.xo:16

TlsErr

struct TlsErr {
 msg: Str
}

Source: std/tls.xo:18

TlsErr.display

fn (e: TlsErr) display() -> Str

The message (decision 0358).

std/toml

Mon, 01 Jan 0001 00:00:00 +0000

Index

type TomlErr
- method TomlErr.display
type DecodeErr
- method DecodeErr.display
fn decode
fn to_json
fn encode

Types

TomlErr

struct TomlErr {
 line: Int
 msg: Str
}

Displays as toml: line 3: expected a value after =; an encode error has line 0 and displays as toml: msg.

Source: std/toml.xo:10

TomlErr.display

fn (e: TomlErr) display() -> Str

Source: std/toml.xo:15

DecodeErr

enum DecodeErr {
 Syntax(err: TomlErr)
 Value(err: json.DecodeErr)
}

Why decode failed: the text is not TOML, or its values do not fit T.

Source: std/toml.xo:34

DecodeErr.display

fn (e: DecodeErr) display() -> Str

Source: std/toml.xo:39

std/trace

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Span
type Ring
- method Ring.middleware
- method Ring.record
- method Ring.spans
- method Ring.handler
fn ring
fn id

Types

Span

struct Span {
 id: Str
 name: Str
 start_ms: Int
 micros: Int
 status: Int
} derive Json

One timed piece of work of a request: the request’s id, the span’s name (request for the whole request, a program’s own for the rest), when it started (Unix milliseconds), how long it took (microseconds), and the response status for request spans (0 otherwise).

Source: std/trace.xo:12

std/udp

Mon, 01 Jan 0001 00:00:00 +0000

Index

type UdpConn
- method UdpConn.read_from
- method UdpConn.write_to
- method UdpConn.read
- method UdpConn.write
- method UdpConn.local_addr
- method UdpConn.close
fn listen
fn dial

Types

UdpConn

struct UdpConn {}

A UDP socket: bound by listen (any peer) or connected by dial (one peer). A handle; close is idempotent.

Source: std/udp.xo:7

UdpConn.read_from

fn (c: UdpConn) read_from(max: Int = 65535) -> (Bytes, Str) ! NetErr uses net

The next datagram and its sender (“ip:port”); a datagram longer than max is cut to max, the rest discarded (Go’s ReadFrom).

Source: std/udp.xo:18

UdpConn.write_to

fn (c: UdpConn) write_to(data: Bytes, addr: Str) -> () ! NetErr uses net

Sends data as one datagram to addr; Net.only checks addr.

std/url

Mon, 01 Jan 0001 00:00:00 +0000

Index

type EscapeErr
- method EscapeErr.display
type Values
- method Values.get
- method Values.all
- method Values.has
- method Values.keys
- method Values.encode
- method Values.add
- method Values.set
- method Values.remove
fn query_escape
fn query_unescape
fn path_escape
fn path_unescape
fn values
fn parse_query

Types

EscapeErr

struct EscapeErr {
 msg: Str
}

A malformed escape or query; displays as Go’s text, for example invalid URL escape "%zz".

Source: std/url.xo:7

EscapeErr.display

fn (e: EscapeErr) display() -> Str

Source: std/url.xo:11

Values

struct Values {}

Query keys with their values in order (url.Values): keys in the order they first appeared, each with every value given for it. A value, not a handle.

std/uuid

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Uuid
- method Uuid.version
- method Uuid.bytes
- method Uuid.display
- method Uuid.debug
type UuidErr
- method UuidErr.display
fn v4
fn v7
fn parse
fn from_bytes
fn nil

Types

Uuid

struct Uuid {
 hi: Int
 lo: Int
} derive Ord

A UUID: its 16 bytes as two words. u.display() (or "${u}") is its canonical text, u.bytes() its bytes, u < v the order of its bytes. @internal: use u.bytes() and uuid.from_bytes(b), u.display() and uuid.parse(s), or u < v

Source: std/uuid.xo:12

Uuid.version

fn (u: Uuid) version() -> Int

Source: std/uuid.xo:40

Uuid.bytes

fn (u: Uuid) bytes() -> Bytes

Source: std/uuid.xo:41

std/websocket

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Message
type Kind
type WsErr
- method WsErr.display
type WsConn
- method WsConn.read
- method WsConn.write
- method WsConn.write_text
- method WsConn.ping
- method WsConn.close
- method WsConn.subprotocol
- method WsConn.set_deadline
- method WsConn.set_read_deadline
- method WsConn.set_write_deadline
- method WsConn.on_ping
- method WsConn.on_pong
- method WsConn.pong
fn upgrade
fn dial

Types

Message

struct Message {
 kind: Kind
 data: Bytes
}

A whole message: its kind and data (a text message’s data is valid UTF-8).

Source: std/websocket.xo:9

Kind

enum Kind {
 Text
 Binary
}

Source: std/websocket.xo:14

WsErr

enum WsErr {
 Closed(code: Int, reason: Str)
 Protocol(msg: Str)
 TooBig(limit: Int)
 Net(err: NetErr)
 Handshake(status: Int, msg: Str)
}

Why a connection stopped or an operation failed. Displays as gorilla’s errors: websocket: close 1001 (going away): bye, websocket: unknown opcode 3, websocket: read limit exceeded, websocket: bad handshake.

std/x509

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Name
- method Name.display
- method Name.attributes
type Extension
type KeyUsage
type ExtKeyUsage
type Certificate
- method Certificate.verify
- method Certificate.verify_hostname
- method Certificate.check_signature_from
- method Certificate.pem
type CertErr
- method CertErr.display
type Pkcs12
type VerifyOptions
type Template
type CertificateRequest
- method CertificateRequest.check_signature
- method CertificateRequest.pem
type RequestTemplate
type RevokedCertificate
type RevocationList
- method RevocationList.check_signature_from
fn parse
fn parse_pkcs12
fn parse_pem
fn create_certificate
fn self_signed
fn create_request
fn parse_request
fn parse_revocation_list
fn system_roots

Types

Name

struct Name {
 country: List[Str] = []
 organization: List[Str] = []
 organizational_unit: List[Str] = []
 locality: List[Str] = []
 province: List[Str] = []
 street_address: List[Str] = []
 postal_code: List[Str] = []
 serial_number: Str = ""
 common_name: Str = ""
 raw: Bytes = b""
}

A distinguished name (Go’s pkix.Name): the common attributes, each list in the order the name has them, and its DER. A Name to build (Template.subject) leaves raw empty and sets the fields it needs.

std/xml

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Name
type Attr
type Token
type XmlErr
- method XmlErr.display
type Reader
- method Reader.next
type Element
- method Element.attr
- method Element.child
- method Element.children_named
- method Element.text
- method Element.encode
type Node
fn tokens
fn raw_tokens
fn reader
fn raw_reader
fn parse
fn escape
fn escape_to
fn encode_value
fn decode

Types

Name

struct Name {
 space: Str
 local: Str
} derive Eq, Ord, Hash

An element or attribute name. space is the namespace URL once resolved (the prefix itself in raw tokens); empty for none.

Source: std/xml.xo:9

Attr

struct Attr {
 name: Name
 value: Str
} derive Eq

Source: std/xml.xo:14

std/xmlcodec

Mon, 01 Jan 0001 00:00:00 +0000

Index

type Piece
type Writer
type Event
fn open_path
fn leaf
fn child
fn chardata
fn comment
fn attr
fn build
fn writer
fn write_start
fn write_open
fn write_leaf
fn write_chardata
fn write_end
fn written
fn parse_root
fn attr_of
fn events
fn direct_text
fn float_text
fn int_of
fn float_of
fn bool_of

Types

Piece

struct Piece {
 parents: List[Str]
 kind: Int
 name: Str = ""
 text: Str = ""
 el: xml.Element? = None
}

One part of a struct’s element: its parents path (the a>b of a field’s name, empty for none), and what to write there.

Source: std/xmlcodec.xo:12

std/yaml

Mon, 01 Jan 0001 00:00:00 +0000

Index

const TAGGED
const DOUBLE_QUOTED
const SINGLE_QUOTED
const LITERAL
const FOLDED
const FLOW
type YamlErr
- method YamlErr.display
type NodeKind
type Node
type RawNode
type Doc
type Ev
type Enc
type Dec
fn decode
fn encode_value
fn decode_all
fn encode_all
fn parse
fn parse_all
fn to_json
fn encode_node
fn parse_doc
fn root
fn is_null
fn to_str
fn to_int
fn to_float
fn to_bool
fn items
fn pairs
fn bad_key
fn errors
fn zero_node
fn put_node
fn to_node_field
fn enc_new
fn set_flow
fn map_start
fn map_end
fn seq_start
fn seq_end
fn put_null
fn put_bool
fn put_int
fn put_float
fn put_str
fn sorted_keys
fn finish
fn dec_new
fn unknown_field
fn tick
fn leave
fn parse_docs
fn finish_all
fn to_duration
fn to_time
fn put_time
fn to_civil
fn zero_civil
fn put_civil
fn to_bytes
fn put_duration
fn put_bytes

Constants

TAGGED

const TAGGED: Int = 1

Style bits of a Node, as yaml.v3’s Style: TAGGED (the tag is written), DOUBLE_QUOTED, SINGLE_QUOTED, LITERAL, FOLDED, FLOW.