bolt

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 unindexed
• 1.11.0.0 unindexed

Definitions (1,644)

src/syntax/outline.bend

• def classify.hold.openthe first character, then the rest of the line
• def classify.holdthe class, and the line when the class does not already carry it
• def name.stop`(`, `<`, `:`, `{` or a space ends a name
• def name.pusha delimiter is not part of the name
• def name.gothe name, reversed into acc, up to a delimiter
• def namethe name that starts a header: up to `(`, `<`, `:`, `{` or a space
• def lstrip.go
• def lstripleading spaces dropped
• def nonemptynot ""?
• def wordsthe words of a line
• def undoca comment line without its `# `
• def undoc.all
• def doc_textthe comment block (reversed) as text
• def sig_textthe pending header lines (reversed) as one text
• def addan item, when there is one, onto the items
• def import_item.of`import <path> as <Alias>` is named by its alias; `import Base` by its path
• def import_iteman `import` line as an item: `import Base`, or `import <path> as <Alias>`
• def def_namethe name of a `def` or `@unsafe def` line
• def starts_upper.of
• def starts_upperdoes the text start with a capital?
• def ctor.ofan indented line of a type block: `Ctor{..}`
• def ctoran indented line of a type block as a constructor item, when it is one
• def is_defa def?
• def flushwhat was pending becomes an item
• def ends_colon.isa `:` token?
• def ends_colon.gothe tokens walked so far ended in `:`; a space or a comment keeps that
• def ends_colonthe line's last token that is not a space or a comment is `:`, so a header ends at its `:` though a comment follows it (`def f() -> U32: # note`)
• def pend_more.closeda def continuation that does or does not end in `:`
• def pend_more.defone more line of a def header
• def pend_moreone more line of a pending header; a def's ends at the line that ends in `:`
• def indentan indented line: more of a pending header, a constructor of an open type, or nothing
• def straya column-0 line that starts nothing: `) -> T:` closing a def's header that broke across lines; anywhere else it is junk, and ends what was pending
• def start_def.ona finished def, or a header that is still open
• def start_defa `def` line: an item at once when it ends in `:`, else a pending header
• def doc_abovea comment continues the block above it only at the top level
• def step.lawa law header, pending the block under it
• def step.tya type header, and the block that follows it
• def step.go
• def step.usethe class and the line, applied to the outline
• def step.text.goa line inside a string: more of a pending header, else nothing
• def step.texta line inside a string, applied to the outline
• def step.codea line of code, by its class
• def stepone line, by its class, or as text when within says it starts inside a string
• def breaksone flag per line break in a text, onto acc (reversed), each str: whether the text is a string's
• def inside.go
• def insideone flag per line, in order: does it start inside a string?
• def inside.hitdoes the line start inside a string?
• def inside.restthe flags of the lines after this one
• def runevery line, in order; ins flags the lines ahead that start inside a string
• def finishthe items once the lines are over, a pending header flushed
• def of_tokensthe top-level items of a source whose tokens are already lexed, in order
• def itemsthe top-level items of a source, in order
• def is_importan import?
• def findthe item of that name; imports are not names of the module
• def import_paththe path behind an import alias
• def hasis the name among these?
• def starting.go
• def startingthe named items whose name starts with prefix, each renamed qual ++ name (the text to insert).
• def aliasesthe import aliases that start with prefix (`import Base` has none)

src/syntax/tree.bend

• type StmtKindwhat a statement is, by its shape: SDef `def f(..)` (also `@unsafe def`), SType, SLaw, SImport, SCase `case p:`, SFor `for x: T` / `exs x: T`, SLet (a `=` or `<-` among its own tokens), else STerm (`match x:`, `do M<T>:`, `return e`, a call, and a dependent arrow `@x: A -> B` or `@+x: A -> B`, which an `@` does not make a def)
• type Nodea leaf holds one token; a group its bracket, what is inside, and its close (None when it never closed); a statement its own tokens and the statements under it; NNil and NCons chain nodes
• def reversea chain, reversed onto acc
• def firstthe token a leaf holds; a group's open, a statement's first token
• def line.of
• def linethe line of a node's first token (0 for none)
• def col.of
• def colthe column of a node's first token (0 for none)
• def opensis it a group opened by this bracket?
• def leaf_closethe leaves of a tree, in order: the significant tokens
• def leaves.go
• def leavesthe leaves of a tree, in order: the significant tokens when the tree is faithful
• type Framean open group (its kids reversed), or an open statement (its kids and the finished statements under it, both reversed); the root holds the items
• type Bfresh: the next significant token starts a line
• def closerthe bracket that closes an opener (`>` for `<` and `<&`)
• def all_gtis every char a `>`?
• def closes_witha token that closes a group: `)`, `]`, `}` or a run of `>`
• def opens_angle`<` or `<&` right after a name opens type arguments
• def puta finished node lands in the frame below
• def close_onethe innermost open group, closed by close (None: never closed)
• def depth_to.upone more group above the one found below, when one was
• def depth_tohow many groups sit open above the one that c closes (counting it); 0 when none does.
• def groupshow many groups sit open on top of the stack
• def close_nn groups close, innermost first; only the last gets the close token
• def close_allevery open group closes, unclosed
• def close_toka close bracket: to its match if it has one, else a stray leaf
• def close_gts`>>` closes two angle groups
• def close_any.atthe close a bracket makes, given whether it is a run of `>`: a match, so only the side taken runs
• def close_anya close bracket, or a run of `>`, closes what it can
• def put_stmta finished statement lands in the body of the frame below
• def binds_ina `=` or `<-` among a statement's own tokens
• def keyword_kindthe kind of a statement led by this keyword
• def arrow.nameddoes the chain after an `@` start with a binder's name and a `:`?
• def arrowdoes the chain after an `@` bind a name, `@x:` or with a quantity mark `@+x:`, as a dependent arrow does, rather than name an attribute (`@unsafe`)?
• def classifya statement's kind from its own tokens
• def end_stmtthe innermost open statement is finished and lands in its parent
• def end_nn statements finish, innermost first
• def deeperthe statements a line at column col ends: those not shallower than it
• def stmtshow many statements sit open on the stack
• def in_groupis the innermost frame an open group?
• def open_stmta new statement at column c, once the ones it ends are finished; inside a group a line is just more tokens