Struct Ref

pub struct Ref<T, B: ?Sized = T> { /* private fields */ }

Implementations

impl<T, B> Ref<T, [B]>

pub fn get(this: Self, index: usize) -> Option<Ref<T, B>>

pub fn range(this: Self, range: Range<usize>) -> Option<Ref<T, [B]>>

pub fn first(this: Self) -> Option<Ref<T, B>>

pub fn skip_first(this: Self) -> Option<Ref<T, [B]>>

pub fn split_first(this: Self) -> Option<(Ref<T, B>, Ref<T, [B]>)>

pub fn split_at(this: Self, mid: usize) -> (Ref<T, [B]>, Ref<T, [B]>)

pub fn split_at_checked( this: Self, mid: usize, ) -> Result<(Ref<T, [B]>, Ref<T, [B]>), Self>

pub fn chunk_by<F: for<'a> FnMut(&'a B, &'a B) -> bool>( this: Self, f: F, ) -> ChunkBy<T, B, F>

pub fn chunks(this: Self, size: usize) -> Chunks<T, B>

pub fn split<F: for<'a> FnMut(&'a B) -> bool>( this: Self, f: F, ) -> Split<T, B, F>

pub fn split_inclusive<F: for<'a> FnMut(&'a B) -> bool>( this: Self, f: F, ) -> SplitInclusive<T, B, F>

pub fn windows(this: Self, size: usize) -> Windows<T, B>

impl<T> Ref<T, ()>

pub fn destructure(self)

impl<T, B0> Ref<T, (B0,)>

pub fn destructure(self) -> (Ref<T, B0>,)

impl<T, B0, B1> Ref<T, (B0, B1)>

pub fn destructure(self) -> (Ref<T, B0>, Ref<T, B1>)

impl<T, B0, B1, B2> Ref<T, (B0, B1, B2)>

pub fn destructure(self) -> (Ref<T, B0>, Ref<T, B1>, Ref<T, B2>)

impl<T, B0, B1, B2, B3> Ref<T, (B0, B1, B2, B3)>

pub fn destructure(self) -> (Ref<T, B0>, Ref<T, B1>, Ref<T, B2>, Ref<T, B3>)

impl<T, B: ?Sized> Ref<T, B>

pub fn downgrade(&self) -> Weak<T, B>

pub fn map<C: ?Sized>(self, f: impl for<'a> FnOnce(&'a B) -> &'a C) -> Ref<T, C>

Given that f works for all lifetimes 'a, it will also work for the indeterminable, yet existant, lifetime of the BorrowInner.

Experimental

This is intended to be a safe API, and I believe that it is safe, however the work to prove this thoroughly is complex and has not yet been undertaken. This work will be done before v1.0.0.

Do not rely on this being safe in safety critical contexts

pub fn context<R>(self, f: impl for<'a> FnOnce(&'a B, Context<'a, T>) -> R) -> R

Uses the same principle behind other scoping APIs to provide additional support to specific lifetimes.

The lifetime in question here is the same 'a as referenced in Ref::map, as the true 'a can not be know the lifetime '_ will be used as a stand_in as it is truly anonymous.

Experimental

This is intended to be a safe API, and I believe that it is safe, however the work to prove this thoroughly is complex and has not yet been undertaken. This work will be done before v1.0.0.

Do not rely on this being safe in safety critical contexts

pub async fn scope<F: Future>( self, f: impl for<'a> FnOnce(&'a B, Context<'a, T>, Spawner<'a>) -> F, ) -> F::Output

Uses the same principle behind other scoping APIs to provide additional support to specific lifetimes.

The lifetime in question here is the same 'a as referenced in Ref::map, as the true 'a can not be know the lifetime '_ will be used as a stand_in as it is truly anonymous.

Experimental

This is intended to be a safe API, and I believe that it is safe, however the work to prove this thoroughly is complex and has not yet been undertaken. This work will be done before v1.0.0.

Do not rely on this being safe in safety critical contexts

pub fn into_deref(self) -> Ref<T, B::Target>

where B: Deref,

A special case of Ref::map to handle dereferencing.

Experimental

This is intended to be a safe API, and I believe that it is safe, however the work to prove this thoroughly is complex and has not yet been undertaken. This work will be done before v1.0.0.

Do not rely on this being safe in safety critical contexts

pub fn into_borrow<C>(self) -> Ref<T, C>

where B: Borrow<C>,

A special case of Ref::map to handle borrowing.

Experimental

This is intended to be a safe API, and I believe that it is safe, however the work to prove this thoroughly is complex and has not yet been undertaken. This work will be done before v1.0.0.

Do not rely on this being safe in safety critical contexts

Trait Implementations

impl<T, B: ?Sized> Clone for Ref<T, B>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, B: ?Sized> Deref for Ref<T, B>

type Target = B

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, B: ?Sized> From<RefMut<T, B>> for Ref<T, B>

fn from(value: RefMut<T, B>) -> Self

Converts to this type from the input type.

impl<T, B> IntoIterator for Ref<T, [B]>

type Item = Ref<T, B>

The type of the elements being iterated over.

type IntoIter = Iter<T, B>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Send, B: ?Sized + Sync> Send for Ref<T, B>

impl<T: Send, B: ?Sized + Sync> Sync for Ref<T, B>