Struct MontyRepl 

pub struct MontyRepl<T>
where
    T: ResourceTracker,
{ /* private fields */ }

Available on crate features code and embedded-python only.

Stateful REPL session that executes snippets incrementally without replay.

MontyRepl preserves heap and global variable state between snippets. Each feed() compiles and executes only the new snippet against the current state, avoiding the cost and semantic risks of replaying prior code.

Implementations

impl<T> MontyRepl<T>

where T: ResourceTracker,

pub fn new( script_name: &str, resource_tracker: T, options: CompileOptions, ) -> MontyRepl<T>

Creates an empty REPL session with no code parsed or executed.

All code execution is driven through feed_run() or feed_start(). This separates construction from execution, matching the pattern used by MontyRun::new(). The CompileOptions apply to every snippet fed to the session.

pub fn tracker(&self) -> &T

Returns the resource tracker that will be used for the next snippet.

This is primarily intended for host integrations that need to attach per-execution state, such as cancellation markers, to an existing REPL.

pub fn tracker_mut(&mut self) -> &mut T

Returns mutable access to the resource tracker for the next snippet.

REPL hosts use this to install ephemeral execution controls, such as async cancellation flags, before calling feed_start().

pub fn feed_start( self, code: &str, inputs: Vec<(String, MontyObject)>, print: PrintWriter<'_>, ) -> Result<ReplProgress<T>, Box<ReplStartError<T>>>

Starts executing a new snippet and returns suspendable REPL progress.

This is the REPL equivalent of MontyRun::start: execution may complete, suspend at external calls / OS calls / unresolved futures, or raise a Python exception. Resume with the returned state object and eventually recover the updated REPL from ReplProgress::into_complete.

Unlike MontyRepl::feed, this method consumes self so runtime state can be safely moved into snapshot objects for serialization and cross-process resume.

On a Python-level runtime exception the REPL is not destroyed: it is returned inside ReplStartError so the caller can continue feeding subsequent snippets against the same heap and namespace state.

Errors

Returns Err(Box<ReplStartError>) for syntax, compile-time, or runtime failures — the REPL session is always preserved inside the error.

pub fn feed_run( &mut self, code: &str, inputs: Vec<(String, MontyObject)>, print: PrintWriter<'_>, ) -> Result<MontyObject, MontyException>

Feeds and executes a new snippet against the current REPL state to completion.

This compiles only code using the existing global slot map, extends the global namespace if new names are introduced, and executes the snippet once. Previously executed snippets are never replayed. If execution raises after partially mutating globals, those mutations remain visible in later feeds, matching Python REPL semantics.

Errors

Returns MontyException for syntax/compile/runtime failures.

pub fn call_function( &mut self, name: &str, args: Vec<MontyObject>, print: PrintWriter<'_>, ) -> Result<MontyObject, MontyException>

Calls a Python function defined in the session by name.

Looks up the function in the global namespace, converts the arguments, executes the function, and converts the result back.

Errors

Returns MontyException if the function is not found, not callable, raises an exception, or encounters an external function call.

pub fn function_names(&self) -> Vec<&str>

Returns a list of all callable function names defined in the session.

Includes functions, closures, and functions with default arguments. Does not include builtins or external functions.

pub fn has_function(&self, name: &str) -> bool

Returns whether a function with the given name exists in the session.

impl<T> MontyRepl<T>

where T: ResourceTracker + Serialize,

pub fn dump(&self) -> Result<Vec<u8>, Error>

Serializes the REPL session state to bytes.

This includes heap + globals + global slot mapping, allowing snapshot/restore of interactive state between process runs.

Errors

Returns an error if serialization fails.

impl<T> MontyRepl<T>

where T: ResourceTracker + DeserializeOwned,

pub fn load(bytes: &[u8]) -> Result<MontyRepl<T>, Error>

Restores a REPL session from bytes produced by MontyRepl::dump.

Errors

Returns an error if deserialization fails.

Trait Implementations

impl<T> Debug for MontyRepl<T>

where T: Debug + ResourceTracker,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for MontyRepl<T>

where T: ResourceTracker + DeserializeOwned,

fn deserialize<__D>( __deserializer: __D, ) -> Result<MontyRepl<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Drop for MontyRepl<T>

where T: ResourceTracker,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<T> Serialize for MontyRepl<T>

where T: ResourceTracker + Serialize,

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.