MontyRun

Primary interface for running Monty code

MontyRun

Primary interface for running Monty code. MontyRun supports two execution modes:

• Simple execution: Use run() or run_no_limits() to run code to completion
• Iterative execution: Use start() to start execution which will pause at external function calls and can be resumed later

Constructor

new()

Creates a new run snapshot by parsing the given code.

This only parses and prepares the code - no heap or namespaces are created yet. Call run() with inputs to start execution.

code · String · required

The Python code to execute

script_name · &str · required

The script name for error messages

input_names · Vec<String> · required

Names of input variables

Result<MontyRun, MontyException>

Returns the parsed MontyRun or an error if the code cannot be parsed

use monty::{MontyRun, MontyObject};

let runner = MontyRun::new(
    "x + 1".to_owned(),
    "test.py",
    vec!["x".to_owned()]
).unwrap();

Execution Methods

run()

Executes the code to completion assuming no external functions or snapshotting.

This is marginally faster than running with snapshotting enabled since we don’t need to track the position in code, but does not allow calling of external functions.

inputs · Vec<MontyObject> · required

Values to fill the first N slots of the namespace

resource_tracker · impl ResourceTracker · required

Custom resource tracker implementation

print · &mut PrintWriter<'_> · required

Print output writer (mutably borrowed so Collect data is preserved)

Result<MontyObject, MontyException>

Returns the final result value or an error if execution fails

use monty::{MontyRun, MontyObject, NoLimitTracker, PrintWriter};

let runner = MontyRun::new(
    "x + 1".to_owned(),
    "test.py",
    vec!["x".to_owned()]
).unwrap();

let result = runner.run(
    vec![MontyObject::Int(41)],
    NoLimitTracker,
    &mut PrintWriter::Stdout
).unwrap();

assert_eq!(result, MontyObject::Int(42));

run_no_limits()

Executes the code to completion with no resource limits, printing to stdout/stderr.

inputs · Vec<MontyObject> · required

Values to fill the first N slots of the namespace

Result<MontyObject, MontyException>

Returns the final result value or an error if execution fails

use monty::{MontyRun, MontyObject};

let runner = MontyRun::new(
    "x + 1".to_owned(),
    "test.py",
    vec!["x".to_owned()]
).unwrap();

let result = runner.run_no_limits(vec![MontyObject::Int(41)]).unwrap();
assert_eq!(result, MontyObject::Int(42));

start()

Starts execution with the given inputs and resource tracker, consuming self.

For iterative execution, start() consumes self and returns a RunProgress:

• RunProgress::FunctionCall(call) - external function call, call call.resume(return_value) to resume
• RunProgress::Complete(value) - execution finished

This enables snapshotting execution state and returning control to the host application during long-running computations.

inputs · Vec<MontyObject> · required

Initial input values (must match length of input_names from new())

resource_tracker · impl ResourceTracker · required

Resource tracker for the execution

print · &mut PrintWriter<'_> · required

Writer for print output

Result<RunProgress<T>, MontyException>

Returns a RunProgress enum indicating the next step in execution

Errors: Returns MontyException if:

• The number of inputs doesn’t match the expected count
• An input value is invalid (e.g., MontyObject::Repr)
• A runtime error occurs during execution

use monty::{MontyRun, MontyObject, NoLimitTracker, PrintWriter};

let code = r#"
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

fib(x)
"#;

let runner = MontyRun::new(
    code.to_owned(),
    "fib.py",
    vec!["x".to_owned()]
).unwrap();

let result = runner.start(
    vec![MontyObject::Int(10)],
    NoLimitTracker,
    &mut PrintWriter::Stdout
).unwrap();

Serialization Methods

dump()

Serializes the runner to a binary format.

The serialized data can be stored and later restored with load(). This allows caching parsed code to avoid re-parsing on subsequent runs.

Result<Vec<u8>, postcard::Error>

Returns the serialized bytes or an error if serialization fails

use monty::MontyRun;

let runner = MontyRun::new(
    "x + 1".to_owned(),
    "test.py",
    vec!["x".to_owned()]
).unwrap();

let bytes = runner.dump().unwrap();

load()

Deserializes a runner from binary format.

bytes · &[u8] · required

The serialized runner data from dump()

Result<MontyRun, postcard::Error>

Returns the deserialized MontyRun or an error if deserialization fails

use monty::{MontyRun, MontyObject, NoLimitTracker, PrintWriter};

// Serialize parsed code
let runner = MontyRun::new(
    "x + 1".to_owned(),
    "main.py",
    vec!["x".to_owned()]
).unwrap();
let bytes = runner.dump().unwrap();

// Later, restore and run
let runner2 = MontyRun::load(&bytes).unwrap();
let result = runner2.run(
    vec![MontyObject::Int(41)],
    NoLimitTracker,
    &mut PrintWriter::Stdout
).unwrap();

assert_eq!(result, MontyObject::Int(42));

Other Methods

code()

Returns the code that was parsed to create this snapshot.

&str

Reference to the source code string

use monty::MontyRun;

let runner = MontyRun::new(
    "x + 1".to_owned(),
    "test.py",
    vec!["x".to_owned()]
).unwrap();

assert_eq!(runner.code(), "x + 1");