Reverse elements in place l.binary_search(&value), l.binary_search_by(&value, cmp), l.binary_search_by_key(&value, key) Sort, using f to retrieve a key l.reverse() f must return an Ordering l.sort_by_key(f) Sort elements, needs Ord trait l.sort_by(f) Remove and return element at i, swap in last element instead Filling l.fill(v)Ĭall f, use result to paint into l Sorting and Searching l.sort() swap all elements in slices l.swap_remove(i) Swap elements at indices l1.swap(&mut l2) Has no mut variant as it's overlapping Swapping l.swap(i, j) The rest can be retrieved via the results remainder() method l.windows(n) l.rchunks(n), l.rchunks_mut(n)Īs above, but from the right l.chunks_exact(n), l.chunks_exact_mut(n)Ĭhunk up slice into subslices of exactly len n. Last chunk may have less than n elements. Split into subslices of given lenght, returns iterator. n slices l.rsplitn(n, is_sep), l.rsplitn_mut(n, is_sep)Īs above, but split from the right l.chunks(n), l.chunks_mut(n) Split into one subslices if the predicate is_sep() is true l.split_inclusive(is_sep), l.split_inclusive_mut(is_sep)Īs above, but include the separator element l.splitn(n, is_sep), l.splitn_mut(n, is_sep)Īs above, but split into max. Returns an Option that may be None if the slice is empty l.split_last(), l.split_last_mut()Īs above, but split off last, rest l.split(is_sep), l.split_mut(is_sep) Join arrays, separated by s Splitting l.split_at(i), l.split_at_mut(i)īreak a slice in two, returns two refs (shared or mut) l.split_first(), l.split_first_mut()
These operate on 2-dim arrays: l.concat() Like dedup above, but passes elems through f – elements are considered equal if f(e1) = f(e2) Joining Keep elements for which the predicate f() returns true l.dedup()ĭrop consecutive repeated elements, like uniq l.dedup_by_key(f) will remove those elements and returns an iterator over them l.retain(f) l2 still exists (but is empty) l.drain(range) Truncates and returns the split-off tail l.append(l2) Noop if it's already equal or less l.clear()Īdd elements from iter to the end l.split_off(i) Like above but calls f() to construct new values l.truncate(new) If the new len is less, the vector gets truncated l.resize_with(new, f) If this increases the vector size fill in copies of v. Remove value, move existing vals to the left l.resize(new, v) Insert value move existing vals to the right (might be slow) l.remove(i) Remove and return last element (moves out!) l.insert(i, v) Growing and Shrinking Vectors l.len()Ĭreate and specify an initial cap l.capacity()Įnsure enough cap for n more elements =l.shrink tofit() Also see the iter() and iter_mut() methods from the previous chapter. Iterating over a &Vec returns refs, and &mut Vec mut refs. Same as above but return mut refs l.to_vec() Ref to some elem in the middle (or None) l.first_mut(), l.last_mut(), l.get_mut(index) Ref to first element, None if l is empty l.last() The indices must be usizes cast with x as usize. If an index is out of bounds the access will cause a panic. clone() // requires Clone // Get a reference to a slice let my_ref = &buffer // Get a copy of a slice let my_copy = buffer.
Generally, I'm curious if there's any neat solution to solve this problem, i.e., implementing different behaviors for different sub-traits of a parent trait.// Get a reference to an element let first_line = &lines // Get a copy of an element let fifth_number = numbers // requires Copy let second_line = lines. I also tried to create another trait C that inherits A and implement C for bool: use std::marker::PhantomData Is that because potentially someone could implement A for another type and thus make this invalid? To me, it seems that this is valid since all the known subtypes of A have implemented the method w, but it still failed. = note: the following trait defines an item `w`, perhaps you need to implement it: = help: items from traits can only be used if the trait is implemented and in scope = note: the method `w` exists but the following trait bounds were not satisfied: Hi, I have the following program: use std::marker::PhantomData
0 kommentar(er)
