Struct RThreadBuilder 

pub struct RThreadBuilder {
    stack_size: usize,
    name: Option<String>,
}

Builder for spawning pure-Rust threads with a legacy R-sized stack.

This builder is always available and configures threads with stack sizes suitable for stack-heavy Rust workloads (8 MiB default, vs Rust’s 2 MiB default).

When the nonapi feature is enabled, spawned threads also automatically disable R’s stack checking via StackCheckGuard. That changes only the stack-address check and does not make R API calls from the thread safe.

Example

use miniextendr_api::thread::RThreadBuilder;

let handle = RThreadBuilder::new()
    .stack_size(16 * 1024 * 1024)  // 16 MiB
    .name("r-worker".to_string())
    .spawn(expensive_pure_rust_computation)?;

Fields

stack_size: usize

name: Option<String>

Implementations

impl RThreadBuilder

pub fn new() -> Self

Create a new builder with default settings.

Default stack size is DEFAULT_R_STACK_SIZE (8 MiB).

pub fn stack_size(self, size: usize) -> Self

Set the stack size for the thread.

The default is 8 MiB, matching the legacy R-sized configuration rather than Rust’s typical 2 MiB spawned-thread default.

pub fn name(self, name: String) -> Self

Set the name for the thread (for debugging).

pub fn spawn<F, T>(self, f: F) -> Result<JoinHandle<T>>

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Spawn the thread with the configured settings.

With nonapi feature: automatically disables R’s stack checking. Without nonapi feature: just spawns with the configured stack size.

pub fn spawn_join<F, T>(self, f: F) -> Result<T>

where F: FnOnce() -> T + Send + 'static, T: Send + 'static,

Spawn and immediately join, returning the result.

Convenience method for synchronously joining a configured thread.

Example

let result = RThreadBuilder::new().spawn_join(|| 40 + 2).unwrap();

Trait Implementations

impl Default for RThreadBuilder

fn default() -> Self

Returns the “default value” for a type.

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: 32 bytes