This section summarizes the grammar of Limbo above the lexical level; constants and identifiers are left undefined.

program:
	implement identifier ; top-declaration-sequence

top-declaration-sequence:
	top-declaration
	top-declaration-sequence top-declaration

top-declaration:
	declaration
	identifier-list := expression ;
	identifier-list = expression ;
	( identifier-list ) := expression ;
	module-declaration
	function-definition
	adt-declaration

declaration:
	identifier-list : type ;
	identifier-list : type = expression ;
	identifier-list : con expression ;
	identifier-list : import identifier ;
	identifier-list : type type ;
	include string-constant ;

identifier-list:
	identifier
	identifier-list , identifier

expression-list:
	expression
	expression-list , expression

type:
	data-type
	function-type

data-type:
	byte
	int
	big
	real
	string
	tuple-type
	array of data-type
	list of data-type
	chan of data-type
	adt-type
	ref adt-type
	module-type
	module-qualified-type
	type-name

tuple-type:
	( data-type-list )

data-type-list:
	data-type
	data-type-list , data-type

adt-type:
	identifier
	module-qualified-type

module-type:
	identifier

module-qualified-type:
	identifier -> identifier

type-name:
	identifier

function-type:
	fn function-arg-ret

function-arg-ret:
	( formal-arg-listopt )
	( formal-arg-listopt ) : data-type

formal-arg-list:
	formal-arg
	formal-arg-list , formal-arg

formal-arg:
	nil-or-D-list : type
	nil-or-D : self refopt identifier
	nil-or-D : self identifier
	*

nil-or-D-list:
	nil-or-D
	nil-or-D-list , nil-or-D

nil-or-D:
	identifier
	nil

module-declaration:
	identifier : module { mod-member-listopt } ;

mod-member-list:
	mod-member
	mod-member-list mod-member

mod-member:
	identifier-list : function-type ;
	identifier-list : data-type ;
	adt-declaration ;
	identifier-list : con expression ;
	identifier-list : type type ;

adt-declaration:
	identifier : adt { adt-member-listopt } ;

adt-member-list:
	adt-member
	adt-member-list adt-member

adt-member:
	identifier-list : cyclicopt  data-type ;
	identifier-list : function-type ;

function-definition:
	function-name-part function-arg-ret { statements }

function-name-part:
	identifier
	function-name-part . identifier

statements:
	(empty)
	statements declaration
	statements statement

statement:
	expression ;
	;
	{ statements }
	if ( expression ) statement
	if ( expression ) statement else statement
	labelopt  while ( expressionopt ) statement
	labelopt  do statement while ( expressionopt ) ;
	labelopt  for ( expressionopt ; expressionopt ; expressionopt ) statement
	labelopt  case expression { qual-statement-sequence }
	labelopt  alt { qual-statement-sequence }
	break identifieropt ;
	continue identifieropt ;
	return expressionopt ;
	spawn term ( expression-listopt ) ;
	exit ;

label:
	identifier :

qual-statement-sequence:
	qual-list =>
	qual-statement-sequence qual-list =>
	qual-statement-sequence statement
	qual-statement-sequence declaration

qual-list:
	qualifier
	qual-list or qualifier

qualifier:
	expression
	expression to expression
	*

expression:
	binary-expression
	lvalue-expression assignment-operator expression
	( lvalue-expression-list ) = expression
	send-expression
	declare-expression
	load-expression

binary-expression:
	monadic-expression
	binary-expression binary-operator binary-expression

binary-operator: one of
	* / % + - << >> < > <= >= == != & ^ | :: && ||

assignment-operator: one of
	= &= |= ^= <<= >>= += -= *= /= %=

lvalue-expression:
	identifier
	nil
	term [ expression ]
	term [ expression : ]
	term . identifier
	( lvalue-expression-list )
	* monadic-expression

lvalue-expression-list:
	lvalue
	lvalue-expression-list , lvalue

expression:
	term
	monadic-operator monadic-expression
	array [ expression ] of data-type
	array [ expressionopt ] of { init-list }
	list of { expression-list }
	chan of data-type
	data-type monadic-expression

term:
	identifier
	constant
	real-constant
	string-constant
	nil
	( expression-list )
	term . identifier
	term -> term
	term ( expression-listopt )
	term [ expression ]
	term [ expression : expression ]
	term [ expression : ]
	term ++
	term --

monadic-operator: one of
	+ - ! ~ ref * <- hd tl len

init-list:
	element
	init-list , element

element:
	expression
	expression => expression
	* => expression

send-expression:
	lvalue-expression <- = expression

declare-expression:
	lvalue-expression := expression

load-expression:
	load identifier expression