Syntax overview

BQN syntax consists of expressions where computation is done, with a little organizing structure around them like assignment, functions, and list notation. Expressions are where the programmer is in control, so the design tries to do as much as possible with them before introducing special syntax.

A program is a unit of source code that's evaluated, such as a source file, or one line of REPL input (one run of the bqn executable often involves multiple programs). Like a block, it's a sequence of expressions to be evaluated in order. It has a result, which is used if the program was evaluated from BQN with •BQN, •Import or similar. An error might occur when a program is running; this ends execution unless it's caught.

Precedence

Here's a full table of precedence for BQN's glyphs (broader than "operator precedence", as an "operator" usually just corresponds to a function). Entries at the bottom make the biggest divisions in the program, while the ones further up are subdivisions.

While all of BQN's grammar fits into this table somehow, it's not really the whole story because subexpressions including parentheses and blocks might behave like functions or modifiers. See expressions and blocks.

Special glyphs

The following glyphs are used for BQN syntax. Primitives (built-in functions and modifiers) are not listed in this table, and have their own page. Digits, characters, and the underscore _ are used for numbers and variable names.

Tokens

Full documentation

BQN syntax is made up of tokens, which are mostly single characters. But there are a few exceptions:

• Comments start with # and end at the end of the line.
• Character literals start and end with ', and have exactly one character in between.
• String literals start and end with ". Pairs of quotes "" in between represent one quote character, and other characters (including ') represent themselves.
• Numbers support decimal (.) and scientific (e) notation, plus π and ∞, and use ¯ for a minus sign.
• Variable names allow letters, underscores, and numeric characters. They're matched case-insensitively, with a spelling system that determines role.

Expressions

Full documentation

BQN expressions are composed of subjects, functions, and modifiers, with parentheses to group parts into subexpressions. Functions can be applied to subjects or grouped into trains, while modifiers can be applied to subjects or functions. The most important kinds of application are:

The four roles (subject, function, two kinds of modifier) describe expressions, not values. When an expression is evaluated, the value's type doesn't have to correspond to its role, and can even change from one evaluation to another. An expression's role is determined entirely by its source code, so it's fixed.

Assignment arrows ←, ↩, and ⇐ store expression results in variables: ← and ⇐ create new variables while ↩ modifies existing ones. The general format is Name ← Value, where the two sides have the same role. Additionally, lhs F↩ rhs is a shortened form of lhs ↩ lhs F rhs and lhs F↩ expands to lhs ↩ F lhs.

The double arrow ⇐ is used for functionality relating to namespaces. It has a few purposes: exporting assignment name⇐value, plain export name⇐, and aliasing ⟨alias⇐field⟩←namespace. A block that uses it for export returns a namespace rather than the result of its last statement. The other namespace-related bit of syntax is field access ns.field.

Arrays and blocks

Arrays and code blocks can both be represented as sequences of expressions in source code. There are paired bracket representations, using ⟨⟩ for lists, [] for arrays, and {} for blocks, as well as a shortcut "stranding" notation using ‿ for lists. Elements within brackets are divided by separators: , or ⋄ or a line break.

List and array notation

Full documentation

Lists (1-dimensional arrays) are enclosed in angle brackets ⟨⟩, with the results of the expressions in between being the list's elements. Lists of two elements or more can also be written with the ligature character ‿. This character has higher binding strength than any part of an expression except . for namespace field access. If one of the elements is a compound expression, then it will need to be enclosed in parentheses.

Arrays, or at least non-empty ones with rank 1 or more, can be written with square brackets []. These work just like angle brackets but merge the elements so that they form cells of the result.

Blocks

Full documentation

Blocks are written with curly braces {} and can have a subject, function, or modifier role. The contents are any number of bodies separated by ;. Each body is a sequence of expressions to be evaluated in order, possibly with a header, followed by :, that sets the type and describes expected inputs. A body runs in its own environment according to the rules of lexical scoping. The result is either a namespace, if the body used ⇐, or the result of the last expression.

The special names 𝕨 and 𝕩, which stand for arguments, and 𝕗 and 𝕘, which stand for operands, are available inside curly braces. Like ordinary names, the lowercase forms indicate subjects and the uppercase forms 𝕎𝕏𝔽𝔾 indicate functions. If it has no header, the type and syntactic role of the block is determined by its contents: a 2-modifier contains 𝕘, a 1-modifier contains 𝕗 but not 𝕘, and a function contains neither but does have one of 𝕨𝕩𝕤𝕎𝕏𝕊. The last option is an immediate block, which has a subject role and runs as soon as it's encountered.