1.36.0[−][src]Struct std::io::IoSlice
A buffer type used with Write::write_vectored
.
It is semantically a wrapper around an &[u8]
, but is guaranteed to be
ABI compatible with the iovec
type on Unix platforms and WSABUF
on
Windows.
Methods
impl<'a> IoSlice<'a>
[src]
pub fn new(buf: &'a [u8]) -> IoSlice<'a>
[src]
Creates a new IoSlice
wrapping a byte slice.
Panics
Panics on Windows if the slice is larger than 4GB.
pub fn advance<'b>(
bufs: &'b mut [IoSlice<'a>],
n: usize
) -> &'b mut [IoSlice<'a>]
[src]
bufs: &'b mut [IoSlice<'a>],
n: usize
) -> &'b mut [IoSlice<'a>]
Advance the internal cursor of the slice.
Notes
Elements in the slice may be modified if the cursor is not advanced to
the end of the slice. For example if we have a slice of buffers with 2
IoSlice
s, both of length 8, and we advance the cursor by 10 bytes the
first IoSlice
will be untouched however the second will be modified to
remove the first 2 bytes (10 - 8).
Examples
#![feature(io_slice_advance)] use std::io::IoSlice; use std::mem; use std::ops::Deref; let mut buf1 = [1; 8]; let mut buf2 = [2; 16]; let mut buf3 = [3; 8]; let mut bufs = &mut [ IoSlice::new(&mut buf1), IoSlice::new(&mut buf2), IoSlice::new(&mut buf3), ][..]; // Mark 10 bytes as written. bufs = IoSlice::advance(mem::replace(&mut bufs, &mut []), 10); assert_eq!(bufs[0].deref(), [2; 14].as_ref()); assert_eq!(bufs[1].deref(), [3; 8].as_ref());Run
Methods from Deref<Target = [u8]>
pub const fn len(&self) -> usize
1.0.0[src]
pub const fn is_empty(&self) -> bool
1.0.0[src]
pub fn first(&self) -> Option<&T>
1.0.0[src]
Returns the first element of the slice, or None
if it is empty.
Examples
let v = [10, 40, 30]; assert_eq!(Some(&10), v.first()); let w: &[i32] = &[]; assert_eq!(None, w.first());Run
pub fn split_first(&self) -> Option<(&T, &[T])>
1.5.0[src]
Returns the first and all the rest of the elements of the slice, or None
if it is empty.
Examples
let x = &[0, 1, 2]; if let Some((first, elements)) = x.split_first() { assert_eq!(first, &0); assert_eq!(elements, &[1, 2]); }Run
pub fn split_last(&self) -> Option<(&T, &[T])>
1.5.0[src]
Returns the last and all the rest of the elements of the slice, or None
if it is empty.
Examples
let x = &[0, 1, 2]; if let Some((last, elements)) = x.split_last() { assert_eq!(last, &2); assert_eq!(elements, &[0, 1]); }Run
pub fn last(&self) -> Option<&T>
1.0.0[src]
Returns the last element of the slice, or None
if it is empty.
Examples
let v = [10, 40, 30]; assert_eq!(Some(&30), v.last()); let w: &[i32] = &[]; assert_eq!(None, w.last());Run
pub fn get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output> where
I: SliceIndex<[T]>,
1.0.0[src]
I: SliceIndex<[T]>,
Returns a reference to an element or subslice depending on the type of index.
- If given a position, returns a reference to the element at that
position or
None
if out of bounds. - If given a range, returns the subslice corresponding to that range,
or
None
if out of bounds.
Examples
let v = [10, 40, 30]; assert_eq!(Some(&40), v.get(1)); assert_eq!(Some(&[10, 40][..]), v.get(0..2)); assert_eq!(None, v.get(3)); assert_eq!(None, v.get(0..4));Run
pub unsafe fn get_unchecked<I>(
&self,
index: I
) -> &<I as SliceIndex<[T]>>::Output where
I: SliceIndex<[T]>,
1.0.0[src]
&self,
index: I
) -> &<I as SliceIndex<[T]>>::Output where
I: SliceIndex<[T]>,
Returns a reference to an element or subslice, without doing bounds checking.
This is generally not recommended, use with caution!
Calling this method with an out-of-bounds index is undefined behavior
even if the resulting reference is not used.
For a safe alternative see get
.
Examples
let x = &[1, 2, 4]; unsafe { assert_eq!(x.get_unchecked(1), &2); }Run
pub const fn as_ptr(&self) -> *const T
1.0.0[src]
Returns a raw pointer to the slice's buffer.
The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage.
The caller must also ensure that the memory the pointer (non-transitively) points to
is never written to (except inside an UnsafeCell
) using this pointer or any pointer
derived from it. If you need to mutate the contents of the slice, use as_mut_ptr
.
Modifying the container referenced by this slice may cause its buffer to be reallocated, which would also make any pointers to it invalid.
Examples
let x = &[1, 2, 4]; let x_ptr = x.as_ptr(); unsafe { for i in 0..x.len() { assert_eq!(x.get_unchecked(i), &*x_ptr.add(i)); } }Run
ⓘImportant traits for Iter<'a, T>pub fn iter(&self) -> Iter<T>
1.0.0[src]
Returns an iterator over the slice.
Examples
let x = &[1, 2, 4]; let mut iterator = x.iter(); assert_eq!(iterator.next(), Some(&1)); assert_eq!(iterator.next(), Some(&2)); assert_eq!(iterator.next(), Some(&4)); assert_eq!(iterator.next(), None);Run
ⓘImportant traits for Windows<'a, T>pub fn windows(&self, size: usize) -> Windows<T>
1.0.0[src]
Returns an iterator over all contiguous windows of length
size
. The windows overlap. If the slice is shorter than
size
, the iterator returns no values.
Panics
Panics if size
is 0.
Examples
let slice = ['r', 'u', 's', 't']; let mut iter = slice.windows(2); assert_eq!(iter.next().unwrap(), &['r', 'u']); assert_eq!(iter.next().unwrap(), &['u', 's']); assert_eq!(iter.next().unwrap(), &['s', 't']); assert!(iter.next().is_none());Run
If the slice is shorter than size
:
let slice = ['f', 'o', 'o']; let mut iter = slice.windows(4); assert!(iter.next().is_none());Run
ⓘImportant traits for Chunks<'a, T>pub fn chunks(&self, chunk_size: usize) -> Chunks<T>
1.0.0[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the
beginning of the slice.
The chunks are slices and do not overlap. If chunk_size
does not divide the length of the
slice, then the last chunk will not have length chunk_size
.
See chunks_exact
for a variant of this iterator that returns chunks of always exactly
chunk_size
elements, and rchunks
for the same iterator but starting at the end of the
slice.
Panics
Panics if chunk_size
is 0.
Examples
let slice = ['l', 'o', 'r', 'e', 'm']; let mut iter = slice.chunks(2); assert_eq!(iter.next().unwrap(), &['l', 'o']); assert_eq!(iter.next().unwrap(), &['r', 'e']); assert_eq!(iter.next().unwrap(), &['m']); assert!(iter.next().is_none());Run
ⓘImportant traits for ChunksExact<'a, T>pub fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<T>
1.31.0[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the
beginning of the slice.
The chunks are slices and do not overlap. If chunk_size
does not divide the length of the
slice, then the last up to chunk_size-1
elements will be omitted and can be retrieved
from the remainder
function of the iterator.
Due to each chunk having exactly chunk_size
elements, the compiler can often optimize the
resulting code better than in the case of chunks
.
See chunks
for a variant of this iterator that also returns the remainder as a smaller
chunk, and rchunks_exact
for the same iterator but starting at the end of the slice.
Panics
Panics if chunk_size
is 0.
Examples
let slice = ['l', 'o', 'r', 'e', 'm']; let mut iter = slice.chunks_exact(2); assert_eq!(iter.next().unwrap(), &['l', 'o']); assert_eq!(iter.next().unwrap(), &['r', 'e']); assert!(iter.next().is_none()); assert_eq!(iter.remainder(), &['m']);Run
ⓘImportant traits for RChunks<'a, T>pub fn rchunks(&self, chunk_size: usize) -> RChunks<T>
1.31.0[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the end
of the slice.
The chunks are slices and do not overlap. If chunk_size
does not divide the length of the
slice, then the last chunk will not have length chunk_size
.
See rchunks_exact
for a variant of this iterator that returns chunks of always exactly
chunk_size
elements, and chunks
for the same iterator but starting at the beginning
of the slice.
Panics
Panics if chunk_size
is 0.
Examples
let slice = ['l', 'o', 'r', 'e', 'm']; let mut iter = slice.rchunks(2); assert_eq!(iter.next().unwrap(), &['e', 'm']); assert_eq!(iter.next().unwrap(), &['o', 'r']); assert_eq!(iter.next().unwrap(), &['l']); assert!(iter.next().is_none());Run
ⓘImportant traits for RChunksExact<'a, T>pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<T>
1.31.0[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the
end of the slice.
The chunks are slices and do not overlap. If chunk_size
does not divide the length of the
slice, then the last up to chunk_size-1
elements will be omitted and can be retrieved
from the remainder
function of the iterator.
Due to each chunk having exactly chunk_size
elements, the compiler can often optimize the
resulting code better than in the case of chunks
.
See rchunks
for a variant of this iterator that also returns the remainder as a smaller
chunk, and chunks_exact
for the same iterator but starting at the beginning of the
slice.
Panics
Panics if chunk_size
is 0.
Examples
let slice = ['l', 'o', 'r', 'e', 'm']; let mut iter = slice.rchunks_exact(2); assert_eq!(iter.next().unwrap(), &['e', 'm']); assert_eq!(iter.next().unwrap(), &['o', 'r']); assert!(iter.next().is_none()); assert_eq!(iter.remainder(), &['l']);Run
pub fn split_at(&self, mid: usize) -> (&[T], &[T])
1.0.0[src]
Divides one slice into two at an index.
The first will contain all indices from [0, mid)
(excluding
the index mid
itself) and the second will contain all
indices from [mid, len)
(excluding the index len
itself).
Panics
Panics if mid > len
.
Examples
let v = [1, 2, 3, 4, 5, 6]; { let (left, right) = v.split_at(0); assert!(left == []); assert!(right == [1, 2, 3, 4, 5, 6]); } { let (left, right) = v.split_at(2); assert!(left == [1, 2]); assert!(right == [3, 4, 5, 6]); } { let (left, right) = v.split_at(6); assert!(left == [1, 2, 3, 4, 5, 6]); assert!(right == []); }Run
ⓘImportant traits for Split<'a, T, P>pub fn split<F>(&self, pred: F) -> Split<T, F> where
F: FnMut(&T) -> bool,
1.0.0[src]
F: FnMut(&T) -> bool,
Returns an iterator over subslices separated by elements that match
pred
. The matched element is not contained in the subslices.
Examples
let slice = [10, 40, 33, 20]; let mut iter = slice.split(|num| num % 3 == 0); assert_eq!(iter.next().unwrap(), &[10, 40]); assert_eq!(iter.next().unwrap(), &[20]); assert!(iter.next().is_none());Run
If the first element is matched, an empty slice will be the first item returned by the iterator. Similarly, if the last element in the slice is matched, an empty slice will be the last item returned by the iterator:
let slice = [10, 40, 33]; let mut iter = slice.split(|num| num % 3 == 0); assert_eq!(iter.next().unwrap(), &[10, 40]); assert_eq!(iter.next().unwrap(), &[]); assert!(iter.next().is_none());Run
If two matched elements are directly adjacent, an empty slice will be present between them:
let slice = [10, 6, 33, 20]; let mut iter = slice.split(|num| num % 3 == 0); assert_eq!(iter.next().unwrap(), &[10]); assert_eq!(iter.next().unwrap(), &[]); assert_eq!(iter.next().unwrap(), &[20]); assert!(iter.next().is_none());Run
ⓘImportant traits for RSplit<'a, T, P>pub fn rsplit<F>(&self, pred: F) -> RSplit<T, F> where
F: FnMut(&T) -> bool,
1.27.0[src]
F: FnMut(&T) -> bool,
Returns an iterator over subslices separated by elements that match
pred
, starting at the end of the slice and working backwards.
The matched element is not contained in the subslices.
Examples
let slice = [11, 22, 33, 0, 44, 55]; let mut iter = slice.rsplit(|num| *num == 0); assert_eq!(iter.next().unwrap(), &[44, 55]); assert_eq!(iter.next().unwrap(), &[11, 22, 33]); assert_eq!(iter.next(), None);Run
As with split()
, if the first or last element is matched, an empty
slice will be the first (or last) item returned by the iterator.
let v = &[0, 1, 1, 2, 3, 5, 8]; let mut it = v.rsplit(|n| *n % 2 == 0); assert_eq!(it.next().unwrap(), &[]); assert_eq!(it.next().unwrap(), &[3, 5]); assert_eq!(it.next().unwrap(), &[1, 1]); assert_eq!(it.next().unwrap(), &[]); assert_eq!(it.next(), None);Run
ⓘImportant traits for SplitN<'a, T, P>pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F> where
F: FnMut(&T) -> bool,
1.0.0[src]
F: FnMut(&T) -> bool,
Returns an iterator over subslices separated by elements that match
pred
, limited to returning at most n
items. The matched element is
not contained in the subslices.
The last element returned, if any, will contain the remainder of the slice.
Examples
Print the slice split once by numbers divisible by 3 (i.e., [10, 40]
,
[20, 60, 50]
):
let v = [10, 40, 30, 20, 60, 50]; for group in v.splitn(2, |num| *num % 3 == 0) { println!("{:?}", group); }Run
ⓘImportant traits for RSplitN<'a, T, P>pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F> where
F: FnMut(&T) -> bool,
1.0.0[src]
F: FnMut(&T) -> bool,
Returns an iterator over subslices separated by elements that match
pred
limited to returning at most n
items. This starts at the end of
the slice and works backwards. The matched element is not contained in
the subslices.
The last element returned, if any, will contain the remainder of the slice.
Examples
Print the slice split once, starting from the end, by numbers divisible
by 3 (i.e., [50]
, [10, 40, 30, 20]
):
let v = [10, 40, 30, 20, 60, 50]; for group in v.rsplitn(2, |num| *num % 3 == 0) { println!("{:?}", group); }Run
pub fn contains(&self, x: &T) -> bool where
T: PartialEq<T>,
1.0.0[src]
T: PartialEq<T>,
Returns true
if the slice contains an element with the given value.
Examples
let v = [10, 40, 30]; assert!(v.contains(&30)); assert!(!v.contains(&50));Run
If you do not have an &T
, but just an &U
such that T: Borrow<U>
(e.g. String: Borrow<str>
), you can use iter().any
:
let v = [String::from("hello"), String::from("world")]; // slice of `String` assert!(v.iter().any(|e| e == "hello")); // search with `&str` assert!(!v.iter().any(|e| e == "hi"));Run
pub fn starts_with(&self, needle: &[T]) -> bool where
T: PartialEq<T>,
1.0.0[src]
T: PartialEq<T>,
Returns true
if needle
is a prefix of the slice.
Examples
let v = [10, 40, 30]; assert!(v.starts_with(&[10])); assert!(v.starts_with(&[10, 40])); assert!(!v.starts_with(&[50])); assert!(!v.starts_with(&[10, 50]));Run
Always returns true
if needle
is an empty slice:
let v = &[10, 40, 30]; assert!(v.starts_with(&[])); let v: &[u8] = &[]; assert!(v.starts_with(&[]));Run
pub fn ends_with(&self, needle: &[T]) -> bool where
T: PartialEq<T>,
1.0.0[src]
T: PartialEq<T>,
Returns true
if needle
is a suffix of the slice.
Examples
let v = [10, 40, 30]; assert!(v.ends_with(&[30])); assert!(v.ends_with(&[40, 30])); assert!(!v.ends_with(&[50])); assert!(!v.ends_with(&[50, 30]));Run
Always returns true
if needle
is an empty slice:
let v = &[10, 40, 30]; assert!(v.ends_with(&[])); let v: &[u8] = &[]; assert!(v.ends_with(&[]));Run
pub fn binary_search(&self, x: &T) -> Result<usize, usize> where
T: Ord,
1.0.0[src]
T: Ord,
Binary searches this sorted slice for a given element.
If the value is found then Result::Ok
is returned, containing the
index of the matching element. If there are multiple matches, then any
one of the matches could be returned. If the value is not found then
Result::Err
is returned, containing the index where a matching
element could be inserted while maintaining sorted order.
Examples
Looks up a series of four elements. The first is found, with a
uniquely determined position; the second and third are not
found; the fourth could match any position in [1, 4]
.
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; assert_eq!(s.binary_search(&13), Ok(9)); assert_eq!(s.binary_search(&4), Err(7)); assert_eq!(s.binary_search(&100), Err(13)); let r = s.binary_search(&1); assert!(match r { Ok(1..=4) => true, _ => false, });Run
If you want to insert an item to a sorted vector, while maintaining sort order:
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; let num = 42; let idx = s.binary_search(&num).unwrap_or_else(|x| x); s.insert(idx, num); assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);Run
pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize> where
F: FnMut(&'a T) -> Ordering,
1.0.0[src]
F: FnMut(&'a T) -> Ordering,
Binary searches this sorted slice with a comparator function.
The comparator function should implement an order consistent
with the sort order of the underlying slice, returning an
order code that indicates whether its argument is Less
,
Equal
or Greater
the desired target.
If the value is found then Result::Ok
is returned, containing the
index of the matching element. If there are multiple matches, then any
one of the matches could be returned. If the value is not found then
Result::Err
is returned, containing the index where a matching
element could be inserted while maintaining sorted order.
Examples
Looks up a series of four elements. The first is found, with a
uniquely determined position; the second and third are not
found; the fourth could match any position in [1, 4]
.
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; let seek = 13; assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9)); let seek = 4; assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7)); let seek = 100; assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13)); let seek = 1; let r = s.binary_search_by(|probe| probe.cmp(&seek)); assert!(match r { Ok(1..=4) => true, _ => false, });Run
pub fn binary_search_by_key<'a, B, F>(
&'a self,
b: &B,
f: F
) -> Result<usize, usize> where
B: Ord,
F: FnMut(&'a T) -> B,
1.10.0[src]
&'a self,
b: &B,
f: F
) -> Result<usize, usize> where
B: Ord,
F: FnMut(&'a T) -> B,
Binary searches this sorted slice with a key extraction function.
Assumes that the slice is sorted by the key, for instance with
sort_by_key
using the same key extraction function.
If the value is found then Result::Ok
is returned, containing the
index of the matching element. If there are multiple matches, then any
one of the matches could be returned. If the value is not found then
Result::Err
is returned, containing the index where a matching
element could be inserted while maintaining sorted order.
Examples
Looks up a series of four elements in a slice of pairs sorted by
their second elements. The first is found, with a uniquely
determined position; the second and third are not found; the
fourth could match any position in [1, 4]
.
let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1), (1, 2), (2, 3), (4, 5), (5, 8), (3, 13), (1, 21), (2, 34), (4, 55)]; assert_eq!(s.binary_search_by_key(&13, |&(a,b)| b), Ok(9)); assert_eq!(s.binary_search_by_key(&4, |&(a,b)| b), Err(7)); assert_eq!(s.binary_search_by_key(&100, |&(a,b)| b), Err(13)); let r = s.binary_search_by_key(&1, |&(a,b)| b); assert!(match r { Ok(1..=4) => true, _ => false, });Run
pub unsafe fn align_to<U>(&self) -> (&[T], &[U], &[T])
1.30.0[src]
Transmute the slice to a slice of another type, ensuring alignment of the types is maintained.
This method splits the slice into three distinct slices: prefix, correctly aligned middle slice of a new type, and the suffix slice. The method may make the middle slice the greatest length possible for a given type and input slice, but only your algorithm's performance should depend on that, not its correctness. It is permissible for all of the input data to be returned as the prefix or suffix slice.
This method has no purpose when either input element T
or output element U
are
zero-sized and will return the original slice without splitting anything.
Safety
This method is essentially a transmute
with respect to the elements in the returned
middle slice, so all the usual caveats pertaining to transmute::<T, U>
also apply here.
Examples
Basic usage:
unsafe { let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7]; let (prefix, shorts, suffix) = bytes.align_to::<u16>(); // less_efficient_algorithm_for_bytes(prefix); // more_efficient_algorithm_for_aligned_shorts(shorts); // less_efficient_algorithm_for_bytes(suffix); }Run
pub fn is_sorted(&self) -> bool where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
🔬 This is a nightly-only experimental API. (is_sorted
#53485)
new API
Checks if the elements of this slice are sorted.
That is, for each element a
and its following element b
, a <= b
must hold. If the
slice yields exactly zero or one element, true
is returned.
Note that if Self::Item
is only PartialOrd
, but not Ord
, the above definition
implies that this function returns false
if any two consecutive items are not
comparable.
Examples
#![feature(is_sorted)] let empty: [i32; 0] = []; assert!([1, 2, 2, 9].is_sorted()); assert!(![1, 3, 2, 4].is_sorted()); assert!([0].is_sorted()); assert!(empty.is_sorted()); assert!(![0.0, 1.0, std::f32::NAN].is_sorted());Run
pub fn is_sorted_by<F>(&self, compare: F) -> bool where
F: FnMut(&T, &T) -> Option<Ordering>,
[src]
F: FnMut(&T, &T) -> Option<Ordering>,
🔬 This is a nightly-only experimental API. (is_sorted
#53485)
new API
Checks if the elements of this slice are sorted using the given comparator function.
Instead of using PartialOrd::partial_cmp
, this function uses the given compare
function to determine the ordering of two elements. Apart from that, it's equivalent to
is_sorted
; see its documentation for more information.
pub fn is_sorted_by_key<F, K>(&self, f: F) -> bool where
F: FnMut(&T) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(&T) -> K,
K: PartialOrd<K>,
🔬 This is a nightly-only experimental API. (is_sorted
#53485)
new API
Checks if the elements of this slice are sorted using the given key extraction function.
Instead of comparing the slice's elements directly, this function compares the keys of the
elements, as determined by f
. Apart from that, it's equivalent to is_sorted
; see its
documentation for more information.
Examples
#![feature(is_sorted)] assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len())); assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));Run
pub fn is_ascii(&self) -> bool
1.23.0[src]
Checks if all bytes in this slice are within the ASCII range.
pub fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool
1.23.0[src]
Checks that two slices are an ASCII case-insensitive match.
Same as to_ascii_lowercase(a) == to_ascii_lowercase(b)
,
but without allocating and copying temporaries.
pub fn to_vec(&self) -> Vec<T> where
T: Clone,
1.0.0[src]
T: Clone,
Copies self
into a new Vec
.
Examples
let s = [10, 40, 30]; let x = s.to_vec(); // Here, `s` and `x` can be modified independently.Run
pub fn repeat(&self, n: usize) -> Vec<T> where
T: Copy,
[src]
T: Copy,
🔬 This is a nightly-only experimental API. (repeat_generic_slice
#48784)
it's on str, why not on slice?
Creates a vector by repeating a slice n
times.
Panics
This function will panic if the capacity would overflow.
Examples
Basic usage:
#![feature(repeat_generic_slice)] fn main() { assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]); }Run
A panic upon overflow:
#![feature(repeat_generic_slice)] fn main() { // this will panic at runtime b"0123456789abcdef".repeat(usize::max_value()); }Run
pub fn concat<Item>(&self) -> <[T] as Concat<Item>>::Output where
Item: ?Sized,
[T]: Concat<Item>,
1.0.0[src]
Item: ?Sized,
[T]: Concat<Item>,
Flattens a slice of T
into a single value Self::Output
.
Examples
assert_eq!(["hello", "world"].concat(), "helloworld"); assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);Run
pub fn join<Separator>(
&self,
sep: Separator
) -> <[T] as Join<Separator>>::Output where
[T]: Join<Separator>,
1.3.0[src]
&self,
sep: Separator
) -> <[T] as Join<Separator>>::Output where
[T]: Join<Separator>,
Flattens a slice of T
into a single value Self::Output
, placing a
given separator between each.
Examples
assert_eq!(["hello", "world"].join(" "), "hello world"); assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]); assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 0, 3, 4]);Run
pub fn connect<Separator>(
&self,
sep: Separator
) -> <[T] as Join<Separator>>::Output where
[T]: Join<Separator>,
1.0.0[src]
&self,
sep: Separator
) -> <[T] as Join<Separator>>::Output where
[T]: Join<Separator>,
renamed to join
pub fn to_ascii_uppercase(&self) -> Vec<u8>
1.23.0[src]
Returns a vector containing a copy of this slice where each byte is mapped to its ASCII upper case equivalent.
ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', but non-ASCII letters are unchanged.
To uppercase the value in-place, use make_ascii_uppercase
.
pub fn to_ascii_lowercase(&self) -> Vec<u8>
1.23.0[src]
Returns a vector containing a copy of this slice where each byte is mapped to its ASCII lower case equivalent.
ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', but non-ASCII letters are unchanged.
To lowercase the value in-place, use make_ascii_lowercase
.
Trait Implementations
impl<'a> Deref for IoSlice<'a>
[src]
impl<'a> Debug for IoSlice<'a>
[src]
Auto Trait Implementations
impl<'a> UnwindSafe for IoSlice<'a>
impl<'a> RefUnwindSafe for IoSlice<'a>
impl<'a> Unpin for IoSlice<'a>
impl<'a> !Send for IoSlice<'a>
impl<'a> !Sync for IoSlice<'a>
Blanket Implementations
impl<T> From<T> for T
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
ⓘImportant traits for &'_ mut Ffn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,