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/doctor/plan.bend

def checkedwhat doctor says of the lock against the lock `ez lock` would write
def trees.askedeach lock question, put to BEND_LIB
def names.askedeach of the lock's name questions, put to BEND_LIB as the name's file.
def trees.worldthe lock questions over the sources git listed, packages and then names
def trees.listing
def trees.heardthe lock questions, once the sources were heard
def trees.ofevery package and name the lock planner asks about, while there is a lock to check.
def ledger.seenthe ledger as doctor sees it: its package, its entry and its dependencies.
def head.notesthe toolchain, the ledger, the lock and the library, each on its line, and the lock check's line after them
def notes.ofevery line doctor says, in order: the toolchain, the ledger, the lock, the library, the lock check, and last the drift report over the sources as they were heard
def note.wrongwhether a note is a problem
def wrongwhether anything found was a problem.
def sayseach line said
def outcome.ofa problem must fail the command, or a script around it learns nothing.
def plan.notesthe plan for these notes: every line said, and the command failed when one of them is a problem
def plan.ofthe plan over what a World read, field by field, with the lock check's lines
def plan`ez doctor` over a World
def refuses.planwhether a plan ends in a refusal
def refuseswhether `ez doctor` fails on a World
def open.puta question kept when it has no answer yet
def openthe questions of a list that have no answer yet
def probe.asksa version question for every program
def lib.asksthe library is looked in only when the lock names a package to look for
def sources.asksthe sources are read only when there is a ledger to compare them with
def names.asksa question for every name's file the lock records
def asks.ofevery question doctor asks on what a World read, besides the lock check's
type Stepthe questions still open, or the plan once there are none
def step.asksthe step, once the open questions are known
def step.ofthe step over what a World read, field by field, with the lock check's questions and lines.
def stepwhat the interpreter does next on a World
def wantsthe questions a World still leaves open
def said.onewhether an effect says this line
def said.inwhether a list of effects says this line
def saidwhether a plan says this line
def drift.ofthe drift report doctor makes of a World's sources against a ledger's dependencies

src/doctor/run.bend

def probe.askhow a program is asked for its version, once it is known whether this is bend.
def tree.reada tree under BEND_LIB, as it is: its manifest and every file it names, read from beside it.
def tree.seena tree whose manifest was looked for; none there is none at all
def treea package's tree under the library directory
def answerone question, answered.
def answer.allevery question, answered
def morethe World with more answers in it
def loop.stepthe planner's step: its questions answered and the loop gone round again, or its plan run
def roundsthe rounds the loop may take.
def loopthe loop, under fuel.
def vara variable's text, "" when it is unset
def run.doctoredthe loop, on the ledger the doctor judges
def run`ez doctor`: the toolchain and the project, reported on

src/doctor/world.bend

type Aska question the planner asks
type Answerthe answer to one: what a program printed, and whether it ran; or the sources as the lock lists them; or a package's tree as BEND_LIB holds it, or that BEND_LIB holds none
type Replyone question, answered
type Worldeverything `ez doctor` reads
def tomlthe ledger's path, which is fixed
def lockfilethe lock's path, which is fixed
def ccwhat `$CC` holds, "" when it is unset
def libwhat `$BEND_LIB` holds, "" when it is unset
def ledgerthe ledger's text, None when there is no ez.toml
def lockthe lock's text, None when there is no ez.lock.toml
def repliesevery question answered so far
def read.ofthe ledger as read: what the file says, or, with no file, a read that did not parse and says why, as every command that reads a ledger says it
def readthe ledger, read
def keya question as a key.
type Heardan answer looked up, or none yet
def look.stepthis answer when it is the question's, otherwise the rest's.
def lookthe first answer given to a question
def heardthe answer to a question, or none yet
def sourcesthe answer the sources question has had on a World, or none yet

src/ez/clock.bend

def onwhether a budget is being kept at all
def by.effectthe deadline as the run effect wants it: an absolute second, or "0" when there is no budget to keep.

src/ez/cmd.bend

def tomlthe ledger's path, which is fixed
def startedwhat `ez check`, `ez build` or `ez run` does, decided from ez.toml as it is on disk (`S.start`): a missing or unreadable ledger is refused before anything is started or made
def refuseda refusal said, and the command ended on it with exit 1
def report.cappeda build's output, printed with a word in front of it for a run the kernel ended rather than the program, and the command ended on it (`E.ran`): a failed build must fail the command, or a script around it learns nothing.
def check.saida passing check says so, since bend says nothing when it is happy, and a failing one shows what bend said
def check.gothe entry checked, and never run, once `.ez` is there for its JS.
def check`ez check`
def build.goa native binary, named after the package (`S.build.out`), once the directory it lands in is there.
def build`ez build [out]`
def run.startedthe program `ez run` starts, on ez's own stdin, stdout and stderr, with the project's BEND_LIB set for it, and the status it exited with; 0 when the run was refused, which starts none
def run.goa run, and how it ends: exit 1 with the reason for a refusal, and the program's own status otherwise (`S.code`, EZ-OUT-1)
def run`ez run [args..]`: the entry run by bend, which checks it first, with every word after `run`, as `cargo run` runs a project's binary
def publish`ez publish`, planned by pub/plan.bend: the entry the ledger names, sent to the hub once the tree is clean and git tracks every file of the package, and bend's answer checked against the `0x` name ez computed.
def lock.go`ez lock`, plain or `--upgrade`, is the planner's (lock/plan.bend, lock/up.bend): a plain lock copies every pin as the ledger has it, refuses one it would have to fill, and never writes ez.toml; an upgrade moves the selected pins, writes ez.toml once, `.gitignore`, the rewritten imports and the lock in one plan.
def lock`ez lock` and `ez lock --upgrade [--package NAME]`
def fetch`ez fetch`, planned by fetch/plan.bend: BEND_LIB filled from the lock, with nothing re-resolved, and nothing laid unless every package checks
def init`ez init [name] [entry.bend] [--description TEXT]`: a new project, planned by init/plan.bend
def add`ez add <target> [rev|tag|branch] [entry.bend] [--rename NAME]`, planned by add/plan.bend.
def remove`ez remove <name>`, planned by remove/plan.bend

src/ez/ends.bend

def outcome.ofa command that ends on whether it passed: success, or a refusal whose reason was already printed
def lock.flags`ez lock --package NAME` without `--upgrade` is a line ez refuses before it reads anything, since `--package` only filters an upgrade
def ran`ez build`: bend exited 0
def no.main`bend f -o out` checks without running main.
def said.no.mainwhether any line of the output is that one.
def check.passedwhether `ez check` passed: bend exited 0, or said only that there is no main
def checked`ez check`
def counted`ez test` and `ez prove`: every file passed

src/ez/gate.bend

def want.puta trailer line kept, with its `#|` dropped, or a source line ignored
def wantthe `#|` lines of a source file, in order
def trailerwhat a test file says its run must print

src/ez/key.bend

type Stampthe commit, the file handed to bend, and the bend that built it