Syntax Summary

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-list:
	nil-or-D
	nil-or-D-list, nil-or-D

nil-or-D:
	identifier
	nil

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

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-list };

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 (expression) statement
	labelopt do statement while (expression) ;
	labelopt for (expression; expression; expression) 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

monadic-expression:
	term
	monadic-operator monadic-expression
	array [expression] of data-type
	array [expression] 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:
	expression <- = expression

declare-expression:
	lvalue-expression := expression

load-expression:
	load identifier expression