ezx

Search uses release 1.11.0.0 · 2,947 definitions

Releases (9)

1.11.0.0 indexed
1.10.0.0 unindexed
1.9.0.0 unindexed
1.8.0.0 unindexed
1.7.0.0 unindexed
1.6.0.0 invalid
expected a fresh constructor name (duplicate declaration: Text)

at src/lock/up.bend:121
19 files do not load
expected a file at https://hub.bend-lang.com/0x49ec536f1d3da4f76d78aaece3ccda7a/manifest hashing to 49ec536f1d3da4f76d78aaece3ccda7a

at src/hub/get.bend:7
12 files do not load
1.5.0.0 invalid
expected a fresh constructor name (duplicate declaration: Wait)

at src/add/hub.bend:87, src/pub/plan.bend:1080, src/tool/plan.bend:867
10 files do not load
1.4.0.0 invalid
expected a fresh constructor name (duplicate declaration: Wait)

at src/add/hub.bend:87, src/pub/plan.bend:1080, src/tool/plan.bend:867
10 files do not load
1.3.0.0 unindexed

Definitions (2,947)

src/ez/key.bend

def nonethe record that matches nothing: an empty commit is never reused
def showthe record as it is written, one field to a line
def read.thirdexactly three lines, or no record.
def read.second
def read.lines
def reada record's text, as `show` wrote it and a file read trimmed it
def checkoutthe checkout is this commit, and there is a commit at all.
def reusethe three fields the same, and a commit at all.

src/ez/line.bend

type Suba subcommand
def specthe program: every command, and the flags and positionals it binds
def commanda subcommand by its path, the words joined with `/`.
def is.helpwhether a subcommand is the one that names no command
def paththe path a match names, its words joined with `/`
def leafthe Matched of the command the path names, whose bindings are the ones the line made for that command (SHAKE-GET-2: `at(m, path_of(m))` follows the selected path).
def getthe value the command bound to `name`, or "" when it bound none
type Linea command runs, with what the line bound for it; help is shown, on stdout; or the line is misused, and says so on stderr
def line.erra line Shake would not parse: a request for help, whose path Shake has already checked word by word (SHAKE-PARSE-8: `help bogus` fails as `Unexpected`, not as a request for help), or a usage error
def line.groupa path that names no command: a bare `ez` is help, as a bare `cargo` is, and a bare group such as `ez tool` is a line that did not say which of its commands to run, as `cargo report` with no command is, so its help goes to stderr and the line fails
def line.runa line Shake parsed: the command its path names runs, or it names none
def linehow a line ends, from what Shake made of it
type Statusthe status a line exits with, when it is decided here, or the command's own end (EZ-OUT-1)
def statushelp exits 0, a misused line 1, and a command that runs ends as it ends

src/ez/main.bend

def dispatchwhat a subcommand runs.
def hint.sync`sync` with no tools is lock or install; a ledger that pins tools already names the command that builds them.
def go.saywhat a line says: the command it names run, its help on stdout, or what was wrong with it on stderr, with a hint for `ez sync`
def go.exita status that is 0 ends nothing, and any other exits with it
def go.enda status decided before any command ran, exited with; a command's own end is its own
def go.linehow the line ends, as `L.line` decided, and the status `L.status` gives it
def gothe line taken apart
def main

src/ez/named.bend

type Seena text walked from its end: whether a slash has been passed yet, and what lies after the last one
def last.atone char in front of what was seen, when no slash has been passed yet
def last.stepone char in front of what was seen.
def lastthe text after its last slash, and whether it had one
def leaf.ofwhat lies after the last slash
def leafthe last component of a path, a slug or a url
def calledthe name a source gives itself.
def bare.stepone char of a key, with the rest still to be asked about.
def bare.restthe rest of a TOML bare key: letters, digits, `-` and `_`
def barea TOML bare key: at least one char, each a letter, a digit, `-` or `_`.
def fromwhether a source is this git url
def had.ata dependency's name when it is this source, or the answer further on
def hadthe name the ledger already gives this url, first in document order, or the fresh one when it gives none.
def ownthe package's own name when it is a bare key, or the name its source gives it.
def namethe name a dependency is recorded under: the ledger's for this source, else the package's own, else its source's
def clash.atthe first dependency of this name, asked whether it is another source
def clashwhether the ledger gives this name to a source other than this url.
def whywhy a name cannot be recorded, or nothing when it can
def as`--rename`, the way `cargo add --rename` works: when it is given, it is the name, ahead of every rule above
def renamed.oka `--rename` that can stand as a key, or none at all
def moved.ofwhether a `--rename` gives a second name to a source the ledger already records as `old`, "" when it records none
def movedwhether a `--rename` would record a source the ledger already names under a second name.
def why.aswhy a name cannot be recorded when `--rename` may have been given, or nothing when it can
def hub.partthe name part of a `<name>@<version>`, what comes before its `@`.
def hub.fromwhether a source is a hub package added by a name with this name part, whatever its version
def hub.hadthe name the ledger already gives a hub package of this name part, first in document order, or "" when it gives none.
def hub.keythe name a hub package is recorded under: `--rename` when it is given, else the ledger's for this name part, else the name part itself
def hub.clash.atthe first dependency of this name, asked whether it is another source
def hub.clashwhether the ledger gives this name to anything but a hub package of this name part: a git dependency, or one added by its hash
def hub.whywhy a hub package cannot be recorded under a name, or nothing when it can: a `--rename` that is no key, a `--rename` of a name part the ledger records under another name, or a name the ledger gives another source

src/ez/prove.bend

def find.atevery file of a kind in the tree, sorted, so a run's report is the same twice over.
def find.proofsevery proof file
def widthhow many `bend` runs may be in flight at once.
def fresh.dira directory emptied and made again, so nothing a run reads was written by the run before it
def out.atwhere the jobs of this run write what they print
def head.ofthe first line of a run's output
def headthe first line of some text
def verdictthe one line a proof passes on
def indent.goevery line of a block, indented under the line that introduces it
def indenta block of text, indented
def cmda `bend` on one file, inside the memory cap and with this project's BEND_LIB set for it
def cmdsevery file's command, in the tree's order
def sayone proof's line.
def countone more proof counted, and one more pass when it held
def oneone proof against its answer: the run's first line, with a memory kill turned into a sentence in front of what it printed
def shortevery proof the answers ran out before.
def reportevery proof, in the tree's order however the run happened to interleave
def donethe count, and the exit status it implies.
def run`ez prove`: every PROOF.bend in the tree, run at once and reported in the tree's order.

src/ez/quiet.bend

def is_nagwhether this line is bend telling us a newer bend exists.
type Taila trailing run of blank lines, being dropped from the right.
def puta line kept or dropped
def gothe lines with the nag dropped
def tail.blanka blank line: kept once something after it has survived, dropped while the run of trailing blanks is still open
def tail.lineone line offered to the tail.
def tail.stepa fold from the right: until a line survives, a blank one is dropped
def tail.outwhat a finished fold collected
def tail.walkthe fold from the right, written out.
def chomp.linesthe lines with the blank ones at the end dropped, the way a shell's `$(...)` drops a trailing newline, so a comparison never turns on one
def chompthe text with its trailing blank lines dropped
def filtera run's output as a test's `#|` trailer states it: no update nag, no trailing newline

src/ez/sorted.bend

def sort.ins.putwhere one string belongs in a list already sorted, once the rest of that list has been placed.
def sort.insone string dropped into a sorted list
def sortthe strings in order.

src/ez/start.bend

type Askwhich of the three commands is asking, with what it was told: where a build goes, and every word of the line for a run
type Startwhat a command does: refuse with a reason, having started nothing, or start bend with this line
def doeswhat each command is for, in the words a refusal says it with
def nonewhy a directory with no ez.toml is refused
def entry.orthe entry file a ledger names, or "main.bend" when it names none
def entrythe entry file of a ledger that parsed