Expressions and macros

An expression is a document. The example builds an expression program once and evaluates it with an input document. The macro example expands an expression before compilation and evaluation.

Example

Build an expression and evaluate it

expression_text holds this document:

json

23 B

[
  "+",
  "?x",
  1
]

input_text holds this document:

json

14 B

{
  "x": 41
}

python

228 B

async with (await stardust.parse(expression_text, "json")) as expression, (await stardust.build(expression)) as program, \
        (await stardust.parse(input_text, "json")) as input:
    result = (await program.evaluate(input))

Result / 2 B

Reusing programs

A program keeps the expression that you built, independently of any one evaluation.

You can evaluate one program concurrently with separate input documents.
Keep the program until its evaluations finish.
Then release it under the ownership rule of its operation.

Operations

Operation	Returns	Summary
build	program	build(expression) borrows the expression document and returns an owned program.
build_macro	program	build_macro(title, authored, arguments) binds AST arguments into an unstored macro and returns an owned program.
expand_macro	document	expand_macro(title, authored, arguments) returns the expanded expression document without building it.
Program.evaluate	document	program.evaluate(input) returns an independent owned result document.
Program.close	none	Release the program handle.
Database.expression	program	Build an owned program from a path or inline expression, expanding stored macros.

build

python

79 B

def build(expression: Document, explain: BuildExplain | None = None) -> Program

Parameters

Parameter	Type	Ownership	Default	Meaning
`expression`	`Document`	Borrowed for the call	Required	The native expression AST to compile. The call borrows this document.
`explain`	`BuildExplain \| None`	Caller-owned output	None	Optional explain output. This record contains explain output for `build`.

Errors

Status	When
`"compile_failed"`	the expression does not compile
`"out_of_memory"`	native memory is exhausted

Notes

Expression documents.

Examples

Build an expression and evaluate its input

expression_text holds this document:

json

23 B

[
  "+",
  "?x",
  1
]

input_text holds this document:

json

14 B

{
  "x": 41
}

python

228 B

async with (await stardust.parse(expression_text, "json")) as expression, (await stardust.build(expression)) as program, \
        (await stardust.parse(input_text, "json")) as input:
    result = (await program.evaluate(input))

Result / 2 B

Inspect one measured cost stage

expression_text holds this document:

json

23 B

[
  "+",
  "?x",
  1
]

python

179 B

explain = stardust.BuildExplain()
async with (await stardust.parse(expression_text, "json")) as expression, (await stardust.build(expression, explain)):
    result = explain.total

Result / 49 B

{
  "cpu": 40,
  "wall": 50,
  "arena_bytes": 0
}

Explain expression compilation

expression_text holds this document:

json

23 B

[
  "+",
  "?x",
  1
]

python

173 B

explain = stardust.BuildExplain()
async with (await stardust.parse(expression_text, "json")) as expression, (await stardust.build(expression, explain)):
    result = explain

Result / 302 B

{
  "prepare_expression": {
    "cpu": 10,
    "wall": 20,
    "arena_bytes": 0
  },
  "compile": {
    "cpu": 70,
    "wall": 60,
    "arena_bytes": 0
  },
  "total": {
    "cpu": 100,
    "wall": 110,
    "arena_bytes": 0
  },
  "arena_capacity": 65536,
  "stages_completed": 2,
  "cache_hit": true
}

C exports: stardust_expr_build, stardust_expr_program_error

build_macro

python

79 B

def build_macro(title: str, authored: Document, arguments: Document) -> Program

Parameters

Parameter	Type	Ownership	Default	Meaning
`title`	`str`	Value	Required	The diagnostic title of this unstored macro.
`authored`	`Document`	Borrowed for the call	Required	The native authored macro definition with its declared parameters and expression body.
`arguments`	`Document`	Borrowed for the call	Required	Native AST arguments bound to the macro's declared parameters before expansion.

Errors

Status	When
`"invalid_argument"`	the arguments include an undeclared macro parameter
`"invalid_definition"`	the macro is invalid or expands recursively
`"not_found"`	the macro refers to an unknown macro
`"compile_failed"`	the expansion does not compile
`"out_of_memory"`	native memory is exhausted

Notes

Macro documents.

Examples

Bind an unstored macro and evaluate it

macro_text holds this document:

json

106 B

{
  "params": [
    "input"
  ],
  "expands": [
    "+",
    {
      "insert": "input"
    },
    1
  ]
}

arguments_text holds this document:

json

51 B

{
  "input": [
    "*",
    "?amount",
    2
  ]
}

input_text holds this document:

json

19 B

{
  "amount": 10
}

python

325 B

async with (await stardust.parse(macro_text, "json")) as authored, (await stardust.parse(arguments_text, "json")) as arguments, \
        (await stardust.build_macro("twice-plus-one", authored, arguments)) as program, \
        (await stardust.parse(input_text, "json")) as input:
    result = (await program.evaluate(input))

Result / 2 B

C exports: stardust_macro_build, stardust_expr_program_error

expand_macro

python

81 B

def expand_macro(title: str, authored: Document, arguments: Document) -> Document

Parameters

Parameter	Type	Ownership	Default	Meaning
`title`	`str`	Value	Required	The diagnostic title of this unstored macro.
`authored`	`Document`	Borrowed for the call	Required	The native authored macro definition with its declared parameters and expression body.
`arguments`	`Document`	Borrowed for the call	Required	Native AST arguments bound to the macro's declared parameters before expansion.

Errors

Status	When
`"invalid_argument"`	the arguments include an undeclared macro parameter
`"invalid_definition"`	the macro is invalid or expands recursively
`"not_found"`	the macro refers to an unknown macro
`"out_of_memory"`	native memory is exhausted

Notes

Macro documents.

Examples

Expand an unstored macro as a native document

macro_text holds this document:

json

106 B

{
  "params": [
    "input"
  ],
  "expands": [
    "+",
    {
      "insert": "input"
    },
    1
  ]
}

arguments_text holds this document:

json

51 B

{
  "input": [
    "*",
    "?amount",
    2
  ]
}

python

209 B

async with (await stardust.parse(macro_text, "json")) as authored, (await stardust.parse(arguments_text, "json")) as arguments:
    result = (await stardust.expand_macro("twice-plus-one", authored, arguments))

Result / 53 B

[
  "+",
  [
    "*",
    "?amount",
    2
  ],
  1
]

C exports: stardust_macro_expand, stardust_document_error

Program.evaluate

python

97 B

def evaluate(self, input: Document | None = None, explain: EvalExplain | None = None) -> Document

Parameters

Parameter	Type	Ownership	Default	Meaning
`self`	`Program`	Borrowed for the call	Required	The program owner for this operation. Keep it alive during the call.
`input`	`Document \| None`	Borrowed for the call	None	Variables for evaluation. Absent input uses an empty object.
`explain`	`EvalExplain \| None`	Caller-owned output	None	Optional explain output. This record contains explain output for `evaluate`.

Errors

Status	When
`"evaluation_failed"`	the expression fails on the input
`"closed"`	the program is closed
`"out_of_memory"`	native memory is exhausted

Notes

Expression evaluation.

Examples

Build an expression and evaluate its input

expression_text holds this document:

json

23 B

[
  "+",
  "?x",
  1
]

input_text holds this document:

json

14 B

{
  "x": 41
}

python

228 B

async with (await stardust.parse(expression_text, "json")) as expression, (await stardust.build(expression)) as program, \
        (await stardust.parse(input_text, "json")) as input:
    result = (await program.evaluate(input))

Result / 2 B

Explain expression evaluation

expression_text holds this document:

json

23 B

[
  "+",
  "?x",
  1
]

input_text holds this document:

json

14 B

{
  "x": 41
}

python

279 B

explain = stardust.EvalExplain()
async with (await stardust.parse(expression_text, "json")) as expression, (await stardust.build(expression)) as program, \
        (await stardust.parse(input_text, "json")) as input, (await program.evaluate(input, explain)):
    result = explain

Result / 386 B

{
  "prepare_variables": {
    "cpu": 10,
    "wall": 20,
    "arena_bytes": 0
  },
  "evaluate": {
    "cpu": 280,
    "wall": 280,
    "arena_bytes": 0
  },
  "adopt_document": {
    "cpu": 10,
    "wall": 20,
    "arena_bytes": 0
  },
  "total": {
    "cpu": 320,
    "wall": 330,
    "arena_bytes": 0
  },
  "arena_capacity": 65536,
  "document_bytes": 42,
  "stages_completed": 3
}

C exports: stardust_expr_evaluate, stardust_result_take_document, stardust_result_error, stardust_result_release

Program.close

python

23 B

def close(self) -> None

Consumes the receiver handle.

Parameters

Parameter	Type	Ownership	Default	Meaning
`self`	`Program`	Consumed owner	Required	The program owner to release. Do not use it after this call.

Examples

Build an expression and evaluate its input

expression_text holds this document:

json

23 B

[
  "+",
  "?x",
  1
]

input_text holds this document:

json

14 B

{
  "x": 41
}

python

228 B

async with (await stardust.parse(expression_text, "json")) as expression, (await stardust.build(expression)) as program, \
        (await stardust.parse(input_text, "json")) as input:
    result = (await program.evaluate(input))

Result / 2 B

C exports: stardust_expr_program_release

Database.expression

python

92 B

def expression(self, source: str | Document, explain: BuildExplain | None = None) -> Program

Parameters

Parameter	Type	Ownership	Default	Meaning
`self`	`Database`	Borrowed for the call	Required	The database owner for this operation. Keep it alive during the call.
`source`	`str \| Document`	Value	Required	An inline native definition or a stored definition path.
`explain`	`BuildExplain \| None`	Caller-owned output	None	Optional explain output. This record contains explain output for `build`.

Errors

Status	When
`"not_found"`	no expression is stored at the path
`"invalid_definition"`	a macro it calls is invalid or expands recursively
`"compile_failed"`	the expanded expression does not compile
`"closed"`	the database is closed
`"out_of_memory"`	native memory is exhausted

Notes

The program keeps the expression and macros selected at build time and survives database closure. Build again to use later definition changes.

Expression documents.

Examples

Build an expression with the database's macros and evaluate it

expression_text holds this document:

json

23 B

[
  "+",
  "?x",
  1
]

input_text holds this document:

json

14 B

{
  "x": 41
}

python

227 B

async with (await stardust.parse(expression_text, "json")) as expression, (await db.expression(expression)) as program, \
        (await stardust.parse(input_text, "json")) as input:
    result = (await program.evaluate(input))

Result / 2 B

C exports: stardust_db_expression_build, stardust_expr_program_error