Notes about Limbo

POWERMAN

"In each of us sleeps a genius...
and his sleep gets deeper everyday."

Home

Operators

Limbo operators have the following associativity and precedence, listed from highest precedence to lowest.

left            .
left            ->
left            () [] ++ --

nonassoc        ! ~ len hd tl tagof
nonassoc        big byte int real string fixed(0.0,0.0)
nonassoc        + - * ref       (unary)

right           <-
right           **
left            * / %
left            + -
left            << >>
left            < > <= >=
left            == !=
left            &
left            ^
left            |
right           ::
left            &&
left            ||
left            load
right           = := &= |= ^= <<= >>= += -= *= /= %= **=

Syntax summary (Updated Dec 2012)

This syntax was defined using current limbo source (/appl/cmd/limbo/limbo.y) to be used as reference instead of outdated syntax summary in “The Limbo Programming Language”.

Actual syntax allowed in limbo programs is slightly more restrictive than described here because limbo do extra syntax checks after parsing source (not every kind of type or expression allowed where you see type or expression below, for example only kind of expressions supported by spawn is function call).

Comments

Comments are everything from # to the end of line. Using comments in this format you can set current location (used for reporting warnings/errors):

#line 123 "/path/file.b"

Identifiers and constants

identifier:: [a-zA-Z_][a-zA-Z_0-9]*
string-constant:: `[^`]*`
"([^"\\\n]|\\[\\'"abtnvfr0]|\\u[0-9a-fA-F]{4})*"
constant:: '([^\\\n']|\\[\\'"abtnvfr0]|\\u[0-9a-fA-F]{4})'
[0-9]+(r[0-9A-Za-z]+)?
([0-9]+(\.[0-9]*)?|\.[0-9]+)([eE][+-]?[0-9]+)?
identifier-list:: identifier
identifier-list , identifier
nil-or-identifier:: identifier
nil
nil-or-identifier-list:: nil-or-identifier
nil-or-identifier-list , nil-or-identifier
tuple-or-nil-or-identifier:: nil-or-identifier
( tuple-or-nil-or-identifier-list )
tuple-or-nil-or-identifier-list:: tuple-or-nil-or-identifier
tuple-or-nil-or-identifier-list , tuple-or-nil-or-identifier

Program

program:: implement identifier-list ; top-declaration-sequence
top-declaration-sequence:: top-declaration
top-declaration-sequence top-declaration
top-declaration:: declaration
tuple-or-nil-or-identifier = expression ;
tuple-or-nil-or-identifier := expression ;
module-declaration
adt-declaration
function-definition
declaration:: include string-constant ;
identifier-list : import identifier ;
identifier-list : type type ;
identifier-list : con expression ;
identifier-list : exception tuple-type_opt ;
identifier-list : type ;
identifier-list : type = expression ;

Types

basic-type:: byte
int
big
real
string
fixed-type:: fixed ( expression , expression )
fixed ( expression )
type:: basic-type
fixed-type
ref type
chan of type
array of type
list of type
tuple-type
identifier poly-type_opt
type . identifier poly-type_opt
type -> identifier poly-type_opt
fn poly-arg_opt function-arg-ret poly-for_opt raises_opt
type-list:: cyclic_opt type
type-list , cyclic_opt type
tuple-type:: ( type-list )
poly-type:: [ type-list ]

Expressions

assignment-operator: one of: = &= |= ^= <<= >>= += -= *= /= %= **=
binary-operator: one of: ** * / % + - << >> < > <= >= == != & ^ | :: && ||
monadic-operator: one of: + - ! ~ ref * ++ -- <- hd tl len tagof
expression-list:: expression
expression-list , expression
expression:: monadic-expression
expression := expression
expression <- = expression
expression assignment-operator expression
expression binary-operator expression
load identifier expression
monadic-expression:: term
monadic-operator monadic-expression
array [ expression ] of type
array [ expression_opt ] of { array-init-element-list ,_opt }
list of { expression-list ,_opt }
chan of type
chan [ expression ] of type
array of basic-type monadic-expression
basic-type monadic-expression
fixed-type monadic-expression
identifier monadic-expression
term:: nil-or-identifier
term ( expression-list_opt )
( expression-list )
term . identifier
term -> term
term [ expression-or-type-list ]
term [ expression_opt : expression_opt ]
term ++
term --
string-constant
constant
expression-or-type-list:: expression-or-type
expression-or-type-list , expression-or-type
expression-or-type:: expression
type-expression
type-expression:: basic-type
array of type
list of type
cyclic type

Module, ADT

module-declaration:: identifier-list : module { module-member-sequence_opt } ;
module-member-sequence:: module-member
module-member-sequence module-member
module-member:: identifier-list : type ;
identifier-list : type type ;
identifier-list : con expression ;
identifier-list : exception tuple-type_opt ;
adt-declaration
adt-declaration:: identifier-list : adt poly-arg_opt { adt-member-sequence_opt } poly-for_opt ;
identifier-list : adt poly-arg_opt poly-for { adt-member-sequence_opt } ;
adt-member-sequence:: adt-member
adt-member-sequence adt-member
adt-member:: identifier-list : cyclic_opt type ;
identifier-list : con expression ;
pick { pick-member-sequence }
field-sequence:: identifier-list : cyclic_opt type ;
field-sequence identifier-list : cyclic_opt type ;
pick-member-sequence:: pick-tag-list => field-sequence_opt
pick-member-sequence pick-tag-list => field-sequence_opt
pick-tag-list:: identifier
pick-tag-list or identifier
poly-arg:: [ identifier-list ]
poly-for:: for { poly-member-sequence }
poly-member-sequence:: identifier-list => field-sequence_opt
poly-member-sequence identifier-list => field-sequence_opt

Function

function-definition:: function-name-part function-arg-ret poly-for_opt raises_opt { statements_opt }
function-name-part:: identifier poly-arg_opt
function-name-part . identifier poly-arg_opt
function-arg-ret:: ( function-varg-list_opt )
( function-varg-list_opt ) : type
function-varg-list:: function-arg-list
function-arg-list ,
function-arg-list:: function-arg
function-arg-list , function-arg
function-arg:: nil-or-identifier-list : type
nil-or-identifier-list : self ref_opt identifier poly-type_opt
nil-or-identifier-list : self ref_opt type . identifier poly-type_opt
raises:: raises tuple-or-nil-or-identifier

Statements

statements:: declaration
statement
statements declaration
statements statement
statement:: expression_opt ;
{ statements_opt }
{ statements_opt } exception identifier_opt { qual-statement-sequence }
if ( expression ) statement
if ( expression ) statement else statement
label_opt for ( expression_opt ; expression_opt ; expression_opt ) statement
label_opt while ( expression_opt ) statement
label_opt do statement while ( expression_opt ) ;
label_opt case expression { qual-statement-sequence }
label_opt alt { qual-statement-sequence }
label_opt pick identifier := expression { pqual-statement-sequence }
break identifier_opt ;
continue identifier_opt ;
return expression_opt ;
spawn expression ;
raise expression_opt ;
exit ;
label:: identifier :
qual-list:: qualifier
qual-list or qualifier
qualifier:: expression
expression to expression
*
pqual-list:: pqualifier
pqual-list or pqualifier
pqualifier:: identifier
*
qual-statement-sequence:: qual-list => statements_opt
qual-statement-sequence qual-list => statements_opt
pqual-statement-sequence:: pqual-list => statements_opt
pqual-statement-sequence pqual-list => statements_opt
array-init-element-list:: array-init-element
array-init-element-list , array-init-element
array-init-element:: expression
expression => expression
qual-list => expression