Struct ChildInfoMeta

pub struct ChildInfoMeta<M>(/* private fields */);

Having a struct with (one) named field (for example, its), instead of a (one field) tuple struct, could make some code “nicer”.

#[repr(transparent)]
pub struct ChildInfoMeta<M> {
    /* Not called `it`, so as not to confuse it with iterators.*/
    pub its: (M, /*...*/),
}

However, that would be useful mostly for either

• accessing the (only) field, but that we can also dereference with asterisk (through Deref and DerefMut). Or
• accessing the anonymous/positional field(s) of the underlying tuple. But for that we have our named accessor methods, so we don’t need to access it through/by specifying the wrapped tuple itself. So we don’t need any of that much.

Instead, the consumers benefit more from easily destructuring our wrappers struct into its (only) positional/anonymous field, especially so they destructure the underlying tuple into its fields (and give them names as local variables).

Why anonymous tuples (with nameless fields)? Brevity of positional constructor. And pattern matching.

Implementations

impl<M> ChildInfoMeta<M>

pub fn child(&self) -> &ChildProcess

Useful if we don’t want to publish the wrapped field.

pub fn info(&self) -> &ChildInfo

pub fn meta(&self) -> &M

Only for non-Copy, or if Copy but deemed large.

If Copy and primitive, then this function doesn’t return a reference, but the field value.

pub fn meta_mut(&mut self) -> &mut M

impl<M> ChildInfoMeta<M>

where M: Copy,

Only for Copy, and only if NOT primitive.

Rename to meta_copy() for non-primitive types, so that its cost would be evident everywhere it’s used.

pub fn meta_copy(&self) -> M