bolt
Search uses release 1.27.0.0 · 1,644 definitions
Definitions (1,644)
- def check.note_phaseinside the list the token is part of a parameter; outside it is not
- def check.note_argsa token that belongs to a parameter notes where that parameter sits
- def check.drop_toka token the parameter list itself consumed
- def check.maybe_notenote the token when it is part of a parameter
- def check.step_hitone significant token
- def check.step_skipa space, a newline or a comment changes nothing
- def check.step_ona significant token is read; a space, a newline or a comment is not
- def check.stepone token of the header
- def check.sealthe parameter still open at the end of the header
- def check.glue_ofa name glues a following `<`
- def check.walkevery token of the header
- def check.sharesanother parameter already sits on this line
- def check.badsplit across lines, sitting on the `(` line, or sharing its line
- def check.judgethe first parameter that is not alone on its own line
- def check.jam_spanthe first parameter that breaks the shape, in source order
- def check.tightthe last parameter (the head: spans are reversed) runs onto the `)` line
- def check.shut_atthe `)`, when it shares the last parameter's line
- def check.shut_spanthe `)` of a list that did close, when it is not on a line after the last parameter
- def check.loose_spanthe `)` with no `->` right after it on its line
- def check.none_atthe `(` line, when the list holds no parameter
- def check.empty_spana parameter list that opened and holds no parameter
- def check.place_loosethe return type off the `)` line, as a finding
- def check.place_shutthe `)` on the last parameter's line, as a finding, else the return type off the `)` line
- def check.place_emptyan empty parameter list across lines, as a finding, else a misplaced `)`
- def check.placethe parameter that breaks the shape, else an empty list, a misplaced `)` or a return type off its line, as a finding on the header's lines
- def check.jama multi-line header that is not one parameter per line, holds no parameter, or whose `)` shares the last parameter's line or has no `->` after it
- def check.widea one-line header past 120
- def check.headera broken header is judged by its shape; a one-line header by its width
- def check.lexeda def header's tokens, judged
- def check.onea def header; anything else is not this rule's
- def check.goevery def header of the file
- def checkthe rule
- def lone.namea leaf that is a lowercase name: its token.
- def lonea chain that is exactly one lowercase name: its token
- def appendedthe list a call appends onto: List.append's first list, String.append's first
- def onto.calla leaf, then a group: the call's append
- def onto.nexta first cell, then the second: a name then `++`, or a call
- def ontothe name an argument appends onto, `p ++ ..` or an append call, inside any number of parentheses
- type Leta let of one plain name in scope: the name, and what its right side appends onto
- def findwhat the nearest let of the name appends onto; nothing when no let binds it
- def via.ofwhat the let of a lone name appends onto
- def viathe name an argument appends onto, when it is a lone name read from a let
- def eitherthe first maybe when it holds a token, else the second
- def seenthe name an argument appends onto, in place or through a let
- def bound.eqan `=`
- def bound.ofa name, then `=`, then the right side: the let
- def bound.nameda plain name, then `=`, then the right side: the let
- def bound.plus`+`, then a plain name, `=` and the right side: the let
- def boundthe let a statement's own tokens make, when it binds one plain name with `=`, bare or `+`
- def pushthe lets in scope after one more, when there is one
- def hita finding when the name is the parameter of the argument's own slot
- def hitsthe findings on a self-call's arguments, each against the parameter in its position (params, from the argument's own slot on)
- def afterthe lets a statement leaves in scope for the statements after it
- def walkevery self-call's arguments, with the lets in scope
- def check.go
- def checkthe rule
- def plusdoes a parameter's chain open with `+`?
- def useshow many times a plain name is read under the node
- def keep.againpast the first read: a second one drops a `+` parameter
- def keepmay an append onto the parameter be reported?
- def accs.go
- def accsthe parameters an append onto may be reported
- def conts.go
- def contsthe function-typed parameters, `rest: File -> List<&2, U32> -> IO(..)`: the continuations a call may pass an accumulator through
- def hit.conta finding when the name is one of the reportable parameters
- def hits.contthe findings on a continuation call's arguments
- def cwalkevery continuation call's arguments, with the lets in scope
- def cont.go
- def contthe rule's other half: appends passed on through a continuation
- def calledevery name a node calls, `f(..)`, at any depth
- def any_ofdoes the list hold a name the set has?
- def loops.go
- def loopsthe defs of the file that loop: one that calls itself, or that reaches one that does (a def is defined above its use and there is no mutual recursion, so one pass down the file settles it)
- def work.hotthe hot a leaf leaves behind: a `=>` clears it for the lambda's body; a comma of a pick's own group moves to its next argument, hot from the third on (0 the type, 1 the condition, 2 and 3 the branches), and a comma of any other group returns it to keep; any other leaf leaves it as it was
- def work.segthe argument a leaf leaves behind: a comma of a pick's own group moves on
- def work.namecan the leaf name a call (it is neither a `=>` nor a comma)?
- def workthe work under a def's body: hot says the node sits in a branch argument of a `Bool.pick` (so it runs whatever the condition), seg counts the arguments of the pick whose group this chain is (0 the type, 1 the condition, 2 and 3 the branches; 9 for a chain that is not a pick's), and keep is what hot returns to at the next comma of a chain that is not a pick's, so a `=>` clears hot for the lambda's own body and not for the arguments after it.
- def check.go
- def checkthe rule
- type Formwhich length a test takes: a list's, a String's, or neither
- type Lastwhat the last tokens of a List.length's arguments were: a comma, a plain name right after a comma, or anything else
- type Takenthe name a test takes the length of, and the tokens after its `)`
- type Hitwhere a finding goes and what it says
- def openera bracket that opens a group, or a comma inside one: what may stand right before a test
- def codea token's text where it is code: a string literal or a comment says nothing the rule reads
- def dotteda dotted name
- def plaina plain name
- def formthe length a dotted name takes
- def headan opener, `Nat.is_eq`, `(`, a dotted name and `(`?
- def last.stepwhat a token leaves of the last tokens: a comma, a name after a comma, or anything else
- def last.namethe name a List.length's arguments end in, when the last two were a comma and a plain name
- def close.deptha bracket at the depth: the length's own `)` at depth zero; else the depth it leaves
- def close.hereis the token the bracket that closes the arguments, at depth zero?
- def close.lista List.length's arguments, scanned to the `)` that closes them: the name they end in and the tokens after that `)`; none when they end otherwise or run out.
- def close.stra String.length's argument: a plain name and `)`, then the tokens after
- def takenthe length's argument, by its form
- def samea plain name with x's text?
- def keptis x read among the tokens before the bracket that closes the group they sit in?
- def saywhat a finding says: the test, its fix and why
- def tail.goa finding, if the test is whole and x kept