Struct FunctionCall 

pub struct FunctionCall<T>
where
    T: ResourceTracker,
{
    pub function_name: String,
    pub args: Vec<MontyObject>,
    pub kwargs: Vec<(MontyObject, MontyObject)>,
    pub call_id: u32,
    pub method_call: bool,
    /* private fields */
}

Available on crate features code and embedded-python only.

Execution paused at an external function call or dataclass method call.

The host can choose how to handle this:

• Sync resolution: Call resume(return_value, print) to push the result and continue.
• Async resolution: Call resume_pending(print) to push an ExternalFuture and continue.

When using async resolution, the code continues and may await the future later. If the future isn’t resolved when awaited, execution yields with ResolveFutures.

When method_call is true, this represents a dataclass method call where the first positional arg is the dataclass instance (self).

Fields

function_name: String

The name of the function or method being called.

args: Vec<MontyObject>

The positional arguments passed to the function.

kwargs: Vec<(MontyObject, MontyObject)>

The keyword arguments passed to the function (key, value pairs).

call_id: u32

Unique identifier for this call (used for async correlation).

method_call: bool

Whether this is a dataclass method call (first arg is self).

Implementations

impl<T> FunctionCall<T>

where T: ResourceTracker,

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

Returns a mutable reference to the resource tracker.

This allows modifying resource limits between execution phases, e.g. setting a time limit before resuming after an external function call.

pub fn resume( self, result: impl Into<ExtFunctionResult>, print: PrintWriter<'_>, ) -> Result<RunProgress<T>, MontyException>

Resumes execution with the return value or exception from the external function.

Consumes self and returns the next execution progress.

Arguments

• result — The return value, exception, or pending future marker.
• print — Writer for print() output.

pub fn resume_pending( self, print: PrintWriter<'_>, ) -> Result<RunProgress<T>, MontyException>

Resumes execution by pushing an ExternalFuture instead of a concrete value.

This is the async resolution pattern: the host continues execution with a pending future. The code can then await this future later. If the code awaits the future before it’s resolved, execution will yield with RunProgress::ResolveFutures.

Uses self.call_id internally — no need to pass it again.

Arguments

• print — Writer for print output.

Trait Implementations

impl<T> Debug for FunctionCall<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 FunctionCall<T>

where T: ResourceTracker + DeserializeOwned,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Serialize for FunctionCall<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.