bend-lint-api

Search uses release 0.2.0.0 · 174 definitions

Releases (3)

def Here.text
def Here.nodesThe file's nodes: its imports, then its declarations.
def Here.sourcesEvery file of the check, hub packages too.
def Here.declarations
def Here.optionThe config's value, or the default.
def Whole.declarations
def Whole.sources
def Whole.option
type QuestionShow spells a type as its file does; Same compares as the checker does.
type Answer
type StepA run so far: finished, or waiting for the answers to its questions, in order.
def AskA computation that may ask the checker, in `do Lint.Ask<A>:` blocks.
def Ask.pure
def Ask.bind
def ask.step
def askThe answers to `questions`, in order, asked in one round; none asked, no round.
def done
def Answer.text
def Answer.same
def Answer.type`t` with the handle of its normal form, if the answers give one.
def show
def same
def normal
def Question.shows
def Answer.texts
def show_allHow each type of `types` is shown, in order, asked in one round.
type NeedsWhat a rule needs collected for it, as each costs time and memory: the checker's facts, and the declarations with their uses.
type RunHow a rule runs: once per linted file, reporting only in it; or once per check, on the whole program, reporting in any file (what it finds in a file that is not linted is dropped).
type RuleA rule: what it needs, the options it declares, and how it runs.

def when
def onto`xs`, last first, onto `out`.
def append
def concat.go
def concat
def length.go
def length
def any.go
def anyWhether `f` holds for some `x` of `xs`; it stops at the first.
def push
def sort.runs
def sort.passOne pass: each two runs merged, in order.
def sort.goPasses until one run is left; each pass halves the runs, so `fuel` (the length) is more than enough.
def sort`xs` in `le` order, stable: a bottom-up merge sort.
def deal.go
def deal`xs` dealt into two halves, each in order: those at even positions, and those at odd ones.

type NamedA value, with the name it is written as.
def lookup.go
def tableEach of `xs` with the name `show` gives it: a table for `lookup`, so that each name is written once, in `show`.
def lookupThe value `key` names in `table`: the first, read no further.
def findThe value `key` names in `table`, a map by name (as `Lint.definitions` makes): one pass over the name, however many names there are.
def Group.add.ofGroups ====== Values by name, in a map: each name's values, last first.
def Group.add`groups` with `x` added under `key`.
def Group.getWhat is added under `key`, in the order added.
def Group.of

def take.go
def takeThe first `n` characters of `s`.
def sliceThe text of `text` from `beg` to `end`, in code points.
def line_start.go
def line_startWhere the line of `text` that holds the offset `at` starts: after the last newline before it.
def line_end.go
def line_endWhere the line of `text` that starts at `beg` ends: after its newline, or at the end of the text.
def starts_with
def before.go
def beforeWhat comes before the first `sep` of `s`, or "" if there is none.
def after_last.go
def after_lastWhat comes after the last `sep` of `s`, or all of `s` if there is none.
def ontoThe chunks of `chunks` (last first) as one text, before `out`.

type TableValues by number, from 0: a balanced tree.
def Table.get.goThe value numbered `i` in `t`: `odd` is whether `i` is.
def Table.get
def Table.set.go`t` with `x` numbered `i`: `odd` is whether `i` is, and `zero` whether it is 0.
def Table.set