This is licensed under the MIT license

Daemos is a transaction engine for handling time- and action based operations. Basically each transaction may have a script and / or an expiration time. When the expiration time is hit the script will get executed. The script may produce a new transaction to be executed in the future.

The transaction script language is a language called MuteScript (Mute). It's a relatively simple language, but it allows the execution to be suspended and continued at any point in time by storing the transaction stage.

Note that any syntax described in this document is intended to explain the expressions; they're edited for brevity.

Generally Mute is an imperative programming language. It does not support user-defined types or functions currently (although user defined functions are planned, and some syntax for it exists). Statements are terminated with ; and is generally in the C camp of syntax.

statementBody
    : '{' statement* '}'
    ;

Each script is a module and module is currently mandatory (although planned for removal). So each script starts with the following:

module myModule;

Datatypes can be either nullable or non-nullable. The default is non-nullable. To make a datatype nullable append ?.

dataType
    : (identifier) '?'?
    ;

Variables are declared with either let (readonly) or var (mutable). Some expressions require that you use let (such as importExpression).

declaration
    : ('let'|'var') identifier (':' dataType)? ('<-' (expression))
    | 'let' identifier '<-' 'import' dataType
    ;

Import expressions are readonly since they denote unserializable dependencies for the script. This may be changed in the future.

Conditional execution is done using the if expression or statement. An if without braces covering all execution paths is an expression, but without braces is a statement.

ifExpression
    : 'if' '(' expression ')' expression ('elseif' '(' expression ')' expression)* ('else' expression)?
    ;

Functions on dependencies (or other objects) can be called using familiar C-style syntax although it also includes named arguments.

argument
    : expression
    ;
namedArgument
    : identifier ':' expression
    ;
functionCall
    : expression '(' (argument)* ')'
    | expression '(' (namedArgument)+ ')'
    ;

You cannot mix named and unnamed arguments. Either it's all named, or none. Some parameters have optional values which can be omitted.

Cast's are currently done using the cast operator, but will use function call syntax in the future.

cast
    : dataType '!' '(' expression ')'
    ;

literalExpression
    : ('true'|'false')
    | 'null'
    | [0-9]+
    | 'this'
    | '@' dateTime // Datetime follows ISO-8601 date format
    | '"' doubleQuotedStringContents '"'
    | '\'' singleQuotedStringContents '\''
    | ('initialize'|'authorize'|'complete'|'fail','cancel') // Used to assign transaction state
    ;

Follows regular C while and do-while expressions.

while
    : 'while' '(' expression ')' statementBody
    | 'do' statementBody 'while' '(' expression ')'
    ;

Commits the specified transaction to its storage engine.

commitExpression
    : 'commit' expression
    ;

Awaits a committed transaction. This stores the scripts state and exits.

awaitExpression
    : 'await' expression
	| 'await' variable
	| 'await' withExpression
    ;

Object expressions are general object structure definitions. It's loosely similar to JSON.

objectExpression
    : '{' (identifier ':' expression)* '}'
    ;

Generally used to alter a transaction since transactions are immutable.

withExpression
    : expression 'with' objectExpression
    ;

module foo;
let communication <- import PaymentService;
let now <- this.Created;

var failureCount <- 0;

try
{
    let result <- communication.Authorize(this.Payload.Amount);
    await commit this with { Expires: this.Created + timespan(hours: 1, minutes: 0, seconds: 0), State: authorize, Payload: this.Payload with { transactionId: result.TransactionId } };
}
catch<Exception>
{
    failureCount <- failureCount + 1;
    if(failureCount < 3)
    {
        await commit this with { Expires: this.Created + timespan(hours: 24, minutes: 0, seconds: 0, State: fail, Error: ex }
        retry;
    }
    else
    {
        rethrow;
    }
}

communication.Complete(this.Payload.TransactionId);
commit this with { State: complete };

Run the console application using dotnet. It requires PostgreSQL server to run properly although an in-memory option is available.