Keywords

Declaration

Keyword	JS Output	Description
const	const	Constant declaration
let	let	Variable declaration
var	var	Var declaration (discouraged)
be	=	Assignment / reassignment (must be preceded by const, let, var, or a property/index target)

Bare variable assignment is not supported (since v0.10.x)

Using be on a bare identifier without a declaration keyword is a compile error. Always declare variables with const, let, or var:

-- ERROR
x be 42

-- OK
const x be 42
let x be 42

-- OK (property / index targets do not need a declaration keyword)
obj.prop be value
arr[\0] be value

Functions

Keyword	JS Output	Description
fn	function	Function declaration/expression
return	return	Return value
to	=> expr	Expression body
to return	{ return expr; }	Explicit return expression body
gives	(erased)	Return type annotation
async	async	Async function
await	await	Await expression
yield	yield	Yield expression (generator)
function	(deprecated)	Deprecated alias for fn

Conditional

Keyword	JS Output	Description
if	if	Conditional
elif	else if	Else-if branch
else	else	Else branch
unless	if (!(...))	Negated conditional
then	(ternary/inline)	Inline conditional

Loops

Keyword	JS Output	Description
while	while	While loop
until	while (!(...))	Negated while loop
for	for	For loop
in	of / in	Iterator
range	(numeric range)	Range-based loop
break	break	Break
continue	continue	Continue
do	do	Do-while loop (deprecated)

Pattern Matching

Keyword	JS Output	Description
switch	if-else chain	Switch expression
case	(switch arm)	Switch case
default	(switch default)	Default arm
match	if-else chain	Match expression (deprecated)
when	(match arm)	Match case (deprecated)

Modules

Keyword	JS Output	Description
import	import	ESM import
from	from	Import source
export	export	ESM export
default	default	Default export
require	require()	CJS require
use	(inline JS)	Standard library import (p- prefix, as optional)
namespace	IIFE	Module namespace
public	export	Public export
all	* as	Namespace import
with	with	Import attributes

Operators

Arithmetic

Keyword	JS Output
add	+
sub	-
mul	*
div	/
mod	%
pow	**
neg	- (unary)

Compound Assignment

Keyword	JS Output
add be	+=
sub be	-=
mul be	*=
div be	/=
mod be	%=
pow be	**=

Comparison

Keyword	JS Output
eq	===
neq / not eq	!==
lt	<
gt	>
le / lt eq	<=
ge / gt eq	>=

Logical

Keyword	JS Output
and	&&
or	||
not	!

Nullish Coalescing

Keyword	JS Output
coal	??

Pipeline

Keyword	JS Output
pipe	b(a)

Type Keywords

Keyword	JS Output	Description
as	(erased)	Type cast
of	(erased)	Type annotation
typeof	typeof	Typeof operator
instanceof	instanceof	Instance check
type	(erased)	Type alias

Other

Keyword	JS Output
new	new
delete	delete
this	this
super	super
throw	throw
try	try
catch	catch
finally	finally
pipe	pipeline operator
list	array literal
object	object literal
nan	NaN
infinity	Infinity (neg infinity / -infinity → -Infinity)

Class

Keyword	JS Output	Description
class	class	Class declaration
extends	extends	Class inheritance
super	super	Parent class reference
static	static	Static method
private	#field	Private field declaration
protected	(deprecated)	Deprecated alias for private
get	get	Getter accessor
set	set	Setter accessor

Punctuation

Symbol	Meaning
[ ]	Brackets (calls, arrays, objects, grouping)
.	Property access
\.	Optional chaining (?.)
\	Computed access prefix (inside [...])
;	Argument / element separator
,	Array / object separator
..	Inclusive range
...	Exclusive range