ezx
Search uses release 1.13.0.0 · 2,947 definitions
Definitions (2,947)
- def digits.at
- def digitsa non-empty run of decimal digits
- def nums.cons
- def nums.put
- def nums.of
- def id.char
- def id.chars
- def id.make
- def ids.cons
- def ids.ok
- def ids.put
- def ids.of
- def pre.parts
- def pre.of
- def split1.put
- def split1.step
- def split1a string cut at the first of a character, the character dropped; no hit leaves the whole string on the left
- def unv.step
- def unva tag with one leading `v` or `V` dropped
- def ver.yes
- def ver.pre
- def ver.nums
- def ver.from
- def ver.cut
- def ver.main
- def ver.core
- def ver.ofa tag read as a version.
- def newerwhether the first version is strictly newer
- def latest.cmp
- def latest.have
- def latest.step
- def latestthe newest semver-ish name, or "" when none of them is one
- def release.vera version with no pre-release, which is a release
- def releasea semver-ish tag that is a release: `v1.9.0`, not `v2.0.0-rc1`
- def latest.rel.stepa name that is a release, weighed against the greatest release after it the way `latest` weighs any two versions; a name that is not is passed over
- def latest.relthe greatest release, or "" when no name is one
- def has.release.stepone name found to be a release, or the rest still to be asked about
- def has.releasewhether any name is a release
- def choose.gothe greatest release when there is one, and otherwise the greatest of what is left, every one of which is a pre-release
- def choosethe tag `ez add` pins when no ref was asked for: a release beats every pre-release, however much greater the pre-release's numbers are, and within each class the greatest wins by `ord.ver`, the later of two equal ones winning as `latest` has it.
- def tag.putone row's tag name, or nothing when the row is peeled or not a tag
- def tag.keep
- def tag.one
- def tag.namesevery tag name `ls-remote --tags` wrote, peeled rows left out
- def get.replywhat ezhttp answered.
- def get.httpa url fetched over a socket
- def get.filea file url read off the disk
- def get.schemea url whose scheme decides where the body comes from
- def get.loca url that came apart, or the reason it did not
- def getthe body at a url: "0" and the body, or a status and the reason
- def fetchthe file at a url, accepted only when it hashes to `want`
- def get.statusa status other than 200 is a miss with the number in it, never a body
- def get.file.gota file url read off the disk.
- def matchesa body is the one that was asked for when its digest starts with the hash
- type Gotwhat a fetch answered: the body when it arrived and hashed right, otherwise the reason, so a caller never mistakes an error page for a package file
- def judge.hashthe digest's verdict on a body that did arrive
- def judgea fetch judged, once the run and the digest are both known
- def showa fetch's outcome on one line
- type Worldwhat `ez init` reads: the name, entry file and description asked for ("" for none), and the texts of ez.toml, `.gitignore`, the entry file and `src/lib.bend`, None when absent
- def tomlthe ledger's path, which is fixed
- def ignore.filewhere the ignore rules go
- def lib.filewhere the library a new project starts with goes
- def name.orthe name a new ledger takes: what was asked for, or `app`
- def entry.orthe entry a new ledger names: what was asked for, or `main.bend`
- def ruleseverything ez writes into a project that is not the project's: the vendored packages, the test gate's shadow and its cache all live under one `.ez/`, and `ez build` drops a binary in `bin/<name>.out` (`build.named` in ez/start.bend) unless it is told otherwise.
- def stated.stepone step of a scan that is looking for one hit, with the head's answer in hand.
- def statedwhether a file already states this rule, on a line of its own.
- def missingthe rules a file does not already state, in order
- def taila file's text with a newline on the end, so what is appended to it starts on a line of its own.
- def ignoredthe ignore file with the rules it lacks added under a line saying whose they are.
- def headerthe line a new entry opens with, which the hub shows as the package's description: the description asked for, or a placeholder that says one is still to be written.
- def bodythe rest of a new entry: a program that checks and runs, saying what the library it was laid out with gives it, or `hello` when there is none
- def stubthe entry of a new project: its line for the hub, then the program
- def libthe library a new project starts with, which its entry imports
- def text.ofa file's text, "" when it is not there
- def ignore.put`.gitignore` written ahead of the rest when it lacks a rule.
- def duewhether the stub is written: nothing is at the entry, so `ez init` does not overwrite the program, and the entry is not ez.toml or `.gitignore`, so the stub is not written over the file this plan just wrote there
- def layswhether `src/lib.bend` is laid out with the stub: nothing is there yet, so a library already there is never written over, the stub is written, and it sits at the project's top, where its `./src/lib.bend` import finds it.
- def main.putthe stub at the entry when it is due, ahead of the rest
- def lib.putthe library when it is laid out, ahead of the rest
- def filesthe files written after the ledger and the ignore rules: the library and the stub, each when it is due
- def modelthe ledger a new project starts from: this package, its entry, and nothing else, so no `publish-as` or `version` and a project that publishes by hash
- def freshits text
- def fitswhether a new project can be written: its ledger reads back (EZ-LED-4), and the line its entry opens with is one line, so the description cannot spill into the program
- def why.unfitwhy a new project that does not fit is refused
- def plan.newthe new project's files, once it fits.
- def plan.gothe plan, once the name and entry are settled.
- def plan`ez init` over a World
- def refuses.planwhether a plan ends in a refusal
- def refuseswhether `ez init` refuses on a World
- def run`ez init [name] [entry.bend] [--description TEXT]`
- def slurp.endthe handle closed, and whatever was gathered
- def slurp.cutan empty chunk means the end of the file
- def slurp.morea failed read ends the file as surely as an empty one
- def slurp.nextthe handle comes back paired with what it read
- def slurpthe whole file, read in chunks until one is empty, or the fuel is
- def unsizedthe reads a file with no size to go by may take: a pipe, a device or a /proc file reports 0 bytes and a file past 4 GiB fails to report, so these are read until they end, up to 100000 reads of 64 KiB, past any file ez reads
- def reads.givena size of 0 is no size to go by; any other is read to
- def readsthe reads a file of this many bytes takes: one for every 64 KiB, one for the part past the last whole 64 KiB, and one to spare for a short read
- def reads.ofthe reads the size the host reported allows