bolt

Search uses release 1.27.0.0 · 1,644 definitions

Releases (13)

1.27.0.0 indexed
1.26.0.0 unindexed
1.25.0.0 unindexed
1.24.0.0 unindexed
1.23.0.0 unindexed
1.22.0.0 unindexed
1.21.0.0 unindexed
1.20.0.0 unindexed
1.19.0.0 unindexed
1.18.0.0 unindexed
1.17.0.0 unindexed
1.12.0.0 invalid
expected a fresh constructor name (duplicate declaration: Ready)

at src/lsp/frame.bend:295
10 files do not load
1.11.0.0 invalid
expected a fresh constructor name (duplicate declaration: Ready)

at src/lsp/frame.bend:295
10 files do not load

Definitions (1,644)

src/rules/laws/law.bend

def keysthe keys of what the mentions name
def ctor_nodesa type's constructors, each a node that leads nowhere, onto the others
def nodesthe items of a file as nodes onto the others: a def leads to what it calls, a type and its constructors to nothing
def graph.itemsthe items of every file as nodes
def graphthe graph: the empty key first, leading to what the laws name, then the items
def any_itema type's constructors: is one of them reached?
def law_dirsthe directories that state laws
def gapsa def, or a type, that no law reaches
def check.goevery file not exempt, against what the laws reach
def reachedwhat the laws reach: the walk from the empty key over the graph, built once
def check.firsta project states no laws: nothing of it is under law, and the graph is never built (a project with no LAWS.bend pays nothing)
def checkthe rule, over every file the linter read

src/rules/pedantic/foreign.bend

type Laneswhich lanes a foreign def's bodies cover
def targetthe imported path of an import statement's tokens (`"./x.c"`, quoted)
def lanes.gothe lanes of a body that is only imports; None when it is anything else
def lanesthe lanes of a def's body: None unless it is a foreign def
def lackwhat the lanes lack, as a message ("" for nothing)
def ata message as a finding, when there is one
def name.ofa def's name, `?` when it has none
def check.go
def native_only.go
def native_onlyis the file headed `# lanes: native`: that exact line among the comment lines before its first line that is not a comment?
def checkthe rule

src/rules/pedantic/fuel.bend

type Fuela def of the file and the position of a fuel parameter
def is_fuelis it a fuel parameter's name?
def fuels.paramsthe fuel parameters among a def's parameters, from position i on
def effect.iois the chain's first node the capitalized name `IO`?
def underthe kids of the first statement under a def: the line a header wrapped after its `->` continues on (`->` then `IO(Unit):` on the next line)
def effect.nextwhat follows an arrow: the rest of the header, or the line under it (below) when the arrow ends the header; is it `IO`?
def effectdoes a def's header return an effect: a top-level `->` with the capitalized name `IO` right after it, on the next line (below) when the arrow ends the header?
def slotsthe parameters a def's fuel may sit in: none when it returns an effect
def fuelsevery fuel parameter of every def of the file that returns no effect
def convertedthe group of a call at line ll, column cc, as a finding when it holds one U32 literal alone (digits) and ok says the call is `U32.to_nat(`
def literalan argument that is a Nat literal alone (digits, then `n`), or `U32.to_nat` of a U32 literal alone, as a finding
def calla call to name with these arguments, against every fuel parameter
def callsevery call at any depth of a chain, but the def's own (self)
def owna def's (or a law's) name, "" when it has none
def check.goeach top-level statement, walked as its own def
def checkthe rule

src/rules/pedantic/index.bend

def literalis the chain exactly one number?
def helda fixed table (src/rules/table.bend) is left alone
def namedis the call named get, and not the def's own (self)?
def walkevery List.get / String.get call at a computed index, but self's own
def check.go
def checkthe rule

src/rules/pedantic/rewalk.bend

type Howhow the result of a call is used
type Siteone expensive call
type Hita narrow read and a wide read of one name
type Slotwhere an accessor reads its collection
type Posa position a mark pass recorded
type Lhsthe left of `=` : one name, and whether a group makes it a field
type Binda let of one name, and where it takes effect
type Notea let whose right-hand side is one call
def none_hitneither read
def eithereither read from two results
def name_slota mention of the name: wide, unless this position is a narrow slot
def name_hita mention of the name, or nothing when it is a different name
def slot_pickwhich argument a narrow accessor reads
def slot_ofList.get / head / last / length, String.get / length, Array.get; not List.set
def step_is_zeroafter a comma, still inside the slot argument?
def step_hot_liveafter a comma, is the next argument the slot?
def step_hotthe slot flag after a comma
def step_left_livethe arguments still to skip after a comma
def step_leftthe arguments still to skip after a comma
def as_openthe chain is exactly one call
def as_insidethe inside of one pair of parentheses, when it is exactly a call
def as_wrappeda parenthesized call, or nothing
def as_callthe chain is exactly one call, or one pair of parentheses around one: its callee
def pos_ofthe callee, when this argument is exactly a call
def mark_slotthe collection argument's call, when this is a narrow accessor
def markcalls that sit in a narrow accessor's collection argument
def here_callthe name before a group is a narrow read, a callee, or an ordinary mention
def here_hitthe name before a group is a narrow read, a callee, or an ordinary mention
def inner_hot_calla bracket's inside is cold; a call's arguments start before the slot
def inner_hota bracket's inside is cold; a call's arguments start before the slot
def slot_atthe argument index a slot reads
def inner_left_callthe slot index of a call; a bracket has none
def inner_leftthe slot index of a call; a bracket has none
def slot_onwhether an accessor has a collection argument
def inner_live_callonly a call's arguments count commas as separators
def inner_liveonly a call's arguments count commas as separators
def has_eqdoes the chain bind?
def hit_keepa read counts only once the left of `=` is over
def pick_hotinside a call, unless this chain is still the left of a let
def pick_leftinside a call, unless this chain is still the left of a let
def pick_liveinside a call, unless this chain is still the left of a let
def hitsreads of the name.
def narrow_leta let of one name is narrow when that name is only read narrowly
def narrowa slot or a field is narrow; a wide use is not; a let depends on the name's reads
def calledevery name a node calls
def any_ofdoes the list hold a name the set has?
def loops.go
def loopsdefs of this file that loop
def heavyBase walks a rewalk cares about
def expensivea loop of this file, or a Base walk, and not this def itself
def indexedthe rest of the chain indexes the call
def how_ofa slot when the call is indexed, otherwise wide, when the call is expensive
def site_howa slot when the call is indexed, otherwise wide, when the call is expensive
def site_listthe call as a site, when it is one
def open_siteone site when this application is an expensive call