Rust Methods Reference

Appends an element to the back of the vector. Panics if the number of elements overflows a usize.

Removes the last element from the vector and returns it wrapped in Some, or None if the vector is empty.

Returns the number of elements in the vector, also referred to as its length.

Returns an iterator over immutable references to each element of the vector. The vector cannot be modified during iteration.

Sorts the vector in-place in ascending order. This sort is stable (preserves the order of equal elements) and uses a modified merge sort.

Returns true if the vector contains an element equal to the given value. Uses linear search.

Creates a new heap-allocated String from a string slice (&str). This is one of the most common ways to create owned strings in Rust.

Returns an iterator over substrings of the string slice, separated by characters matched by a pattern.

Returns a string slice with leading and trailing whitespace removed. Does not allocate a new string.

Replaces all matches of a pattern with another string and returns a new String.

Returns the uppercase equivalent of this string slice as a new String, according to Unicode rules.

Takes a closure and creates an iterator that calls that closure on each element. The map iterator is lazy and does nothing until consumed.

Creates an iterator that yields only the elements for which the closure returns true. The closure receives a reference to each element.

Consumes the iterator and collects the resulting values into a collection. The target type can often be inferred by the compiler.

Applies a closure to each element, threading an accumulator value through the computation. Returns the final accumulated value.

Creates an iterator that yields pairs of (index, element), where the index starts at 0.

Zips two iterators into a single iterator of pairs. The resulting iterator ends when either input iterator is exhausted.

Inserts a key-value pair into the map. If the map already contained a value for this key, the old value is returned wrapped in Some.

Returns a reference to the value corresponding to the key, or None if the key is not present.

Removes a key from the map, returning the stored value if the key was previously in the map.

Returns true if the map contains a value for the specified key.

Returns the contained Some value. Panics if the value is None with a generic panic message.

Returns the contained Some value, or a provided default value if the Option is None.

Maps an Option<T> to Option<U> by applying a function to the contained value (if Some), or returns None (if None).

Returns None if the Option is None, otherwise calls the closure with the wrapped value and returns the result. Also known as flatmap in other languages.

Returns the contained Ok value. Panics if the value is an Err, with the Err value as the panic message.

Maps a Result<T, E> to Result<U, E> by applying a function to the contained Ok value, leaving an Err value untouched.

Calls the closure if the Result is Ok, otherwise returns the Err value unchanged. Useful for chaining operations that can each fail.

Binary searches a sorted slice for a given element. Returns Ok(index) if found, Err(index) if not found where index is where the element could be inserted to maintain sort order.

Returns an iterator over consecutive non-overlapping sub-slices of the given chunk size. The last chunk may have fewer elements if the slice length is not evenly divisible.

Returns an iterator over all contiguous windows (overlapping sub-slices) of a given length. The windows overlap by window_size - 1 elements.