Struct TransferClosure 

pub struct TransferClosure {
    pub is_async: bool,
    pub arity: usize,
    pub body: ClosureBody,
    pub module: String,
    pub captures: Vec<(String, Transfer)>,
}

The parts of a Closure a receiving task can own.

The body carries the declaration with it and is shared rather than copied wherever it can be: an Arc<Block> is immutable syntax, so two threads reading the same one observe nothing about each other. Only the captures are converted, which is where the task-safety rule has anything to decide.

Fields

is_async: bool

arity: usize

How many parameters the closure declares — a number, and so nothing the task-safety rule has to decide about.

body: ClosureBody

The body, in whichever of the two forms the backend that made this closure builds.

ClosureBody::Tree is syntax and crosses the way the declaration inside it does: an Arc<Block> is immutable, so two threads reading one observe nothing about each other, and the parameters beside it are copied like any other owned syntax. ClosureBody::Linear is a crate::value::LinearClosure naming a function in one run’s cove_ir::Program and the heap object it closes over, so what its FunctionId means depends on which program the receiving task is running against — and the answer is that every task of a run runs against the same one, immutable once lowered. The heap object crosses unconverted alongside it, because ADR 0034 makes the object heap the run’s rather than the task’s, so an address made on one task’s thread is good on another’s. Lowering the program a second time on the receiving thread would not have given the same FunctionId, which is why nothing does.

module: String

captures: Vec<(String, Transfer)>

Trait Implementations

impl Clone for TransferClosure

fn clone(&self) -> TransferClosure

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransferClosure

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

Formats the value using the given formatter.