1 of 100

Celerity

Home

This is currently in-development vaporware.

Celerity is a programming language aiming for a good balance of productivity and scalability while being easily embeddable in host applications.

Celerity is expression-oriented, multi-paradigm, and features optional type checking. Some notable features are pattern matching, first-class functions with closures, opt-in mutability, explicit yet terse error propagation, concurrency based on lightweight agents, and non-suspending garbage collection.

Installation

Language

Basic Concepts

Modules and Code Reuse

Types and Values

Optional Type Checking

Mutability and Freezing

Pattern Matching

Error Handling

Agents and Communication

Garbage Collection

Startup and Termination

Lexical Structure

input ::= shebang-line? token*
token ::= blank |
          comment |
          operator |
          punctuator |
          keyword |
          identifier |
          literal

Shebang Line

shebang-line ::= '#!' [^#xa#xd#x85#x2028#x2029]*

Blanks

blank ::= white-space |
          line-break

White Space

white-space ::= [#x9#xb#xc#x20#xa0#x1680#x#x2000-#x2009#x200a#x202f#x205f#x3000]

Line Break

line-break ::= [#xa#xd#x85#x2028#x2029]

Comments

Operators

operator ::= custom-operator |
             special-operator

Custom Operators

custom-operator ::= custom-additive-operator |
                    custom-multiplicative-operator |
                    custom-bitwise-operator |
                    custom-shift-operator
custom-additive-operator ::= [+-~] operator-part*
custom-multiplicative-operator ::= [*/%] operator-part*
custom-bitwise-operator ::= [&|^] operator-part*
custom-shift-operator ::= [><] operator-part*
operator-part ::= [+-~*/%&|^><]

Special Operators

special-operator ::= '=' |
                     '==' |
                     '!=' |
                     '>' |
                     '>=' |
                     '<' |
                     '<='

Punctuators

punctuator ::= '.' |
               '..' |
               ',' |
               ':' |
               '::' |
               ';' |
               '->' |
               '@' |
               '#' |
               '?' |
               '(' |
               ')' |
               '[' |
               ']' |
               '{' |
               '}'

Keywords

keyword ::= regular-keyword |
            type-keyword |
            reserved-keyword

Regular Keywords

regular-keyword ::= 'and' |
                    'as' |
                    'assert' |
                    'break' |
                    'catch' |
                    'cond' |
                    'const' |
                    'defer' |
                    'else' |
                    'err' |
                    'ext' |
                    'false' |
                    'fn' |
                    'for' |
                    'if' |
                    'in' |
                    'let' |
                    'match' |
                    'meta' |
                    'mod' |
                    'mut' |
                    'next' |
                    'nil' |
                    'not' |
                    'opaque' |
                    'or' |
                    'pub' |
                    'raise' |
                    'rec' |
                    'recv' |
                    'ret' |
                    'tail' |
                    'test' |
                    'this' |
                    'true' |
                    'try' |
                    'type' |
                    'use' |
                    'while' |
                    'with'

Type Keywords

type-keyword ::= 'agent' |
                 'any' |
                 'atom' |
                 'bool' |
                 'handle' |
                 'int' |
                 'none' |
                 'real' |
                 'ref' |
                 'str' |
                 'unk'

Reserved Keywords

reserved-keyword ::= 'friend' |
                     'macro' |
                     'quote' |
                     'unquote' |
                     'yield'

Identifiers

identifier ::= upper-identifier |
               lower-identifier |
               discard-identifier

Uppercase Identifier

upper-identifier ::= [A-Z] [0-9a-zA-Z]*

Lowercase Identifier

lower-identifier ::= [a-z] [_0-9a-z]*

Discard Identifier

discard-identifier ::= '_' [_0-9a-z]*

Special Identifiers

Binding Identifier

binding-identifier ::= discard-identifier |
                       code-identifier

Code Identifier

code-identifier ::= lower-identifier |
                    type-keyword

Literals

literal ::= nil-literal |
            boolean-literal |
            integer-literal |
            real-literal |
            atom-literal |
            string-literal

Nil Literal

nil-literal ::= 'nil'

Boolean Literal

boolean-literal ::= 'true' |
                    'false'

Integer Literal

integer-literal ::= binary-integer-literal |
                    octal-integer-literal |
                    decimal-integer-literal |
                    hexadecimal-integer-literal
binary-integer-literal ::= '0' [bB] binary-digit ('_'* binary-digit)*
binary-digit ::= [0-1]
octal-integer-literal ::= '0' [oO] octal-digit ('_'* octal-digit)*
octal-digit ::= [0-7]
decimal-integer-literal ::= decimal-digit ('_'* decimal-digit)*
decimal-digit ::= [0-9]
hexadecimal-integer-literal ::= '0' [xX] hexadecimal-digit ('_'* hexadecimal-digit)*
hexadecimal-digit ::= [0-9a-fA-F]

Real Literal

real-literal ::= real-part '.' real-part ([eE] [+-]? real-part)?
real-part ::= decimal-digit ('_'* decimal-digit)*

Atom Literal

atom-literal ::= ':' (upper-identifier |
                      lower-identifier |
                      discard-identifier)

String Literal

string-literal ::= regular-string-literal |
                   verbatim-string-literal |
                   block-string-literal

Regular String Literal

regular-string-literal ::= '"' ([^#xa#xd#x85#x2028#x2029"\] |
                                regular-string-escape-sequence)* '"'
regular-string-escape-sequence ::= '\' (regular-string-escape-simple |
                                        regular-string-escape-unicode)
regular-string-escape-simple ::= [0aAbBeEfFnNrRtTvV"\]
regular-string-escape-unicode ::= [uU] hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit hexadecimal-digit

Verbatim String Literal

verbatim-string-literal ::= '"""' '"'* [^#xa#xd#x85#x2028#x2029]+ '"""' '"'*

Block String Literal

block-string-literal ::= '"""' '"'* white-space* line-break block-string-line white-space* '"""' '"'*
block-string-line ::= [^#xa#xd#x85#x2028#x2029]* line-break

Modules

Module Paths

Attributes

attribute ::= '@' code-identifier literal

Declarations

declaration ::= attribute* (use-declaration |
                            type-declaration |
                            constant-declaration |
                            function-declaration |
                            test-declaration)

Use Declaration

Type Declaration

type-declaration ::= ('pub' 'opaque'?)? 'type' lower-identifier type-parameter-list? '=' type ';'
type-parameter-list ::= '(' type-parameter (',' type-parameter)* ','? ')'
type-parameter ::= attribute* type-parameter-binding
type-parameter-binding ::= lower-identifier |
                           discard-identifier

Constant Declaration

Function Declaration

function-declaration ::= 'pub'? (function-declaration-signature block-expression |
                                 'ext' function-declaration-signature ';')
function-declaration-signature ::= 'err'? 'fn' code-identifier function-parameter-list return-type-annotation?
function-parameter-list ::= '(' (function-parameter (',' function-parameter)* ','?)? ')'
function-parameter ::= attribute* function-parameter-binding type-annotation?
function-parameter-binding ::= binding-identifier

Test Declaration

test-declaration ::= 'test' code-identifier block-expression

Types

primary-type ::= nominal-type |
                 literal-type |
                 boolean-type |
                 integer-type |
                 real-type |
                 atom-type |
                 string-type |
                 reference-type |
                 handle-type |
                 module-type |
                 record-type |
                 error-type |
                 tuple-type |
                 array-type |
                 set-type |
                 map-type |
                 function-type |
                 agent-type
type ::= any-type |
         unknown-type |
         union-type |
         variable-type
type-annotation ::= ':' type

Return Types

return-type ::= regular-return-type |
                none-return-type
regular-return-type ::= type
none-return-type ::= 'none'
return-type-annotation ::= '->' return-type return-type-annotation-raise?
return-type-annotation-raise ::= 'raise' type

Special Types

Any Type

any-type ::= 'any'

The type of any operation on a value typed as any is also any. A value of type any can be assigned to a location of any other type.

unk should generally be preferred over any wherever possible.

Unknown Type

unknown-type ::= 'unk'

A value of type unk can only be assigned to a location of type unk or any.

Union Type

union-type ::= primary-type ('or' primary-type)*

Variable Type

Nominal Type

nominal-type ::= nominal-type-path? lower-identifier nominal-type-argument-list?
nominal-type-path ::= module-path '.'
nominal-type-argument-list ::= '(' nominal-type-argument (',' nominal-type-argument)* ','? ')'
nominal-type-argument ::= type

Literal Type

literal-type ::= nil-literal |
                 boolean-literal |
                 '-'? (integer-literal |
                       real-literal) |
                 atom-literal |
                 string-literal

Boolean Type

boolean-type ::= 'bool'

Integer Type

integer-type ::= 'int' integer-type-range?
integer-type-range ::= '(' (integer-type-range-bound '..' integer-type-range-bound? |
                            '..' integer-type-range-bound) ')'
integer-type-range-bound ::= '-'? integer-literal

Real Type

real-type ::= 'real'

Atom Type

String Type

string-type ::= 'str'

Reference Type

Handle Type

Module Type

module-type ::= 'mod' '{' (module-type-field (',' module-type-field)* ','?)? '}'
module-type-field ::= code-identifier ':' type

Record Type

Error Type

error-type ::= 'err' upper-identifier? '{' (error-type-field (',' error-type-field)* ','?)? '}'
error-type-field ::= 'mut'? code-identifier ':' type

Tuple Type

tuple-type ::= '(' type (',' type)+ ','? ')'

Array Type

array-type ::= 'mut'? '[' type ']'

Set Type

set-type ::= 'mut'? '#' '{' type '}'

Map Type

map-type ::= 'mut'? '#' '[' type ':' type ']'

Function Type

function-type ::= 'fn' |
                  'err'? 'fn' function-type-signature?
function-type-signature ::= '(' function-type-parameter-list return-type-annotation ')'
function-type-parameter-list ::= '(' (function-type-parameter (',' function-type-parameter)* ','?)? ')'
function-type-parameter ::= attribute* type

Agent Type

agent-type ::= 'agent' agent-type-protocol?
agent-type-protocol ::= '{' agent-type-message (',' agent-type-message)* ','? '}'
agent-type-message ::= code-identifier agent-type-message-parameter-list
agent-type-message-parameter-list ::= '(' (agent-type-message-parameter (',' agent-type-message-parameter)* ','?)? ')'
agent-type-message-parameter ::= type

Statements

Let Statement

let-statement ::= 'let' pattern '=' expression ';'

Defer Statement

defer-statement ::= 'defer' expression ';'

defer statements are typically used to reliably clean up resources regardless of how control leaves a block expression.

Expression Statement

expression-statement ::= (block-expression |
                          if-expression |
                          condition-expression |
                          match-expression |
                          receive-expression |
                          while-expression |
                          for-expression |
                          try-expression) ';'? | expression ';'

Expressions

Value Expressions

Literal Expression

literal-expression ::= literal

Module Expression

module-expression ::= module-path

Record Expression

record-expression ::= 'rec' record-expression-with? '{' (record-expression-field (',' record-expression-field)* ','?)? '}'
record-expression-with ::= 'with' expression
record-expression-meta ::= 'meta' expression
record-expression-field ::= 'mut'? code-identifier ':' expression

Error Expression

error-expression ::= 'err' upper-identifier error-expression-with? '{' (error-expression-field (',' error-expression-field)* ','?)? '}'
error-expression-with ::= 'with' expression
error-expression-field ::= 'mut'? code-identifier ':' expression

Tuple Expression

tuple-expression ::= '(' expression (',' expression)+ ','? ')'

Array Expression

array-expression ::= 'mut'? '[' (expression (',' expression)* ','?)? ']'

Set Expression

set-expression ::= 'mut'? '#' '{' (expression (',' expression)* ','?)? '}'

Map Expression

map-expression ::= 'mut'? '#' '[' (map-expression-pair (',' map-expression-pair)* ','?)? ']'
map-expression-pair ::= expression ':' expression

Lambda Expression

lambda-expression ::= 'err'? 'fn' lambda-parameter-list '->' expression
lambda-parameter-list ::= '(' (lambda-parameter (',' lambda-parameter)* ','?)? ')'
lambda-parameter ::= attribute* lambda-parameter-binding
lambda-parameter-binding ::= binding-identifier

Operator Expressions

Unary Expressions

unary-expression ::= (custom-operator |
                      'not') prefix-expression

Additive Expressions

additive-expression ::= multiplicative-expression (custom-additive-operator multiplicative-expression)*

Multiplicative Expressions

multiplicative-expression ::= prefix-expression (custom-multiplicative-operator prefix-expression)*

Bitwise Expressions

bitwise-expression ::= shift-expression (custom-bitwise-operator shift-expression)*

Shift Expressions

shift-expression ::= additive-expression (custom-shift-operator additive-expression)*

Logical Expressions

logical-expression ::= relational-expression (('and' |
                                               'or') relational-expression)*

Relational Expressions

relational-expression ::= bitwise-expression (('==' |
                                               '!=' |
                                               '>' |
                                               '>=' |
                                               '<' |
                                               '<=') bitwise-expression)*

Control Expressions

If Expression

if-expression ::= 'if' expression block-expression if-expression-else?
if-expression-else ::= 'else' block-expression

The whole expression results in one of the following values, in order:

The result of the then body.
The result of the else body, if an if-expression-else is present.

Truthiness

Almost all values are considered truthy, with the following exceptions:

Condition Expression

condition-expression ::= 'cond' '{' condition-expression-arm (',' condition-expression-arm)* ','? '}'
condition-expression-arm ::= expression '->' expression

The whole expression results in the value of the evaluated body.

Match Expression

match-expression ::= 'match' expression '{' match-expression-arm (',' match-expression-arm)* ','? '}'
match-expression-arm ::= pattern match-expression-arm-guard? '->' expression
match-expression-arm-guard ::= 'if' expression

Receive Expression

receive-expression ::= 'recv' '{' receive-expression-arm (',' receive-expression-arm)* ','? '}' receive-expression-else?
receive-expression-arm ::= code-identifier receive-parameter-list receive-expression-arm-guard? '->' expression ','
receive-expression-arm-guard ::= 'if' expression
receive-expression-else ::= 'else' block-expression
receive-parameter-list ::= '(' (receive-parameter (',' receive-parameter)* ','?)? ')'
receive-parameter ::= pattern

While Expression

while-expression ::= 'while' expression block-expression while-expression-else?
while-expression-else ::= 'else' block-expression

The whole expression results in one of the following values, in order:

The result of the loop body, if at least one iteration completes.
The result of the else body, if a while-expression-else is present.

For Expression

for-expression ::= 'for' pattern 'in' expression block-expression for-expression-else?
for-expression-else ::= 'else' block-expression

Try Expression

try-expression ::= 'try' expression 'catch' '{' try-expression-arm (',' try-expression-arm)* ','? '}'
try-expression-arm ::= try-catch-pattern try-expression-arm-guard? '->' expression
try-expression-arm-guard ::= 'if' expression

Return Expression

return-expression ::= 'tail'? 'ret' expression

It is a semantic error for a ret expression to appear outside of an fn declaration or lambda expression. A ret expression cannot appear in the body of a defer statement, unless it is nested in a lambda expression.

A ret expression has no result value.

Raise Expression

raise-expression ::= 'raise' expression

Next Expression

next-expression ::= 'next'

It is a semantic error for a next expression to appear outside of the loop body of a while expression or for expression. If a next expression appears in the body of a defer statement, it cannot bind to a while expression or for expression outside of the body.

A next expression has no result value.

Break Expression

It is a semantic error for a break expression to appear outside of the loop body of a while expression or for expression. If a break expression appears in the body of a defer statement, it cannot bind to a while expression or for expression outside of the body.

A break expression has no result value.

Parenthesized Expression

parenthesized-expression ::= '(' expression ')'

Block Expression

block-expression ::= '{' statement+ '}'

This Expression

Meta Expression

meta-expression ::= 'meta' expression

Assert Expression

assert-expression ::= 'assert' expression

The result of an assert expression is the value of the condition.

Identifier Expression

identifier-expression ::= code-identifier

Assignment Expression

assignment-expression ::= logical-expression ('=' assignment-expression)*

Field Expression

field-expression ::= '.' code-identifier

Index Expression

index-expression ::= index-argument-list
index-argument-list ::= '[' index-argument (',' index-argument)* ','? ']'
index-argument ::= expression

Call Expression

call-expression ::= call-argument-list '?'
call-argument-list ::= '(' (call-argument (',' call-argument)* ','?)? ')'
call-argument ::= expression

Send Expression

send-expression ::= '->' code-identifier send-argument-list
send-argument-list ::= '(' (send-argument (',' send-argument)* ','?)? ')'
send-argument ::= expression