Grammar overview

compilationUnit   ::= namespace? useDirective*  # Compile-time entities
                      ( compositeDef | functionDef | standAloneTypeDef )*
namespace         ::= ‘namespace' ID+. ‘;'
useDirective      ::= ‘use' ID+. ‘::' ( ‘*' | ID ) ‘;apos;

Composite operators are defined at the top level in a namespace.

compositeDef    ::= compositeHead compositeBody # Composite operators
compositeHead   ::= ‘public'? ‘composite' ID ( ‘(' compositeInOut+; ‘)' )?
compositeInOut  ::= ( ‘input' | ‘output' ) ( streamType? ID )+,
streamType      ::= ‘stream' ‘<' tupleBody ‘>'
compositeBody   ::= ‘{'
                    ( ‘param' compositeFormal+ )?
                    ( ‘type' compositeTypeDef+ )?
                    ( ‘graph' opInvoke+        )?
                    ( ‘config' configuration+  )?
                    ‘}'
compositeFormal ::= expressionMode ID ( ‘:' opActual )? ‘; # Operator parameter modes
opInvokeActual  ::= ID ‘:' opActual ‘;'
opActual        ::= type | expr+,
configuration   ::= ID ‘:' expr+, ‘;'  # Config clause, Config clause

Streams are defined in a composite operator's graph clause.

opInvoke        ::= opInvokeHead opInvokeBody  # Operator invocations
opInvokeHead    ::= opOutputs ( ‘as' ID )? ‘=' ID opInputs  # Operator invocation head
opOutputs       ::= opOutput | ‘(' opOutput*; ‘)'
opOutput        ::= streamType ID ( ‘as' ID )?
opInputs        ::= ‘(' portInputs*; ‘)'
portInputs      ::= streamType? ID+, ( ‘as' ID )?
opInvokeBody    ::= ‘{'  # Operator invocations
                    ( ‘logic' opInvokeLogic+ )?
                    ( ‘window' opInvokeWindow+ )?
                    ( ‘param' opInvokeActual+ )?
                    ( ‘output' opInvokeOutput+ )?
                    ( ‘config' configuration+ )?
                    ‘}'
opInvokeLogic   ::= opInvokeCode | opInvokeState  # Logic clause
opInvokeCode    ::= 'onProcess' ':' stmt
                    | ( 'onTuple' | 'onPunct' ) ':' stmt
opInvokeState   ::= ‘state' ‘:' ( varDef | ‘{' varDef+ ‘}' )
opInvokeWindow  ::= ID ‘:' expr+, ‘;'  # Window clause
opInvokeOutput  ::= ID ‘:' ( ID ‘=' expr )+, ‘;'  # Output clause

SPL functions are defined at the top level in a namespace.

functionDef      ::= functionHead blockStmt  # SPL functions
functionHead     ::= functionModifier* type ID ‘(' functionFormal*, ‘)'
functionModifier ::= ‘public' | ‘stateful'
functionFormal   ::= ‘mutable'? type ID

Native function prototype declarations come from XML files, not regular SPL files.

functionPrototype    ::= genericFormals functionModifier*  # Native functions
                        type ID ‘(' protoFormal*, ‘)'
genericFormals       ::= ( ‘<' typeFormal+, ‘>' )? ( ‘[' boundsFormal+, ‘]' )?
typeFormal           ::= typeFormalConstraint ID
typeFormalConstraint ::= ‘any' | ‘collection' | ‘complex' | ‘composite'
                       | ‘decimal' | ‘enum' | ‘float' | ‘floatingpoint'
                       | ‘integral' | ‘list' | ‘map' | ‘numeric' | ‘ordered'
                       | ‘primitive' | ‘set' | ‘string' | ‘tuple'
boundsFormal         ::= ID
protoFormal          ::= formalModifier* type ID?

Imperative statements can appear in function bodies or the logic clause of an operator invocation.

stmt          ::= varDef | blockStmt | exprStmt  # Statements
                | ifStmt | forStmt | whileStmt
                | breakStmt | continueStmt | returnStmt
varDef        ::= ‘mutable'? type  ( ID ( ‘=' expr )? )+, ‘;'
blockStmt     ::= ‘{' ( stmt | standAloneTypeDef )* ‘}'
exprStmt      ::= expr ‘;'
ifStmt        ::= ‘if' ‘(' expr ‘)' stmt ( ‘else' stmt )?
forStmt       ::= ‘for' ‘(' type ID ‘in' expr ‘)' stmt
whileStmt     ::= ‘while' ‘(' expr ‘)' stmt
breakStmt     ::= ‘break' ‘;'
continueStmt  ::= ‘continue' ‘;'
returnStmt    ::= ‘return' expr? ‘;'

Expressions can appear in many places in the grammar. For precedence and associativity, see # Expression operators.

expr            ::= prefixExpr | infixExpr | postfixExpr
                  | conditionalExpr | ‘(' expr ‘)' | ID 
                  | literal  # Expression language
prefixExpr      ::= prefixOp expr
prefixOp        ::= ‘!' | ‘-' | ‘~' | ‘++' | ‘--'
infixExpr       ::= expr ( infixOp | mappedOp | assignOp ) expr
infixOp         ::= ‘+' | ‘-' | ‘*' | ‘/' | ‘%' | ‘<<' | ‘>>' | ‘&' | ‘ˆ' | ‘|'
                  | ‘&&' | ‘||' | ‘in' | ‘<' | ‘<=' | ‘>' | ‘>=' | ‘!=' | ‘=='
mappedOp        ::= ‘.+' | ‘.-' | ‘.*' | ‘./' | ‘.%' | ‘.<<' | ‘.>>' | ‘.&'
                  | ‘.^' | ‘.|' | ‘.<' | ‘.<=' | ‘.>' | ‘.>=' | ‘.!=' | ‘.=='
assignOp        ::= ‘=' | ‘+=' | ‘-=' | ‘*=' | ‘/=' | ‘%=' | ‘<<=' | ‘>>='
                  | ‘&=' | ‘^=' | ‘|='
postfixExpr     ::= ID ‘(' expr*, ‘)'
                  | type ‘(' expr ‘)'
                  | expr ‘[' subscript ‘]'
                  | expr ‘.' ID
                  | expr postfixOp
subscript       ::= expr | ( expr? ‘:' expr? )
postfixOp       ::= ‘++' | ‘--'
conditionalExpr ::= expr ‘?' expr ‘:' expr

Literals are the highest-precedence expressions that denote values.

literal           ::= primitiveLiteral | listLiteral | setLiteral | mapLiteral 
                      | tupleLiteral # Expression language
listLiteral       ::= ‘[' expr*, ‘]'  # Collections
setLiteral        ::= ‘{' expr*, ‘}'
mapLiteral        ::= ‘{' ( expr ‘:' expr )*, ‘}'
tupleLiteral      ::= ‘{' ( ID ‘=' expr)*, ‘}'  # Tuples
primitiveLiteral  ::= ‘true' | ‘false' | STRING | FLOAT | INT  # Primitive types;

Types are defined in a composite operator's type clause, or in a block, or at the top level.

standAloneTypeDef ::= ‘type' ID ‘=' ( type | tupleBody ) ‘;'
compositeTypeDef  ::= ‘static'? ID ‘=' ( type | tupleBody ) ‘;'  # Tuples
expressionMode  ::= ‘attribute' | ‘expression' typeArgs?  # Operator parameter modes
                  | ‘function' | ‘operator' | ‘type'
type            ::= ID | ‘void' | primitiveType | compositeType  # Types
typeArgs        ::= ‘<' type+, ‘>'
typeDims        ::= ‘[' expr ‘]'

Primitive types are types without other types as arguments.

primitiveType   ::= ‘boolean'  # Primitive types
                  | ‘enum' ‘{' ID*, ‘}'
                  | ‘int8' | ‘int16' | ‘int32' | ‘int64' | ‘int128'
                  | ‘uint8' | ‘uint16' | ‘uint3'| ‘uint64' | ‘uint128'
                  | ‘float32' | ‘float64'
                  | ‘decimal32' | ‘decimal64' | ‘decimal128'
                  | ‘complex32' | ‘complex64'
                  | ‘timestamp'
                  | ‘blob'
                  | ‘rstring' typeDims?
                  | ‘ustring'
                  | ‘xml' ('<' "schemaURI" '>')?

Composite types are type constructors for composing new types out of other types.

compositeType   ::= tupleType  # Composite types
                 | ‘list' typeArgs typeDims?
                 | ‘map' typeArgs typeDims?
                 | ‘set' typeArgs typeDims?
tupleType       ::= ‘tuple' ‘<' tupleBody ‘>'  # Tuples
tupleBody       ::= attributeDecl+,
                 | ( ID | tupleType )+,
attributeDecl   ::= type ID