Enum ReturnStrategy 

pub enum ReturnStrategy {
    ReturnSelf,
    ReturnOtherClass,
    ReturnOtherClassList,
    ChainableMutation,
    Direct,
}

Return handling strategy for class methods.

Determines how the R wrapper function processes and returns the .Call() result. Each class system generator uses this to produce idiomatic R return code.

Variants

ReturnSelf

The method returns Self. The wrapper wraps the raw pointer result with the appropriate class attribute or creates a new class object (e.g., R6Class$new(.ptr = result) or structure(result, class = "...")).

ReturnOtherClass

The method returns a bare type name that may be another registered ExternalPtr-backed class. The final decision is deferred to write_r_wrappers_to_file, where the complete class registry is known.

ReturnOtherClassList

The method returns a list of values (Vec<Class>, plus its Option<Vec<Class>> / Result<Vec<Class>, E> wrappers; an Option’s NULL passes through the wrap) whose element type may be another registered ExternalPtr-backed class (#1284). Deferred to write_r_wrappers_to_file like ReturnOtherClass, but through a distinct .__MX_WRAP_LIST_RETURN_* marker that resolves to a per-element lapply(...) wrap. The marker prefix must never overlap the scalar .__MX_WRAP_RETURN_ family: the scalar resolver rewrites unrecognized markers of its own prefix to the bare expression, so a shared prefix would consume list markers before the list resolver ran.

ChainableMutation

The method is a &mut self method returning (). The wrapper calls the .Call() for its side effect and returns the receiver (self/x) for method chaining. The receiver is returned visibly unless the method is marked Invisible<..> / invisible (#1213).

Direct

Default strategy: return the .Call() result directly without wrapping.

Implementations

impl ReturnStrategy

pub fn for_method(method: &ParsedMethod) -> Self

Determine the return strategy for a parsed method.

• Methods that return Self, Result<Self, E>, or Option<Self> use ReturnSelf. The C wrapper already raised on Err (see crate::c_wrapper_builder::ReturnHandling::ResultExternalPtr) and gives NULL for None (see crate::c_wrapper_builder::ReturnHandling::OptionExternalPtr), which passes through; any other .val is a bare ExternalPtr — identical in shape to the bare-Self case — and gets the same class-wrapping tail.
• In-place builders (&mut self -> &mut Self / &self -> Self) and &mut self -> () methods use ChainableMutation. Both return the receiver object (x / self, visibly unless marked invisible) so the call composes under the native pipe (obj |> set_a(1) |> set_b(2)); the C wrapper hands back the same ExternalPtr handle (see crate::c_wrapper_builder::ReturnHandling::SelfHandle).

A visibility marker on the return type (Invisible<Self>, Invisible<()>, …) is peeled at parse time (ParsedMethod::sig holds the inner type), so it never changes the strategy; it only sets MethodReturnBuilder::with_invisible.

• Bare capitalized return types that are not known primitives/containers use ReturnOtherClass; write-time registry lookup wraps registered classes and leaves false positives unchanged. This also covers the explicit-handle spelling ExternalPtr<Class> (#1375) — the detector peels through it to the same wrapped name.
• Vec<Class> (and its Option/Result wrappers; an Option return’s NULL passes through) use ReturnOtherClassList; write-time registry lookup wraps registered element classes via lapply and leaves false positives unchanged (#1284). This also covers Vec<ExternalPtr<Class>> and Vec<Self> (#1375) — the latter via returns_self_list(), since the scalar detector can’t name Self; with_return_class_from_method substitutes the actual name.
• All other methods use Direct.

Trait Implementations

impl Clone for ReturnStrategy

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ReturnStrategy

impl Debug for ReturnStrategy

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

Formats the value using the given formatter.

impl Eq for ReturnStrategy

#[doc(hidden)]

fn assert_receiver_is_total_eq(&self)

👎Deprecated since 1.95.0:

implementation detail of #[derive(Eq)]

#[doc(hidden)]

fn assert_fields_are_eq(&self)

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

impl PartialEq for ReturnStrategy

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ReturnStrategy

impl TrivialClone for ReturnStrategy

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1 byte

Size for each variant:

• ReturnSelf: 0 bytes
• ReturnOtherClass: 0 bytes
• ReturnOtherClassList: 0 bytes
• ChainableMutation: 0 bytes
• Direct: 0 bytes