snap

Search uses release 1.4.0.0 · 50 definitions

Releases (4)

def runa program run with its arguments: the exit status on its own first line, then stdout and stderr together.
def execa program run with its arguments; the same as `run`
def starta program started with its arguments and left running; the answer is its pid, or 0 when it could not be started or its argv was refused
def parseveral programs run at once, each answered exactly as `run` answers one, in the order the jobs were given; a job `run` would refuse answers 127 in its place.
def codethe exit status an answer holds: everything before its first newline
def textwhat the program printed, stdout and stderr together: everything after the answer's first newline
def okwhether an answer's status is 0
def cmdthe arguments joined on newlines, the wire ez's `pass` effect reads
def linethe arguments joined on newlines; the same as `cmd`

def code.atone char of the status: a newline ends it, and any other char is part of it, with the rest of the status read only then
def codethe exit status a run answered with: the answer up to its first newline.
def text.atone char before the body: a newline starts the body, which is the rest as it stands, and any other char is still the status
def textwhat the program printed, stdout and stderr together: the answer after its first newline, or nothing when it has none.
def oka run that finished with status 0

def cmdthe arguments joined on newlines, which is the wire ez's `pass` effect reads.
def linethe arguments joined on newlines; the same as `cmd`
def free_ofwhether a string holds no copy of a char
def free_of.allwhether no string of a list holds a copy of a char
def acceptswhether an argv can reach its program whole: it names a program, and no argument holds NUL, which separates them on the wire and which no program could be handed inside an argument anyway
def wirethe arguments as the effects want them: joined on NUL, the one char no argument can hold, so each is split back out whole
type Stepwhat a call does with its argv: refuse it, or hand the effect this wire
def run.plan.ofan argv accepted is run; any other is refused
def run.planwhat `run`, `exec` and `start` do with an argv.
def run.witha step performed by an effect that waits: a refused argv answers as a program that could not be started, and the effect is never called
def start.witha step performed by an effect that does not wait: a refused argv answers as a program that could not be started, and the effect is never called

def snaprun.execthe program and its arguments, NUL separated (`wire`), run with no shell between.
def snaprun.starta program started and left running, answering with its pid, or 0 when it could not be started.
def snaprun.parseveral programs run at once, answering with every exit status in the order the jobs were given.

def file.slurp.endthe handle closed, and whatever was gathered
def file.slurp.cutan empty chunk means the end of the file
def file.slurp.morea failed read ends the file as surely as an empty one
def file.slurp.nextthe handle comes back paired with what it read
def file.slurpthe whole file, read in chunks until one is empty, or the fuel is
def file.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
def file.reads.givena size of 0 is no size to go by; any other is read to
def file.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 file.reads.ofthe reads the size the host reported allows
def file.read.sizeda file read whole, with fuel enough for the size it reported
def file.read.openedwhat an opened file holds, or nothing when it would not open
def file.reada file's text, or None when it cannot be opened
def file.text_ofa file's text, or "" when there is none

def job.fieldsone job's fields on the `par` wire: each argument marked with a `+` in front, then an empty field that ends the job.
def par.job.ofa job accepted as `run` would accept it is sent as it is; any other is sent as the empty job, which the effect answers as a program that could not be started, in its own place
def par.jobthe job `par` sends for an argv
def par.fieldsevery job's fields, in the order the jobs were given
def par.planwhat the `par` effect is handed: how many may run at once, how many gigabytes each was given, where they write, the second they must all be finished by, and then every job's fields, all joined on NUL
def par.nonblankthe strings that are not empty, which is what a list of statuses amounts to once a trailing newline has been counted as a line
def par.ofone job's answer, in the shape `run` gives: the status on its own first line, then everything the program printed, read back out of the file it was pointed at
def par.answersevery job's answer: each status paired with the body at its place in the order, or with none when there is no body there
def par.bodiesthe file each job wrote, one per status, by its place in the order