ezx

Releases (11)

• 1.13.0.0 indexed
• 1.12.0.0 unindexed
• 1.11.0.0 unindexed
• 1.10.0.0 unindexed
• 1.9.0.0 unindexed
• 1.8.0.0 unindexed
• 1.7.0.0 unindexed
• 1.6.0.0 unindexed
• 1.5.0.0 unindexed
• 1.4.0.0 unindexed
• 1.3.0.0 unindexed

Definitions (2,947)

src/share/say.bend

• def briefa commit as a line shows it
• def label.goa package's name when its entry has one, otherwise the hash.
• def labelwhat a line calls a package
• def dep.git`dep sha256: git fetch (https://github.com/…)`
• def dep.huba package taken from the hub
• def reuseda binary already built for this commit
• def resolvingthe lock resolving every dependency
• def resolving.at
• def git.fetch
• def buildinga binary being built
• def linkinga binary being linked into place
• def installeda binary built and linked
• def linkeda binary linked, with nothing to build
• def hashinga commit's tree being weighed for its NAR hash
• def tty.ata device path that is a terminal.
• def tty.out
• def tty.pick.gostderr's terminal when it is one, otherwise stdout's, otherwise none
• def tty.pick
• def hub.missthe hub answered 404 for a manifest.
• def hub.explain.go
• def hub.explain
• def drift.wherethe commit the words name.
• def driftthe tagged commit's tree no longer hashes to the pin.
• def stucka drift judged before the tree was weighed, so there are not two hashes to show
• def has.toolsa `[tools.` section in the ledger text.
• def hint`ez sync` is not a command.
• def probethe parent's fd, by number.
• def framesa mark on the terminal while the parent is alive.
• def settlethe mark wiped, and the line left in its place

src/share/sha.bend

• def packfour big-endian bytes in one word, each kept to eight bits
• def byteone character as the byte it contributes
• def words.ofhow many words hold this many bytes
• def depth.stepone more bit of depth when the capacity does not yet hold the words.
• def depth.gothe depth of an array whose capacity, 2^depth, is at least `words`
• def depththe depth of the array that holds this many words, at most 32
• def fillthe string packed into the array, four bytes to a word.
• def bytesthe string packed into big-endian words, four bytes each
• def showa length that does not fit is not a digest.
• def rawthe hex sha256 digest of a string whose characters are bytes: each one is reduced to its low eight bits.
• def utf8.byteone byte as a character: a UTF-8 string is held in a Bend string one byte to a character, the shape `raw` hashes
• def utf8.one
• def utf8.two
• def utf8.three
• def utf8.four
• def utf8.put.three
• def utf8.put.two
• def utf8.put.ascii
• def utf8.put
• def utf8the string's characters encoded as UTF-8, each byte a character
• def hexthe hex sha256 digest of a text's UTF-8 bytes, which is what `sha256sum` says of the file the text was read from, and what `bend --publish` and the hub hash a package file and its manifest by.

src/share/spin.bend

• def linkone fd of this process, as a path.
• def devthe terminal this process writes to, stderr's first, or empty for none
• def startthe mark, when there is a terminal to draw it on
• def hold.at
• def holdthe line, then the mark when a terminal will show it moving.
• def oweda spinner that never started still owes its line, unless the plain path already printed it and left the message empty
• def done.livethe mark stopped, and the line written where it was
• def done.bad
• def donethe step finished: the mark stopped and the line left, or the line owed

src/toml/toml.bend

• type Kva key and the string written for it
• type Secta section header and the pairs under it, in the order they were written
• type Tomla document read: the first error, "" when there is none, a name kept for the shape callers match on (always ""), the pairs above the first header, and every section that holds a pair, or holds no table, in document order
• def value.atthis pair's value when the key matches, otherwise whatever the rest of the table gave
• def valuethe value written for a key in a table, or "" when it is absent.
• def sectsthe sections a parse found, in the order they were written
• type Symwhat a header's next character is: the quoting toggles, an unquoted dot cuts, anything else is kept
• def seg.syma header char classified.
• type Splita header being cut apart: `quoted` is true inside quotes, `cur` is the segment being gathered and `out` the finished ones, both reversed
• def seg.charsthe chars gathered so far, last read first, spelled in the order they arrived
• def seg.donethe segment gathered so far, in order
• def seg.dota dot inside quotes is part of the segment; outside, it ends one
• def seg.gothe state once a char has been classified
• def seg.stepone char of a header against the state
• def seg.finthe segment still being gathered, closed, and the rest put back in order
• def seg.walkthe walk one char at a time, written out rather than folded
• def segmentsa header's segments, unquoted.
• def quotea string in quotes, which is how a segment or a key that is not bare is written, and how every value is
• def bare.ata char a bare key may hold.
• def bare.all.stepone step of the walk, with the head's answer in hand.
• def bare.allwhether every char of a key is one a bare key may hold.
• def barewhether a key can be written without quotes
• def keya key as it is written: bare when it can be, quoted when it must be
• def render.pairone `key = "value"` line
• def render.pairsevery pair of a section, in the order it holds them
• def render.sectone table: its header, then its pairs.
• def render.allevery table of a document
• def rendera document of tables, one blank line between them, as ez assembles it; `normal` is what is written
• def normala document written as eztoml writes it: read by eztoml, and rendered back
• def flag.texta truth value as TOML writes it
• def pair.ofa pair whose value is written as text: a string or a boolean, as ez writes them; an integer as its digits.
• def pairs.ofthe pairs among a table's rows, in order
• def row.tablewhether a row is a table
• def has.table.stepthe rest of the walk, when this row was not a table
• def has.tablewhether a table's rows hold a table, stopping at the first
• def head.ofa header as ez names it: its segments, each bare or quoted, joined by dots
• def sect.puta table's section, when it holds a pair or no table.
• def sect.keep
• def table.sectsa table's section, then the sections of the tables in it
• def tablesthe sections of every table among a table's rows, in document order: each table's own section, then the tables in it, then the tables after it.
• def parse.ofa document eztoml read, as sections