Enum artichoke_core::load::Required

pub enum Required {
    Success,
    AlreadyRequired,
}

The side effect from a call to Kernel#require.

In Ruby, require is stateful. All required sources are tracked in a global interpreter state accessible as $" and $LOADED_FEATURES.

The first time a file is required, it is parsed and executed by the interpreter. If the file executes without raising an error, the file is successfully required and Rust callers can expect a Required::Success variant. Files that are successfully required are added to the interpreter’s set of loaded features.

If the file raises an exception as it is required, Rust callers can expect an Err variant. The file is not added to the set of loaded features.

If the file has previously been required such that Required::Success has been returned, all subsequent calls to require the file will return Required::AlreadyRequired.

See the documentation of require_source for more details.

Variants

Success

Kernel#require succeeded at requiring the file.

If this variant is returned, this is the first time the given file has been required in the interpreter.

This variant has value true when converting to a Boolean as returned by Kernel#require.

AlreadyRequired

Kernel#require did not require the file because it has already been required.

If this variant is returned, this is at least the second time the given file has been required. Interpreters guarantee that files are only required once. To load a source multiple times, see load_source and Kernel#load.

This variant has value false when converting to a Boolean as returned by Kernel#require.

Trait Implementations

impl Clone for Required

fn clone(&self) -> Required

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Required

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

Formats the value using the given formatter.

impl From<Required> for bool

fn from(req: Required) -> Self

Convert a Required enum into a bool as returned by Kernel#require.

impl Hash for Required

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Required

fn cmp(&self, other: &Required) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Required

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Required

fn partial_cmp(&self, other: &Required) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for Required

impl Eq for Required

impl StructuralPartialEq for Required