Enum molt::types::ResultCode

pub enum ResultCode {
    Error(Value),
    Return(Value),
    Break,
    Continue,
}

This enum represents the possible exceptional results of evaluating a Molt script, as used in MoltResult. It is often used in the Result<_,ResultCode> type of other functions in the Molt API, so that these functions can easily return errors when used in the definition of Molt commands.

A Molt script can return a normal result, as indicated by MoltResult's Ok variant, or it can return one of a number of exceptional results, which will bubble up the call stack in the usual way until caught.

• Error(Value): This code indicates a Molt error; the Value is the error message for display to the user. (But see "Future Work", below.)

• Return(Value): This code indicates that a Molt procedure called the return command. The Value is the returned value, or the empty value if return was called without a return value. This result will bubble up until it reaches the top-level of the procedure, which will then return the value as a normal Ok result. If it is received when evaluating an arbitrary script, i.e., if return is called outside of any procedure, the interpreter will convert it into a normal Ok result.

• Break: This code indicates a script called the Molt break command. It will break out of the inmost enclosing loop in the usual way. If it is returned outside a loop (or some user-defined control structure that supports break), the interpreter will convert it into an error.

• Continue: This code indicates that a script called the Molt continue command. It will continue with the next iteration of the inmost enclosing loop in the usual way. If it is returned outside a loop (or some user-defined control structure that supports continue), the interpreter will convert it into an error.

Client code will usually see only the Error code; the others will most often be caught and handled within the interpreter. However, client code may explicitly catch and handle the Return, Break, and Continue codes at both the Rust and the TCL level (see the catch command) in order to implement application-specific control structures.

Future Work

• Standard TCL includes more information with non-Ok results, especially for error cases. Ultimately, this type will be need to be extended to support that.

• Standard TCL allows for an arbitrary number of result codes, which in turn allows the application to define an arbitrary number of new kinds of control structures that are distinct from the standard ones. At some point we might wish to add one or more generic result codes, parallel to Break and Continue, for this purpose. (However, in over two decades of TCL programming I've never seen the need to use generic result codes.)

Variants

Error(Value)

Return(Value)

Break

Continue

Methods

impl ResultCode

pub fn is_error(&self) -> bool

Indicates whether the result code is an Error.

Trait Implementations

impl Clone for ResultCode

fn clone(&self) -> ResultCode

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ResultCode

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Eq for ResultCode

impl PartialEq<ResultCode> for ResultCode

fn eq(&self, other: &ResultCode) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &ResultCode) -> bool

This method tests for !=.

impl StructuralEq for ResultCode

impl StructuralPartialEq for ResultCode