bolt Releases (12): 1.26.0.0 0x1e8aaaf7f2a60aba7c7bc65699caa820 indexed https://jend.leeeet.dev/files.txt?path=bolt@1.26.0.0 1.25.0.0 0x9783a6a2a487c8baa062899ad235618e unindexed https://jend.leeeet.dev/files.txt?path=bolt@1.25.0.0 1.24.0.0 0x1d907092a452cd105e95df09b21f0aaf unindexed https://jend.leeeet.dev/files.txt?path=bolt@1.24.0.0 1.23.0.0 0x1617abc30c012397a51f2088f60b6621 unindexed https://jend.leeeet.dev/files.txt?path=bolt@1.23.0.0 1.22.0.0 0xf2df9c564649a8f27ab619d885418944 unindexed https://jend.leeeet.dev/files.txt?path=bolt@1.22.0.0 1.21.0.0 0xcb00b2b8895301b86fb365a9ceb6e119 unindexed https://jend.leeeet.dev/files.txt?path=bolt@1.21.0.0 1.20.0.0 0x6da2affe27298531acb4879fbe88e96d unindexed https://jend.leeeet.dev/files.txt?path=bolt@1.20.0.0 1.19.0.0 0xe4f42cd2ab82ae9f041f8a07d4b4eec8 unindexed https://jend.leeeet.dev/files.txt?path=bolt@1.19.0.0 1.18.0.0 0x35f17b35555be5fc1e2ec2480b52b92a unindexed https://jend.leeeet.dev/files.txt?path=bolt@1.18.0.0 1.17.0.0 0x925a781ce1187774553f425315592b66 unindexed https://jend.leeeet.dev/files.txt?path=bolt@1.17.0.0 1.12.0.0 0x582b4b0fdf3dafdeecc8c3bfddc5e4db invalid https://jend.leeeet.dev/files.txt?path=bolt@1.12.0.0 expected a fresh constructor name (duplicate declaration: Ready) At https://jend.leeeet.dev/read.txt?path=bolt@1.12.0.0/src/lsp/frame.bend&start_line=295. Files that do not load: main.bend, src/lint.bend, src/lsp/checker/bend.bend, src/lsp/files/disk.bend, src/lsp/frame.bend and 5 more. 1.11.0.0 0x013e0f9a479bbebad5ed196725eede95 invalid https://jend.leeeet.dev/files.txt?path=bolt@1.11.0.0 expected a fresh constructor name (duplicate declaration: Ready) At https://jend.leeeet.dev/read.txt?path=bolt@1.11.0.0/src/lsp/frame.bend&start_line=295. Files that do not load: main.bend, src/lint.bend, src/lsp/checker/bend.bend, src/lsp/files/disk.bend, src/lsp/frame.bend and 5 more. Definitions (1608, 1 to 100 shown): Bolt.dispatch (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/main.bend&name=dispatch) # what a subcommand runs, over the files after it def dispatch(cmd: Args.Cmd, paths: List<&2, String>) -> IO(Unit): # noqa: L001 IO driver Bolt.perform (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/main.bend&name=perform) # what a parsed line does, done def perform(oo: Args.Out) -> IO(Unit): # noqa: L001 IO driver Bolt.main (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/main.bend&name=main) def main() -> IO(Unit): # noqa: L001 IO entry point Args.widen (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=widen) # the line at the quantity the rest of bolt reads it at (IO.args gives each # argument once) def widen(ss: List<&1, String>) -> List<&2, String>: Args.args_of (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=args_of) # the arguments of IO.args's line: the program as invoked comes first, and is # dropped def args_of(ss: List<&1, String>) -> List<&2, String>: Args.argv (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=argv) # bolt's command line: its arguments, without the program def argv() -> IO(List<&2, String>): # noqa: L001 IO: reads argv Args.is_cmd (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=is_cmd) # whether a word names a subcommand def is_cmd(+ww: String) -> Bool: Args.asks_help (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=asks_help) # whether `--help` stands among the words before the first `--` (after it, # every word is a file); the search stops at either def asks_help(ws: List<&2, String>) -> Bool: Args.help_path (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=help_path) # the command path `--help` asks about: the first word other than `--help`, # when it names a subcommand, else the root's def help_path(ws: List<&2, String>) -> List<&2, String>: Args.line.at (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=line.at) # the line, given whether it asks for `--help` def line.at(ask: Bool, +ws: List<&2, String>) -> List<&2, String>: Args.line (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=line) # the line shake parses: one that asks for `--help` is `help` for its command # path, the page `bolt help` prints; any other is itself def line(+ws: List<&2, String>) -> List<&2, String>: Args.spec.files (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=spec.files) # the files rest, optional, last among positionals def spec.files(+help: String) -> Shake.Arg: Args.version.at (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=version.at) # the release, with the short commit in parentheses when it is present def version.at(+rel: String, +rev: String) -> String: Args.version (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=version) # the release, and the short commit when the build has one def version() -> String: Args.spec (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=spec) # bolt's program spec def spec() -> Shake.Cli: Args.parse (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=parse) # argv against bolt's spec def parse(av: List<&2, String>) -> Result<&2, &2, Shake.ParseErr, Shake.Matched>: Args.help_text (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=help_text) # usage for a command path def help_text(path: List<&2, String>) -> String: Args.err_text (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=err_text) # a parse error as the text the binary prints def err_text(ee: Shake.ParseErr) -> String: Args.Cmd (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=Cmd) # a subcommand type Cmd is Data: CLint{} CCheck{} CLsp{} Args.command (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=command) # a subcommand by its name; the empty name (no subcommand) is `lint` def command(+name: String) -> Cmd: Args.Stream (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=Stream) # where a line that stops puts its text type Stream is Data: Line{} Page{} Err{} Args.Out (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=Out) # what a parsed line does: print a text and exit with a code, or run a # subcommand over files (which then exits as that command decides) type Out is Data: Stop{to: Stream, text: String, code: U32} Go{cmd: Cmd, paths: List<&2, String>} Args.files.at (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=files.at) # the files the selected command bound: each command keeps its own # bindings, so they are read from the Matched at the end of the selected # path, which is the root's own when no subcommand was selected def files.at(sel: Maybe<&2, Shake.Matched>, +mm: Shake.Matched) -> List<&2, String>: Args.files (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=files) # the files a successful parse bound, to the command it selected def files(+mm: Shake.Matched) -> List<&2, String>: Args.out.run (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=out.run) # a successful parse: the version, or the selected command and its files def out.run(ask: Bool, +mm: Shake.Matched) -> Out: Args.out.fail.at (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=out.fail.at) # a failed parse, given whether it asked for usage: that usage page, or the # error def out.fail.at(asked: Maybe<&2, List<&2, String>>, +ee: Shake.ParseErr) -> Out: Args.out.fail (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=out.fail) # a failed parse: help text, or an error def out.fail(+ee: Shake.ParseErr) -> Out: Args.out.done (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=out.done) # a successful parse, read once for the version flag def out.done(+mm: Shake.Matched) -> Out: Args.out (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/args.bend&name=out) # what a parse result does def out(rr: Result<&2, &2, Shake.ParseErr, Shake.Matched>) -> Out: BuildRev.text (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/build_rev.bend&name=text) # the short commit id, or empty def text() -> String: Check.rest_lines (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=rest_lines) # a message's lines after the first, indented def rest_lines(ls: List<&2, String>) -> String: Check.message.of (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=message.of) # a message's lines: the first, then the rest indented def message.of(ls: List<&2, String>) -> String: Check.message (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=message) # a message: its first line, the rest indented def message(msg: String) -> String: Check.show_all (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=show_all) # each diagnostic as a line def show_all(ds: List<&2, Rep.Diag>, +path: String) -> List<&2, String>: Check.Run (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=Run) # a file checked: its path and the diagnostics bend reported for it, or a # file bend could not be run on type Run is Data: Run{path: String, ds: List<&2, Rep.Diag>} Failed{path: String} Check.Out (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=Out) # what a check prints, line by line, and the code it exits with type Out is Data: Out{lines: List<&2, String>, code: U32} Check.lines_of (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=lines_of) # every run's error lines, in order def lines_of(runs: List<&2, Run>) -> List<&2, String>: Check.out.at (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=out.at) # the error lines, then `clean` or the count, and the exit code: 1 when # there is any error def out.at(ls: List<&2, String>, count: Nat) -> Out: Check.out (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=out) # what a check prints and how it exits, from what bend reported for each file def out(runs: List<&2, Run>) -> Out: Check.print_all (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=print_all) # each line printed def print_all(lines: List<&2, String>) -> IO(Unit): # noqa: L001 IO driver Check.run_of (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=run_of) # a file's run, from the checker's answer for it def run_of(path: String, aa: Checker.Answer) -> Run: Check.check_all (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=check_all) # every file checked, in order: what bend reported for each def check_all(~ck: Checker.Checker, paths: List<&2, String>) -> IO(List<&2, Run>): # noqa: L001 IO driver Check.perform (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=perform) # what out decided, done (trusted in src/lint.bend): its lines printed, then its code def perform(oo: Out) -> IO(Unit): # noqa: L001 IO driver Check.run (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/check.bend&name=run) # the checker over the files given, exiting 1 when any of them had an error # (main passes checker/bend.bend's service) def run(~ck: Checker.Checker, paths: List<&2, String>) -> IO(Unit): # noqa: L001 IO driver Codes.Entry (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/codes.bend&name=Entry) # one rule: the slug bolt.bend names, its code, its group type Entry is Data: Entry{slug: String, id: String, grp: String} Codes.table (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/codes.bend&name=table) # every rule, in group order def table() -> List<&2, Entry>: Codes.find.same (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/codes.bend&name=find.same) # this row is the slug def find.same(+row: Entry, +slug: String) -> Bool: Codes.find (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/codes.bend&name=find) # the row for a slug def find(rows: List<&2, Entry>, +slug: String) -> Maybe<&2, Entry>: Codes.code.at (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/codes.bend&name=code.at) # the stable code; the slug itself when it is not a rule def code.at(mm: Maybe<&2, Entry>, +slug: String) -> String: Codes.code (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/codes.bend&name=code) # the stable code; the slug itself when it is not a rule def code(+slug: String) -> String: Codes.group.at (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/codes.bend&name=group.at) # the group; empty when the slug is not a rule def group.at(mm: Maybe<&2, Entry>) -> String: Codes.group (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/codes.bend&name=group) # the group; empty when the slug is not a rule def group(+slug: String) -> String: Codes.source.at (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/codes.bend&name=source.at) # `bolt(group:slug)`; `bolt` when the slug is not a rule def source.at(mm: Maybe<&2, Entry>) -> String: Codes.source (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/codes.bend&name=source) # `bolt(group:slug)`; `bolt` when the slug is not a rule def source(+slug: String) -> String: Config.Level (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=Level) # how much a finding matters type Level is Data: Off{} Warn{} Error{} Config.LevelSet (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=LevelSet) # a name (a group's or a rule's) at a level type LevelSet is Data: LevelSet{name: String, level: Level} Config.Config (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=Config) # the settings, in file order type Config is Data: Config{sets: List<&2, LevelSet>} Config.none (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=none) # no file: the defaults def none() -> Config: Config.show (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=show) # the word for a level, as a finding is shown def show(ll: Level) -> String: Config.is_error (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=is_error) # is it an error? def is_error(ll: Level) -> Bool: Config.is_off (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=is_off) # is it off? def is_off(ll: Level) -> Bool: Config.of_word (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=of_word) # a level by its word; an unknown word is an error, so a typo shows def of_word(+ww: String) -> Level: Config.unquote (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=unquote) # a string literal's text, its quotes dropped def unquote(+tt: String) -> String: Config.first_str (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=first_str) # the first string among the tokens def first_str(toks: List<&2, Lex.Tok>) -> Maybe<&2, String>: Config.Setting (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=Setting) # a setting as a bolt.bend writes it: the def's name, the word its body # returns, and the line of its `def` (0-based) type Setting is Data: Setting{name: String, word: String, line: U32} Config.setting (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=setting) # a def's name and the string it returns, at its line, as a setting def setting(name: Maybe<&2, String>, word: Maybe<&2, String>, +line: U32) -> List<&2, Setting>: Config.settings.go (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=settings.go) # every `def x(): "level"` of a tree def settings.go(root: Tree.Node) -> List<&2, Setting>: Config.settings (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=settings) # every setting of a bolt.bend's text, in file order def settings(text: String) -> List<&2, Setting>: Config.levels (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=levels) # each setting as the level it sets its name to def levels(ss: List<&2, Setting>) -> List<&2, LevelSet>: Config.parse (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=parse) # a bolt.bend's text as a config: its settings, each at its level def parse(text: String) -> Config: Config.known.group (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=known.group) # some row of the table has the name as its group def known.group(rows: List<&2, Codes.Entry>, +name: String) -> Bool: Config.known.in (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=known.in) # some row of the table has the name as its slug or its group def known.in(+rows: List<&2, Codes.Entry>, +name: String) -> Bool: Config.unknown.in (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=unknown.in) # the settings, in order, whose name no row of the table has as its slug or # its group def unknown.in(ss: List<&2, Setting>, +rows: List<&2, Codes.Entry>) -> List<&2, Setting>: Config.unknown (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=unknown) # the settings, in order, whose name is neither a rule's slug nor a group of # the code table def unknown(ss: List<&2, Setting>) -> List<&2, Setting>: Config.dir_of.go (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=dir_of.go) # a path's directory, with its slash; `` at the top def dir_of.go(cs: List<&2, Char>, +acc: List<&2, Char>, best: List<&2, Char>) -> String: Config.dir_of (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=dir_of) # a path's directory, with its slash; `` at the top def dir_of(path: String) -> String: Config.absolute (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=absolute) # a path from the root: itself when it starts there, otherwise under the # working directory def absolute(+cwd: String, +path: String) -> String: Config.home.up (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=home.up) # the directories above the innermost one; none above the root def home.up(above: List<&2, String>) -> List<&2, String>: Config.home.step (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=home.step) # a path's segment read onto the directories before it, innermost first: an # empty segment (from `//` or the `/` a directory ends in) and `.` stay where # they are, `..` goes up one (never above the root), and a name goes into it def home.step(+seg: String, +above: List<&2, String>) -> List<&2, String>: Config.home.segs (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=home.segs) # the directories a path names, innermost first: its segments, split at `/`, # each read by `home.step` onto those before it (seg holds the segment being # read, reversed) def home.segs(cs: List<&2, Char>, seg: List<&2, Char>, above: List<&2, String>) -> List<&2, String>: Config.home (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=home) # a directory resolved against the working directory, as the names of the # directories from the root to it, innermost first: `sub/../p3/` under # `/w/p1` is `[p3, w]`, and `` is the working directory itself def home(cwd: String, dir: String) -> List<&2, String>: Config.root (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=root) # directories, innermost first, as a path from the root ending in `/` def root(ds: List<&2, String>, acc: String) -> String: Config.chain (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=chain) # the bolt.bend of a resolved directory (innermost first, as `home` gives it) # and of each parent up to the root, nearest first: `[p3, w]` is # `/w/p3/bolt.bend`, `/w/bolt.bend`, `/bolt.bend` def chain(ds: List<&2, String>) -> List<&2, String>: Config.nearest (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=nearest) # the first file that was there, parsed; none, the defaults def nearest(rs: List<&2, Maybe<&2, String>>) -> Config: Config.set_level.go (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=set_level.go) # the level a name is set to, when it is; hit: the setting before sets # named it, so the search stops there def set_level.go(sets: List<&2, LevelSet>, +name: String, hit: Maybe<&2, Level>) -> Maybe<&2, Level>: Config.set_level (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=set_level) # the level a name is set to, when it is: the first setting that names it def set_level(sets: List<&2, LevelSet>, +name: String) -> Maybe<&2, Level>: Config.default (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=default) # a group's level when nothing sets it def default(+group: String) -> Level: Config.opt_in (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=opt_in) # a rule only its own setting turns on: a group setting, or the group's # default, would put new findings on projects that never asked for it # (`thunk`, `transcong`, and the laws' `coverage` and `closed`, which are a # project's policy rather than defects) def opt_in(+rule: String) -> Bool: Config.level.of (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=level.of) # the rule's own setting, else its group's, else the group's default; an # opt-in rule's own setting, else off def level.of(+sets: List<&2, LevelSet>, +group: String, +rule: String) -> Level: Config.level (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/config.bend&name=level) # the rule's own setting, else its group's, else the group's default def level(cfg: Config, group: String, rule: String) -> Level: Finding.Finding (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/finding.bend&name=Finding) # where (and how far), which rule, what type Finding is Data: Finding{path: String, line: U32, col: U32, len: U32, rule: String, msg: String} Finding.Graded (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/finding.bend&name=Graded) # a finding at the level the project set for its rule type Graded is Data: Graded{level: Config.Level, finding: Finding} Finding.show_graded (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/finding.bend&name=show_graded) # one line, `path:line:col: level: CODE: message` def show_graded(gg: Graded) -> String: Lazy.stop (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/lazy/lazy.bend&name=stop) # `a` when c, else what rest gives: the early exit of a search def stop(-A: Type, cc: Bool, aa: A, rest: Unit -> A) -> A: Lazy.or_else (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/lazy/lazy.bend&name=or_else) # True when a, else what rest gives: `or` that stops at the first True def or_else(aa: Bool, rest: Unit -> Bool) -> Bool: Lazy.and_then (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/lazy/lazy.bend&name=and_then) # what rest gives when a, else False: `and` that stops at the first False def and_then(aa: Bool, rest: Unit -> Bool) -> Bool: Lazy.either (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/lazy/lazy.bend&name=either) # what yes gives when c, else what no gives: a pick whose two branches each # recurse, only the one taken run def either(-A: Type, cc: Bool, yes: Unit -> A, no: Unit -> A) -> A: Lint.read.answer (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/lint.bend&name=read.answer) # a file's text as an answer def read.answer(mm: Maybe<&2, String>) -> W.Answer: Lint.text.answer (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/lint.bend&name=text.answer) # a path's text as an answer: a directory has none, and a file is read def text.answer(dir: Bool, path: String) -> IO(W.Answer): Lint.answer (https://jend.leeeet.dev/definition.txt?path=bolt@1.26.0.0/src/lint.bend&name=answer) # one question, answered def answer(ask: W.Ask) -> IO(W.Answer): # noqa: L001 IO driver More: https://jend.leeeet.dev/packages/bolt.txt?definitions_offset=100