Trait wasmtime_environ::__core::prelude::v1::Extend

pub trait Extend<A> {
    fn extend<T>(&mut self, iter: T)
    where
        T: IntoIterator<Item = A>;

    fn extend_one(&mut self, item: A) { ... }
    fn extend_reserve(&mut self, additional: usize) { ... }
}

Extend a collection with the contents of an iterator.

Iterators produce a series of values, and collections can also be thought of as a series of values. The Extend trait bridges this gap, allowing you to extend a collection by including the contents of that iterator. When extending a collection with an already existing key, that entry is updated or, in the case of collections that permit multiple entries with equal keys, that entry is inserted.

Examples

Basic usage:

// You can extend a String with some chars:
let mut message = String::from("The first three letters are: ");

message.extend(&['a', 'b', 'c']);

assert_eq!("abc", &message[29..32]);

Implementing Extend:

// A sample collection, that's just a wrapper over Vec<T>
#[derive(Debug)]
struct MyCollection(Vec<i32>);

// Let's give it some methods so we can create one and add things
// to it.
impl MyCollection {
    fn new() -> MyCollection {
        MyCollection(Vec::new())
    }

    fn add(&mut self, elem: i32) {
        self.0.push(elem);
    }
}

// since MyCollection has a list of i32s, we implement Extend for i32
impl Extend<i32> for MyCollection {

    // This is a bit simpler with the concrete type signature: we can call
    // extend on anything which can be turned into an Iterator which gives
    // us i32s. Because we need i32s to put into MyCollection.
    fn extend<T: IntoIterator<Item=i32>>(&mut self, iter: T) {

        // The implementation is very straightforward: loop through the
        // iterator, and add() each element to ourselves.
        for elem in iter {
            self.add(elem);
        }
    }
}

let mut c = MyCollection::new();

c.add(5);
c.add(6);
c.add(7);

// let's extend our collection with three more numbers
c.extend(vec![1, 2, 3]);

// we've added these elements onto the end
assert_eq!("MyCollection([5, 6, 7, 1, 2, 3])", format!("{c:?}"));

Required methods

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = A>, 

Extends a collection with the contents of an iterator.

As this is the only required method for this trait, the trait-level docs contain more details.

Examples

Basic usage:

// You can extend a String with some chars:
let mut message = String::from("abc");

message.extend(['d', 'e', 'f'].iter());

assert_eq!("abcdef", &message);

Provided methods

fn extend_one(&mut self, item: A)

🔬 This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

The default implementation does nothing.

Implementations on Foreign Types

impl<'a> Extend<&'a OsStr> for OsString

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = &'a OsStr>, 

impl<K, V, S> Extend<(K, V)> for HashMap<K, V, S> where
    K: Eq + Hash,
    S: BuildHasher, 

Inserts all new key-values from the iterator and replaces values with existing keys with new values returned from the iterator.

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = (K, V)>, 

fn extend_one(&mut self, (K, V))

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a, T, S> Extend<&'a T> for HashSet<T, S> where
    T: 'a + Eq + Hash + Copy,
    S: BuildHasher, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'a T>, 

fn extend_one(&mut self, &'a T)

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl Extend<OsString> for OsString

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = OsString>, 

impl<P> Extend<P> for PathBuf where
    P: AsRef<Path>, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = P>, 

fn extend_one(&mut self, p: P)

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a, K, V, S> Extend<(&'a K, &'a V)> for HashMap<K, V, S> where
    K: Eq + Hash + Copy,
    V: Copy,
    S: BuildHasher, 

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = (&'a K, &'a V)>, 

fn extend_one(&mut self, (&'a K, &'a V))

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl<T, S> Extend<T> for HashSet<T, S> where
    T: Eq + Hash,
    S: BuildHasher, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

fn extend_one(&mut self, item: T)

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a> Extend<Cow<'a, OsStr>> for OsString

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = Cow<'a, OsStr>>, 

impl<A, B, ExtendA, ExtendB> Extend<(A, B)> for (ExtendA, ExtendB) where
    ExtendA: Extend<A>,
    ExtendB: Extend<B>, 

fn extend<T>(&mut self, into_iter: T) where
    T: IntoIterator<Item = (A, B)>, 

Allows to extend a tuple of collections that also implement Extend.

See also: Iterator::unzip

Examples

let mut tuple = (vec![0], vec![1]);
tuple.extend([(2, 3), (4, 5), (6, 7)]);
assert_eq!(tuple.0, [0, 2, 4, 6]);
assert_eq!(tuple.1, [1, 3, 5, 7]);

// also allows for arbitrarily nested tuples as elements
let mut nested_tuple = (vec![1], (vec![2], vec![3]));
nested_tuple.extend([(4, (5, 6)), (7, (8, 9))]);

let (a, (b, c)) = nested_tuple;
assert_eq!(a, [1, 4, 7]);
assert_eq!(b, [2, 5, 8]);
assert_eq!(c, [3, 6, 9]);

fn extend_one(&mut self, item: (A, B))

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl Extend<()> for ()

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = ()>, 

fn extend_one(&mut self, _item: ())

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a> Extend<&'a str> for String

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'a str>, 

fn extend_one(&mut self, s: &'a str)

🔬 This is a nightly-only experimental API. (extend_one)

impl<T, A> Extend<T> for VecDeque<T, A> where
    A: Allocator, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

fn extend_one(&mut self, elem: T)

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a, T, A> Extend<&'a T> for Vec<T, A> where
    T: 'a + Copy,
    A: 'a + Allocator, 

Extend implementation that copies elements out of references before pushing them onto the Vec.

This implementation is specialized for slice iterators, where it uses copy_from_slice to append the entire slice at once.

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'a T>, 

fn extend_one(&mut self, &'a T)

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl Extend<Box<str, Global>> for String

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = Box<str, Global>>, 

impl<T> Extend<T> for BTreeSet<T> where
    T: Ord, 

fn extend<Iter>(&mut self, iter: Iter) where
    Iter: IntoIterator<Item = T>, 

fn extend_one(&mut self, elem: T)

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a> Extend<Cow<'a, str>> for String

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = Cow<'a, str>>, 

fn extend_one(&mut self, s: Cow<'a, str>)

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a> Extend<&'a char> for String

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'a char>, 

fn extend_one(&mut self, &'a char)

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl Extend<String> for String

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = String>, 

fn extend_one(&mut self, s: String)

🔬 This is a nightly-only experimental API. (extend_one)

impl<T> Extend<T> for LinkedList<T>

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

fn extend_one(&mut self, elem: T)

🔬 This is a nightly-only experimental API. (extend_one)

impl<T> Extend<T> for BinaryHeap<T> where
    T: Ord, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

fn extend_one(&mut self, item: T)

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a, T, A> Extend<&'a T> for VecDeque<T, A> where
    T: 'a + Copy,
    A: Allocator, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'a T>, 

fn extend_one(&mut self, &T)

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl<T, A> Extend<T> for Vec<T, A> where
    A: Allocator, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

fn extend_one(&mut self, item: T)

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a, K, V> Extend<(&'a K, &'a V)> for BTreeMap<K, V> where
    K: Ord + Copy,
    V: Copy, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = (&'a K, &'a V)>, 

fn extend_one(&mut self, (&'a K, &'a V))

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a, T> Extend<&'a T> for BTreeSet<T> where
    T: 'a + Ord + Copy, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'a T>, 

fn extend_one(&mut self, &'a T)

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a, T> Extend<&'a T> for LinkedList<T> where
    T: 'a + Copy, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'a T>, 

fn extend_one(&mut self, &'a T)

🔬 This is a nightly-only experimental API. (extend_one)

impl Extend<char> for String

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = char>, 

fn extend_one(&mut self, c: char)

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl<'a, T> Extend<&'a T> for BinaryHeap<T> where
    T: 'a + Ord + Copy, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'a T>, 

fn extend_one(&mut self, &'a T)

🔬 This is a nightly-only experimental API. (extend_one)

fn extend_reserve(&mut self, additional: usize)

🔬 This is a nightly-only experimental API. (extend_one)

impl<K, V> Extend<(K, V)> for BTreeMap<K, V> where
    K: Ord, 

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = (K, V)>, 

fn extend_one(&mut self, (K, V))

🔬 This is a nightly-only experimental API. (extend_one)

impl<K, V, S> Extend<(K, V)> for IndexMap<K, V, S> where
    K: Hash + Eq,
    S: BuildHasher, 

fn extend<I>(&mut self, iterable: I) where
    I: IntoIterator<Item = (K, V)>, 

Extend the map with all key-value pairs in the iterable.

This is equivalent to calling insert for each of them in order, which means that for keys that already existed in the map, their value is updated but it keeps the existing order.

New keys are inserted in the order they appear in the sequence. If equivalents of a key occur more than once, the last corresponding value prevails.

impl<T, S> Extend<T> for IndexSet<T, S> where
    T: Hash + Eq,
    S: BuildHasher, 

fn extend<I>(&mut self, iterable: I) where
    I: IntoIterator<Item = T>, 

impl<'a, K, V, S> Extend<(&'a K, &'a V)> for IndexMap<K, V, S> where
    K: Hash + Eq + Copy,
    V: Copy,
    S: BuildHasher, 

fn extend<I>(&mut self, iterable: I) where
    I: IntoIterator<Item = (&'a K, &'a V)>, 

Extend the map with all key-value pairs in the iterable.

See the first extend method for more details.

impl<'a, T, S> Extend<&'a T> for IndexSet<T, S> where
    T: 'a + Hash + Eq + Copy,
    S: BuildHasher, 

fn extend<I>(&mut self, iterable: I) where
    I: IntoIterator<Item = &'a T>, 

impl<T, S, A> Extend<T> for HashSet<T, S, A> where
    T: Eq + Hash,
    S: BuildHasher,
    A: Allocator + Clone, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

impl<K, V, S, A> Extend<(K, V)> for HashMap<K, V, S, A> where
    K: Eq + Hash,
    S: BuildHasher,
    A: Allocator + Clone, 

Inserts all new key-values from the iterator and replaces values with existing keys with new values returned from the iterator.

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = (K, V)>, 

impl<'a, T, S, A> Extend<&'a T> for HashSet<T, S, A> where
    T: 'a + Eq + Hash + Copy,
    S: BuildHasher,
    A: Allocator + Clone, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'a T>, 

impl<'a, K, V, S, A> Extend<(&'a K, &'a V)> for HashMap<K, V, S, A> where
    K: Eq + Hash + Copy,
    V: Copy,
    S: BuildHasher,
    A: Allocator + Clone, 

fn extend<T>(&mut self, iter: T) where
    T: IntoIterator<Item = (&'a K, &'a V)>, 

Implementors