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

def path.safewhether a path stays inside the tree it is laid in: written the way the path walk writes it, so no `.` or `//` in it, not empty, not absolute and not climbing out with `..`.
def paths.safewhether every path stays inside the tree
def manifestthe manifest of the files laid, weighed by their own texts
def namedthe `0x` name of the files laid, weighed by their own texts
def goodwhether a package may be laid: every file is the one the lock names, no path leaves the tree, and the files hash to the name the lock records them under, so the tree laid under that name is that name's
def unfit.pickthe first file that is not the one the lock names, or "" when none is wrong.
def unfitthe first path that does not fit, "" when every file does
def bad.whywhy a package may not be laid, naming it
type Partwhere one package stands: its tree under BEND_LIB still to read, its fetch still to ask, a tree under BEND_LIB that passed and is kept, the files that arrived, or why nothing arrived
def part.treethe files that arrived for a package, or why none did
def part.fetch.hearda package fetched, once it is answered
def files.ofthe committed files a listing names, as the walk takes them
def member.samea member's walk, once it is known whether it hashes to the hash the lock records: the files it walked, or a refusal naming the member
def member.walkeda member's package walked from its entry over the committed files
def member.listeda workspace member's package, once the committed files were asked for
def member.answera workspace member's package, by what the question was answered with
def part.membera workspace member's package (EZ-WS-8): laid from the committed files only when its walk from its entry hashes to the hash the lock records for it
def part.fetcha package fetched, from where the lock says it comes from
def part.kepta tree under BEND_LIB that passes is kept; any other is fetched
def part.foundthe tree under BEND_LIB, read: checked the way a fetched one is, and fetched when it is not there
def part.laidthe tree under BEND_LIB, once it is read
def partwhere one package stands
def nar.whywhy a checkout may not be laid for the narHash it weighed to, "" when it may: the lock records a narHash and the checkout weighed to it
def unweighedwhy a package stands without a weighed checkout
def weighed.upwhat a checkout question was answered with, against the lock's narHash
def weighed.answer
def weighed.heard
def weighed.src
def weighedwhy the checkout a package of the lock was fetched as may not be laid, "" when it may.
def weigh.got
def weigh.partfiles that arrived stand only when the checkout they came from weighed to the lock's narHash.
type Ptone package of the lock, and where it stands
def partsevery package of the lock, and where each stands
type Nmwhere one name of the lock stands: its names file still to read, a file that already holds the lock's hash, a file to write, with the hash the one there held ("" when there was none), or why the name refuses the fetch
def name.helda names file that was there, against the lock's hash.
def name.gotwhat BEND_LIB holds for a name
def name.answera names file, once it is read
def name.heard
def name.valida name bend would read back is looked for under BEND_LIB; any other stops the fetch, since the file laid for it would not be the one bend reads
def name.partwhere one name of the lock stands
def name.partswhere every name of the lock stands
def name.rewrotehow a rewritten names file is said to have been rewritten
def name.put.ata names file written, said first when it held another hash
def name.put
def names.layevery names file a fetch writes, ahead of what follows
def names.outcomehow the names end the fetch: the first that refuses, or `o`, how the packages ended it, which comes first
def outcome.thenthe packages' end, or, when they succeed, the names'
def names.asksthe names still to read under BEND_LIB
def name.parts.ofevery name the lock records, and where each stands
type Verdictwhat one package comes to: nothing to do, a tree to lay, or a refusal
def judge.gotthe files that arrived, laid when they pass
def judgewhat one package comes to, where it stands
def judgedwhat every package comes to
def laya tree laid under BEND_LIB: the files the lock names, then their manifest, so a tree that has one is a tree that finished
def effect.vone verdict's effect, ahead of the rest
def effects.ofevery verdict's effect
def outcome.ofhow the command ends: the first refusal, or success
def seala plan that refuses has no effect at all; its reason is how it ends
def parts.planthe plan once every package and every name stands somewhere: the names files, then the trees, and how the command ends.
def parts.ofevery package of the lock on a World that has one, and where each stands
def need.nowhy a fetch refuses before anything is asked: no ez.toml, or no lock
def need.lock
def plan.lockthe plan once the ledger and the lock are known to be there
def plan.ledthe plan: a missing ledger, then a missing lock, refused before the rest
def plan`ez fetch` over a World
def refuses.planwhether a plan ends in a refusal
def refuseswhether `ez fetch` refuses on a World
def ask.ptone package's open question, ahead of the rest
def asks.ofevery open question
def wants.lockthe open questions once the ledger and the lock are known to be there
def wants.led
def wantsthe questions a World still leaves open: none when the fetch refuses before it asks, and otherwise one for each package that does not yet stand anywhere
type Stepthe questions still open, or the plan once there are none
def step.asks
def step.lock
def step.led
def stepwhat the interpreter does next on a World.
def effectsthe effects of a plan
def frontevery file of a tree but the last, which a `Lay` writes as the manifest
def lockedthe files the lock records under a hash
def lays.onewhether an effect that lays a tree lays the files the lock records under its hash, each with a text whose digest is the lock's sum for it
def lays.lockedwhether every tree a list of effects lays is the one the lock records
def clone.urlthe source a checkout is asked of, "" for any other question
def ask.hashthe package a question is about
def ask.anchoredwhether a git question asks for the source the lock records for its package, taken from the project: the lock's url anchored at `here`
def asks.anchoredwhether every question does
def weighed.laywhether an effect that lays a tree lays a package whose checkout, when it has one, weighed to the narHash the lock records
def lays.weighedwhether every tree a list of effects lays does

src/fetch/run.bend

def laid.seena tree's manifest, when there is one: the tree as it names it, and otherwise a miss
def laidthe tree under BEND_LIB for a hash, as its manifest names it, or a miss when there is none
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 ata file of the project, read
def fillBEND_LIB `lib` filled from the lock of the project in `here`, which is where every relative path in the lock is read from.
def run`ez fetch`: BEND_LIB filled from the lock of the project ez runs in

src/fetch/world.bend

type Aska question about one package of the lock, or one name it records