Trait Borrow

pub trait Borrow:
    Len
    + Clone
    + 'static {
    type Ref<'a>: Copy;
    type Borrowed<'a>: Copy + Len + Index<Ref = Self::Ref<'a>>
       where Self: 'a;

    // Required methods
    fn borrow<'a>(&'a self) -> Self::Borrowed<'a>;
    fn reborrow<'b, 'a: 'b>(item: Self::Borrowed<'a>) -> Self::Borrowed<'b>
       where Self: 'a;
    fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'b>
       where Self: 'a;
}

A type that can be borrowed into a preferred reference type.

Required Associated Types

type Ref<'a>: Copy

For each lifetime, a reference with that lifetime.

As an example, (&'a A, &'a [B]).

type Borrowed<'a>: Copy + Len + Index<Ref = Self::Ref<'a>> where Self: 'a

The type of a borrowed container.

Corresponding to our example, (&'a [A], Vecs<&'a [B], &'a [u64]>).

Required Methods

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

Converts a reference to the type to a borrowed variant.

fn reborrow<'b, 'a: 'b>(item: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where Self: 'a,

Reborrows the borrowed type to a shorter lifetime. See Columnar::reborrow for details.

fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

Reborrows the borrowed type to a shorter lifetime. See Columnar::reborrow for details.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<AA: Borrow> Borrow for (AA,)

type Ref<'a> = (<AA as Borrow>::Ref<'a>,) where AA: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>,) where AA: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow> Borrow for (AA, BB)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>) where AA: 'a, BB: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow> Borrow for (AA, BB, CC)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow> Borrow for (AA, BB, CC, DD)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow> Borrow for (AA, BB, CC, DD, EE)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow, FF: Borrow> Borrow for (AA, BB, CC, DD, EE, FF)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>, <FF as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>, <FF as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow, FF: Borrow, GG: Borrow> Borrow for (AA, BB, CC, DD, EE, FF, GG)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>, <FF as Borrow>::Ref<'a>, <GG as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>, <FF as Borrow>::Borrowed<'a>, <GG as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow, FF: Borrow, GG: Borrow, HH: Borrow> Borrow for (AA, BB, CC, DD, EE, FF, GG, HH)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>, <FF as Borrow>::Ref<'a>, <GG as Borrow>::Ref<'a>, <HH as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>, <FF as Borrow>::Borrowed<'a>, <GG as Borrow>::Borrowed<'a>, <HH as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow, FF: Borrow, GG: Borrow, HH: Borrow, II: Borrow> Borrow for (AA, BB, CC, DD, EE, FF, GG, HH, II)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>, <FF as Borrow>::Ref<'a>, <GG as Borrow>::Ref<'a>, <HH as Borrow>::Ref<'a>, <II as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a, II: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>, <FF as Borrow>::Borrowed<'a>, <GG as Borrow>::Borrowed<'a>, <HH as Borrow>::Borrowed<'a>, <II as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a, II: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a, II: 'a,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<AA: Borrow, BB: Borrow, CC: Borrow, DD: Borrow, EE: Borrow, FF: Borrow, GG: Borrow, HH: Borrow, II: Borrow, JJ: Borrow> Borrow for (AA, BB, CC, DD, EE, FF, GG, HH, II, JJ)

type Ref<'a> = (<AA as Borrow>::Ref<'a>, <BB as Borrow>::Ref<'a>, <CC as Borrow>::Ref<'a>, <DD as Borrow>::Ref<'a>, <EE as Borrow>::Ref<'a>, <FF as Borrow>::Ref<'a>, <GG as Borrow>::Ref<'a>, <HH as Borrow>::Ref<'a>, <II as Borrow>::Ref<'a>, <JJ as Borrow>::Ref<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a, II: 'a, JJ: 'a

type Borrowed<'a> = (<AA as Borrow>::Borrowed<'a>, <BB as Borrow>::Borrowed<'a>, <CC as Borrow>::Borrowed<'a>, <DD as Borrow>::Borrowed<'a>, <EE as Borrow>::Borrowed<'a>, <FF as Borrow>::Borrowed<'a>, <GG as Borrow>::Borrowed<'a>, <HH as Borrow>::Borrowed<'a>, <II as Borrow>::Borrowed<'a>, <JJ as Borrow>::Borrowed<'a>) where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a, II: 'a, JJ: 'a

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(thing: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where AA: 'a, BB: 'a, CC: 'a, DD: 'a, EE: 'a, FF: 'a, GG: 'a, HH: 'a, II: 'a, JJ: 'a,

fn reborrow_ref<'b, 'a: 'b>(thing: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<T: Clone + 'static> Borrow for Vec<T>

type Ref<'a> = &'a T

type Borrowed<'a> = &'a [T]

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(item: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where Self: 'a,

fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<T: Borrow> Borrow for Rc<T>

type Ref<'a> = <T as Borrow>::Ref<'a> where T: 'a

type Borrowed<'a> = <T as Borrow>::Borrowed<'a>

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(item: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where Self: 'a,

fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

impl<T: Borrow> Borrow for Arc<T>

type Ref<'a> = <T as Borrow>::Ref<'a> where T: 'a

type Borrowed<'a> = <T as Borrow>::Borrowed<'a>

fn borrow<'a>(&'a self) -> Self::Borrowed<'a>

fn reborrow<'b, 'a: 'b>(item: Self::Borrowed<'a>) -> Self::Borrowed<'b>

where Self: 'a,

fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'b>

where Self: 'a,

Implementors

impl Borrow for Strides

type Ref<'a> = u64

type Borrowed<'a> = Strides<&'a [u64], &'a u64>

impl Borrow for Empties

type Ref<'a> = ()

type Borrowed<'a> = Empties<&'a u64>

impl<BC: BorrowIndexAs<u64>> Borrow for Strings<BC, Vec<u8>>

type Ref<'a> = &'a str

type Borrowed<'a> = Strings<<BC as Borrow>::Borrowed<'a>, &'a [u8]> where BC: 'a

impl<BC: BorrowIndexAs<u64>, TC: Container> Borrow for Vecs<TC, BC>

type Ref<'a> = Slice<<TC as Borrow>::Borrowed<'a>> where TC: 'a

type Borrowed<'a> = Vecs<<TC as Borrow>::Borrowed<'a>, <BC as Borrow>::Borrowed<'a>> where BC: 'a, TC: 'a

impl<C: Borrow> Borrow for Boxed<C>

type Ref<'a> = Boxed<<C as Borrow>::Ref<'a>>

type Borrowed<'a> = Boxed<<C as Borrow>::Borrowed<'a>>

impl<CV: BorrowIndexAs<i64>> Borrow for Isizes<CV>

type Ref<'a> = isize

type Borrowed<'a> = Isizes<<CV as Borrow>::Borrowed<'a>> where CV: 'a

impl<CV: BorrowIndexAs<u32>> Borrow for Chars<CV>

type Ref<'a> = char

type Borrowed<'a> = Chars<<CV as Borrow>::Borrowed<'a>> where CV: 'a

impl<CV: BorrowIndexAs<u64> + Len> Borrow for Usizes<CV>

type Ref<'a> = usize

type Borrowed<'a> = Usizes<<CV as Borrow>::Borrowed<'a>> where CV: 'a

impl<CV: BorrowIndexAs<[u8; 16]>> Borrow for I128s<CV>

type Ref<'a> = i128

type Borrowed<'a> = I128s<<CV as Borrow>::Borrowed<'a>> where CV: 'a

impl<CV: BorrowIndexAs<[u8; 16]>> Borrow for U128s<CV>

type Ref<'a> = u128

type Borrowed<'a> = U128s<<CV as Borrow>::Borrowed<'a>> where CV: 'a

impl<SC: BorrowIndexAs<u64>, NC: BorrowIndexAs<u32>> Borrow for Durations<SC, NC>

type Ref<'a> = Duration

type Borrowed<'a> = Durations<<SC as Borrow>::Borrowed<'a>, <NC as Borrow>::Borrowed<'a>> where SC: 'a, NC: 'a

impl<SC: Borrow, TC: Borrow> Borrow for Results<SC, TC>

type Ref<'a> = Result<<SC as Borrow>::Ref<'a>, <TC as Borrow>::Ref<'a>> where SC: 'a, TC: 'a

type Borrowed<'a> = Results<<SC as Borrow>::Borrowed<'a>, <TC as Borrow>::Borrowed<'a>, &'a [u64], &'a [u64], &'a u64> where SC: 'a, TC: 'a

impl<TC: Borrow> Borrow for Options<TC>

type Ref<'a> = Option<<TC as Borrow>::Ref<'a>> where TC: 'a

type Borrowed<'a> = Options<<TC as Borrow>::Borrowed<'a>, &'a [u64], &'a [u64], &'a u64> where TC: 'a

impl<VC: BorrowIndexAs<u64>> Borrow for Bools<VC>

type Ref<'a> = bool

type Borrowed<'a> = Bools<<VC as Borrow>::Borrowed<'a>, &'a u64> where VC: 'a

impl<const K: u64> Borrow for Fixeds<K>

type Ref<'a> = u64

type Borrowed<'a> = Fixeds<K, &'a u64>