Trait Extend

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

    // Provided methods
    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

// 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.

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.

Implementors

impl Extend<(String, Value)> for rustmax::tera::Map<String, Value>

impl Extend<(String, Value)> for rustmax::toml::map::Map<String, Value>

impl Extend<Signal> for SigSet

impl Extend<TokenTree> for rustmax::proc_macro2::TokenStream

impl Extend<TokenTree> for rustmax::proc_macro::TokenStream

impl Extend<char> for String

impl Extend<u8> for BytesMut

impl Extend<()> for ()

impl Extend<FileType> for FileType

impl Extend<AtFlags> for nix::fcntl::AtFlags

impl Extend<FallocateFlags> for nix::fcntl::FallocateFlags

impl Extend<FdFlag> for FdFlag

impl Extend<OFlag> for OFlag

impl Extend<RenameFlags> for nix::fcntl::RenameFlags

impl Extend<ResolveFlag> for ResolveFlag

impl Extend<SealFlag> for SealFlag

impl Extend<PollFlags> for PollFlags

impl Extend<MemFdCreateFlag> for MemFdCreateFlag

impl Extend<SaFlags> for SaFlags

impl Extend<SfdFlags> for SfdFlags

impl Extend<Mode> for nix::sys::stat::Mode

impl Extend<SFlag> for SFlag

impl Extend<FsFlags> for FsFlags

impl Extend<ControlFlags> for ControlFlags

impl Extend<InputFlags> for InputFlags

impl Extend<LocalFlags> for LocalFlags

impl Extend<OutputFlags> for OutputFlags

impl Extend<WaitPidFlag> for WaitPidFlag

impl Extend<AccessFlags> for AccessFlags

impl Extend<CipherCtxFlags> for CipherCtxFlags

impl Extend<CMSOptions> for CMSOptions

impl Extend<OcspFlag> for OcspFlag

impl Extend<Pkcs7Flags> for Pkcs7Flags

impl Extend<ExtensionContext> for ExtensionContext

impl Extend<ShutdownState> for ShutdownState

impl Extend<SslMode> for SslMode

impl Extend<SslOptions> for SslOptions

impl Extend<SslSessionCacheMode> for SslSessionCacheMode

impl Extend<SslVerifyMode> for SslVerifyMode

impl Extend<X509CheckFlags> for X509CheckFlags

impl Extend<X509VerifyFlags> for X509VerifyFlags

impl Extend<CreateFlags> for CreateFlags

impl Extend<ReadFlags> for ReadFlags

impl Extend<WatchFlags> for WatchFlags

impl Extend<Access> for Access

impl Extend<AtFlags> for rustix::backend::fs::types::AtFlags

impl Extend<FallocateFlags> for rustix::backend::fs::types::FallocateFlags

impl Extend<MemfdFlags> for MemfdFlags

impl Extend<Mode> for rustix::backend::fs::types::Mode

impl Extend<OFlags> for OFlags

impl Extend<RenameFlags> for rustix::backend::fs::types::RenameFlags

impl Extend<ResolveFlags> for ResolveFlags

impl Extend<SealFlags> for SealFlags

impl Extend<StatVfsMountFlags> for StatVfsMountFlags

impl Extend<StatxFlags> for StatxFlags

impl Extend<DupFlags> for DupFlags

impl Extend<FdFlags> for FdFlags

impl Extend<ReadWriteFlags> for ReadWriteFlags

impl Extend<MountFlags> for MountFlags

impl Extend<MountPropagationFlags> for MountPropagationFlags

impl Extend<UnmountFlags> for UnmountFlags

impl Extend<IFlags> for IFlags

impl Extend<XattrFlags> for XattrFlags

impl Extend<Table> for ArrayOfTables

impl Extend<CodegenConfig> for CodegenConfig

impl Extend<Bytes> for BytesMut

impl Extend<TokenStream> for rustmax::proc_macro2::TokenStream

impl Extend<TokenStream> for rustmax::proc_macro::TokenStream

impl Extend<Modifiers> for Modifiers

impl Extend<Error> for Error

impl Extend<OsString> for OsString

impl Extend<String> for String

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

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

impl<'a> Extend<&'a u8> for BytesMut

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

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

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

impl<'a, K, V, A> Extend<(&'a K, &'a V)> for BTreeMap<K, V, A>

where K: Ord + Copy, V: Copy, A: Allocator + Clone,

impl<'a, K, V, S> Extend<(&'a K, &'a V)> for IndexMap<K, V, S>

where K: Hash + Eq + Copy, V: Copy, S: BuildHasher,

impl<'a, K, V, S> Extend<(&'a K, &'a V)> for AHashMap<K, V, S>

where K: Eq + Hash + Copy + 'a, V: Copy + 'a, S: BuildHasher,

impl<'a, K, V, S> Extend<(&'a K, &'a V)> for rustmax::std::collections::HashMap<K, V, S>

where K: Eq + Hash + Copy, V: Copy, S: BuildHasher,

impl<'a, K, V, S, A> Extend<&'a (K, V)> for hashbrown::map::HashMap<K, V, S, A>

where K: Eq + Hash + Copy, V: Copy, S: BuildHasher, A: Allocator,

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

impl<'a, K, V, S, A> Extend<(&'a K, &'a V)> for hashbrown::map::HashMap<K, V, S, A>

where K: Eq + Hash + Copy, V: Copy, S: BuildHasher, A: Allocator,

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

impl<'a, T, A> Extend<&'a T> for BinaryHeap<T, A>

where T: 'a + Ord + Copy, A: Allocator,

impl<'a, T, A> Extend<&'a T> for BTreeSet<T, A>

where T: 'a + Ord + Copy, A: Allocator + Clone,

impl<'a, T, A> Extend<&'a T> for LinkedList<T, A>

where T: 'a + Copy, A: Allocator,

impl<'a, T, A> Extend<&'a T> for VecDeque<T, A>

where T: 'a + Copy, A: Allocator,

impl<'a, T, A> Extend<&'a T> for Vec<T, A>

where T: 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.

impl<'a, T, S> Extend<&'a T> for IndexSet<T, S>

where T: Hash + Eq + Copy + 'a, S: BuildHasher,

impl<'a, T, S> Extend<&'a T> for AHashSet<T, S>

where T: 'a + Eq + Hash + Copy, S: BuildHasher,

impl<'a, T, S> Extend<&'a T> for rustmax::std::collections::HashSet<T, S>

where T: 'a + Eq + Hash + Copy, S: BuildHasher,

impl<'a, T, S, A> Extend<&'a T> for hashbrown::set::HashSet<T, S, A>

where T: 'a + Eq + Hash + Copy, S: BuildHasher, A: Allocator,

impl<A> Extend<<A as Array>::Item> for SmallVec<A>

where A: Array,

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

where A: Allocator,

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

where ExtendA: Extend<A>, ExtendB: Extend<B>,

impl<B> Extend<bool> for BitVec<B>

where B: BitBlock,

impl<B> Extend<usize> for BitSet<B>

where B: BitBlock,

impl<Fut> Extend<Fut> for FuturesOrdered<Fut>

where Fut: Future,

impl<Fut> Extend<Fut> for FuturesUnordered<Fut>

impl<K, V> Extend<(K, V)> for InlineTable

where K: Into<Key>, V: Into<Value>,

impl<K, V> Extend<(K, V)> for Table

where K: Into<Key>, V: Into<Item>,

impl<K, V, A> Extend<(K, V)> for BTreeMap<K, V, A>

where K: Ord, A: Allocator + Clone,

impl<K, V, S> Extend<(K, V)> for IndexMap<K, V, S>

where K: Hash + Eq, S: BuildHasher,

impl<K, V, S> Extend<(K, V)> for AHashMap<K, V, S>

where K: Eq + Hash, S: BuildHasher,

impl<K, V, S> Extend<(K, V)> for rustmax::std::collections::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.

impl<K, V, S, A> Extend<(K, V)> for hashbrown::map::HashMap<K, V, S, A>

where K: Eq + Hash, S: BuildHasher, A: Allocator,

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

impl<L, R, A> Extend<A> for Either<L, R>

where L: Extend<A>, R: Extend<A>,

impl<P> Extend<P> for PathBuf

where P: AsRef<Path>,

impl<St> Extend<St> for SelectAll<St>

where St: Stream + Unpin,

impl<T> Extend<(Option<HeaderName>, T)> for HeaderMap<T>

impl<T> Extend<(HeaderName, T)> for HeaderMap<T>

impl<T, A> Extend<T> for BinaryHeap<T, A>

where T: Ord, A: Allocator,

impl<T, A> Extend<T> for BTreeSet<T, A>

where T: Ord, A: Allocator + Clone,

impl<T, A> Extend<T> for LinkedList<T, A>

where A: Allocator,

impl<T, A> Extend<T> for VecDeque<T, A>

where A: Allocator,

impl<T, A> Extend<T> for Vec<T, A>

where A: Allocator,

impl<T, P> Extend<Pair<T, P>> for Punctuated<T, P>

where P: Default,

impl<T, P> Extend<T> for Punctuated<T, P>

where P: Default,

impl<T, S> Extend<T> for IndexSet<T, S>

where T: Hash + Eq, S: BuildHasher,

impl<T, S> Extend<T> for AHashSet<T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S> Extend<T> for rustmax::std::collections::HashSet<T, S>

where T: Eq + Hash, S: BuildHasher,

impl<T, S, A> Extend<T> for hashbrown::set::HashSet<T, S, A>

where T: Eq + Hash, S: BuildHasher, A: Allocator,

impl<T, const CAP: usize> Extend<T> for ArrayVec<T, CAP>

Extend the ArrayVec with an iterator.

Panics if extending the vector exceeds its capacity.

impl<V> Extend<V> for Array

where V: Into<Value>,