Trait TursoFromIterator 

pub trait TursoFromIterator<T>: Sized {
    // Required methods
    fn try_from_iter<I>(iter: I) -> Result<Self, TryReserveError>
       where I: IntoIterator<Item = T>;
    fn try_extend<I>(&mut self, iter: I) -> Result<(), TryReserveError>
       where I: IntoIterator<Item = T>;
}

Required Methods

fn try_from_iter<I>(iter: I) -> Result<Self, TryReserveError>

where I: IntoIterator<Item = T>,

fn try_extend<I>(&mut self, iter: I) -> Result<(), TryReserveError>

where I: IntoIterator<Item = T>,

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<A, B, C, D, E, F, FromA, FromB, FromC, FromD, FromE, FromF> TursoFromIterator<(A, B, C, D, E, F)> for (FromA, FromB, FromC, FromD, FromE, FromF)

where FromA: TursoFromIterator<A>, FromB: TursoFromIterator<B>, FromC: TursoFromIterator<C>, FromD: TursoFromIterator<D>, FromE: TursoFromIterator<E>, FromF: TursoFromIterator<F>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F)>,

impl<A, B, C, D, E, F, G, FromA, FromB, FromC, FromD, FromE, FromF, FromG> TursoFromIterator<(A, B, C, D, E, F, G)> for (FromA, FromB, FromC, FromD, FromE, FromF, FromG)

where FromA: TursoFromIterator<A>, FromB: TursoFromIterator<B>, FromC: TursoFromIterator<C>, FromD: TursoFromIterator<D>, FromE: TursoFromIterator<E>, FromF: TursoFromIterator<F>, FromG: TursoFromIterator<G>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G)>,

impl<A, B, C, D, E, F, G, H, FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH> TursoFromIterator<(A, B, C, D, E, F, G, H)> for (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH)

where FromA: TursoFromIterator<A>, FromB: TursoFromIterator<B>, FromC: TursoFromIterator<C>, FromD: TursoFromIterator<D>, FromE: TursoFromIterator<E>, FromF: TursoFromIterator<F>, FromG: TursoFromIterator<G>, FromH: TursoFromIterator<H>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G, H)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G, H)>,

impl<A, B, C, D, E, F, G, H, I, FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI> TursoFromIterator<(A, B, C, D, E, F, G, H, I)> for (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI)

where FromA: TursoFromIterator<A>, FromB: TursoFromIterator<B>, FromC: TursoFromIterator<C>, FromD: TursoFromIterator<D>, FromE: TursoFromIterator<E>, FromF: TursoFromIterator<F>, FromG: TursoFromIterator<G>, FromH: TursoFromIterator<H>, FromI: TursoFromIterator<I>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G, H, I)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G, H, I)>,

impl<A, B, C, D, E, F, G, H, I, J, FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ> TursoFromIterator<(A, B, C, D, E, F, G, H, I, J)> for (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ)

where FromA: TursoFromIterator<A>, FromB: TursoFromIterator<B>, FromC: TursoFromIterator<C>, FromD: TursoFromIterator<D>, FromE: TursoFromIterator<E>, FromF: TursoFromIterator<F>, FromG: TursoFromIterator<G>, FromH: TursoFromIterator<H>, FromI: TursoFromIterator<I>, FromJ: TursoFromIterator<J>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G, H, I, J)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G, H, I, J)>,

impl<A, B, C, D, E, F, G, H, I, J, K, FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK> TursoFromIterator<(A, B, C, D, E, F, G, H, I, J, K)> for (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK)

where FromA: TursoFromIterator<A>, FromB: TursoFromIterator<B>, FromC: TursoFromIterator<C>, FromD: TursoFromIterator<D>, FromE: TursoFromIterator<E>, FromF: TursoFromIterator<F>, FromG: TursoFromIterator<G>, FromH: TursoFromIterator<H>, FromI: TursoFromIterator<I>, FromJ: TursoFromIterator<J>, FromK: TursoFromIterator<K>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G, H, I, J, K)>,

impl<A, B, C, D, E, F, G, H, I, J, K, L, FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL> TursoFromIterator<(A, B, C, D, E, F, G, H, I, J, K, L)> for (FromA, FromB, FromC, FromD, FromE, FromF, FromG, FromH, FromI, FromJ, FromK, FromL)

where FromA: TursoFromIterator<A>, FromB: TursoFromIterator<B>, FromC: TursoFromIterator<C>, FromD: TursoFromIterator<D>, FromE: TursoFromIterator<E>, FromF: TursoFromIterator<F>, FromG: TursoFromIterator<G>, FromH: TursoFromIterator<H>, FromI: TursoFromIterator<I>, FromJ: TursoFromIterator<J>, FromK: TursoFromIterator<K>, FromL: TursoFromIterator<L>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E, F, G, H, I, J, K, L)>,

impl<A, B, C, D, E, FromA, FromB, FromC, FromD, FromE> TursoFromIterator<(A, B, C, D, E)> for (FromA, FromB, FromC, FromD, FromE)

where FromA: TursoFromIterator<A>, FromB: TursoFromIterator<B>, FromC: TursoFromIterator<C>, FromD: TursoFromIterator<D>, FromE: TursoFromIterator<E>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D, E)>,

impl<A, B, C, D, FromA, FromB, FromC, FromD> TursoFromIterator<(A, B, C, D)> for (FromA, FromB, FromC, FromD)

where FromA: TursoFromIterator<A>, FromB: TursoFromIterator<B>, FromC: TursoFromIterator<C>, FromD: TursoFromIterator<D>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A, B, C, D)>,

impl<A, B, C, FromA, FromB, FromC> TursoFromIterator<(A, B, C)> for (FromA, FromB, FromC)

where FromA: TursoFromIterator<A>, FromB: TursoFromIterator<B>, FromC: TursoFromIterator<C>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A, B, C)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A, B, C)>,

impl<A, B, FromA, FromB> TursoFromIterator<(A, B)> for (FromA, FromB)

where FromA: TursoFromIterator<A>, FromB: TursoFromIterator<B>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A, B)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A, B)>,

impl<A, FromA> TursoFromIterator<(A,)> for (FromA,)

where FromA: TursoFromIterator<A>,

fn try_from_iter<Iter>(iter: Iter) -> Result<Self, TryReserveError>

where Iter: IntoIterator<Item = (A,)>,

fn try_extend<Iter>(&mut self, iter: Iter) -> Result<(), TryReserveError>

where Iter: IntoIterator<Item = (A,)>,

impl<T, C> TursoFromIterator<Option<T>> for Option<C>

where C: TursoFromIterator<T>,

fn try_from_iter<I>(iter: I) -> Result<Self, TryReserveError>

where I: IntoIterator<Item = Option<T>>,

fn try_extend<I>(&mut self, iter: I) -> Result<(), TryReserveError>

where I: IntoIterator<Item = Option<T>>,

impl<T, E, F, C> TursoFromIterator<Result<T, E>> for Result<C, F>

where C: TursoFromIterator<T>, F: From<E>,

fn try_from_iter<I>(iter: I) -> Result<Self, TryReserveError>

where I: IntoIterator<Item = Result<T, E>>,

fn try_extend<I>(&mut self, iter: I) -> Result<(), TryReserveError>

where I: IntoIterator<Item = Result<T, E>>,

Implementors

impl<K, V> TursoFromIterator<(K, V)> for HashMap<K, V>

where K: Eq + Hash,

impl<T: Ord> TursoFromIterator<T> for BinaryHeap<T>

impl<T> TursoFromIterator<T> for Box<[T]>

impl<T> TursoFromIterator<T> for HashSet<T>

where T: Eq + Hash,

impl<T> TursoFromIterator<T> for Vec<T>

Available on non-nightly only.

impl<T> TursoFromIterator<T> for VecDeque<T>