pub struct ArgsOs { /* fields omitted */ }
An iterator over the arguments of a process, yielding an OsString
value for each argument.
This struct is created by the std::env::args_os
function. See its documentation for more.
The first element is traditionally the path of the executable, but it can be set to arbitrary text, and may not even exist. This means this property should not be relied upon for security purposes.
impl Debug for ArgsOs
[src]1.16.0
impl DoubleEndedIterator for ArgsOs
[src]1.12.0
fn next_back(&mut self) -> Option<OsString>
[src]
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
[src]1.37.0
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
[src]1.27.0
fn rfold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
[src]1.27.0
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
[src]1.27.0
impl ExactSizeIterator for ArgsOs
[src]
impl Iterator for ArgsOs
[src]
type Item = OsString
The type of the elements being iterated over.
fn next(&mut self) -> Option<OsString>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
[src]
fn count(self) -> usize
[src]
fn last(self) -> Option<Self::Item>
[src]
fn nth(&mut self, n: usize) -> Option<Self::Item>
[src]
fn step_by(self, step: usize) -> StepBy<Self>ⓘNotable traits for StepBy<I>
impl<I> Iterator for StepBy<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]1.28.0
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Chain<A, B>
impl<A, B> Iterator for Chain<A, B> where
A: Iterator,
B: Iterator<Item = <A as Iterator>::Item>,
type Item = <A as Iterator>::Item;
where
U: IntoIterator<Item = Self::Item>,
[src]
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Zip<A, B>
impl<A, B> Iterator for Zip<A, B> where
A: Iterator,
B: Iterator,
type Item = (<A as Iterator>::Item, <B as Iterator>::Item);
where
U: IntoIterator,
[src]
fn map<B, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
F: FnMut(<I as Iterator>::Item) -> B,
I: Iterator,
type Item = B;
where
F: FnMut(Self::Item) -> B,
[src]
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
[src]1.21.0
fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘNotable traits for Filter<I, P>
impl<I, P> Iterator for Filter<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool,
type Item = <I as Iterator>::Item;
where
P: FnMut(&Self::Item) -> bool,
[src]
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘNotable traits for FilterMap<I, F>
impl<B, I, F> Iterator for FilterMap<I, F> where
F: FnMut(<I as Iterator>::Item) -> Option<B>,
I: Iterator,
type Item = B;
where
F: FnMut(Self::Item) -> Option<B>,
[src]
fn enumerate(self) -> Enumerate<Self>ⓘNotable traits for Enumerate<I>
impl<I> Iterator for Enumerate<I> where
I: Iterator,
type Item = (usize, <I as Iterator>::Item);
[src]
fn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I>
impl<I> Iterator for Peekable<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘNotable traits for SkipWhile<I, P>
impl<I, P> Iterator for SkipWhile<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool,
type Item = <I as Iterator>::Item;
where
P: FnMut(&Self::Item) -> bool,
[src]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘNotable traits for TakeWhile<I, P>
impl<I, P> Iterator for TakeWhile<I, P> where
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool,
type Item = <I as Iterator>::Item;
where
P: FnMut(&Self::Item) -> bool,
[src]
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘNotable traits for MapWhile<I, P>
impl<B, I, P> Iterator for MapWhile<I, P> where
I: Iterator,
P: FnMut(<I as Iterator>::Item) -> Option<B>,
type Item = B;
where
P: FnMut(Self::Item) -> Option<B>,
[src]
fn skip(self, n: usize) -> Skip<Self>ⓘNotable traits for Skip<I>
impl<I> Iterator for Skip<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn take(self, n: usize) -> Take<Self>ⓘNotable traits for Take<I>
impl<I> Iterator for Take<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>ⓘNotable traits for Scan<I, St, F>
impl<B, I, St, F> Iterator for Scan<I, St, F> where
F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>,
I: Iterator,
type Item = B;
where
F: FnMut(&mut St, Self::Item) -> Option<B>,
[src]
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>ⓘNotable traits for FlatMap<I, U, F>
impl<I, U, F> Iterator for FlatMap<I, U, F> where
F: FnMut(<I as Iterator>::Item) -> U,
I: Iterator,
U: IntoIterator,
type Item = <U as IntoIterator>::Item;
where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
[src]
fn flatten(self) -> Flatten<Self>ⓘNotable traits for Flatten<I>
impl<I, U> Iterator for Flatten<I> where
I: Iterator,
U: Iterator,
<I as Iterator>::Item: IntoIterator,
<<I as Iterator>::Item as IntoIterator>::IntoIter == U,
<<I as Iterator>::Item as IntoIterator>::Item == <U as Iterator>::Item,
type Item = <U as Iterator>::Item;
where
Self::Item: IntoIterator,
[src]1.29.0
fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<I>
impl<I> Iterator for Fuse<I> where
I: Iterator,
type Item = <I as Iterator>::Item;
[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F>
impl<I, F> Iterator for Inspect<I, F> where
F: FnMut(&<I as Iterator>::Item),
I: Iterator,
type Item = <I as Iterator>::Item;
where
F: FnMut(&Self::Item),
[src]
fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
#[must_use =
"if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
[src]
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
[src]
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
[src]
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
[src]1.27.0
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
[src]1.27.0
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
[src]
fn fold_first<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
[src]
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
[src]1.30.0
fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
[src]
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
[src]
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
[src]
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
[src]1.6.0
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]1.15.0
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B,
[src]1.6.0
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
[src]1.15.0
fn rev(self) -> Rev<Self>ⓘNotable traits for Rev<I>
impl<I> Iterator for Rev<I> where
I: DoubleEndedIterator,
type Item = <I as Iterator>::Item;
where
Self: DoubleEndedIterator,
[src]
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
[src]
fn copied<'a, T>(self) -> Copied<Self>ⓘNotable traits for Copied<I>
impl<'a, I, T> Iterator for Copied<I> where
I: Iterator<Item = &'a T>,
T: 'a + Copy,
type Item = T;
where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
[src]1.36.0
fn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I>
impl<'a, I, T> Iterator for Cloned<I> where
I: Iterator<Item = &'a T>,
T: 'a + Clone,
type Item = T;
where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
[src]
fn cycle(self) -> Cycle<Self>ⓘNotable traits for Cycle<I>
impl<I> Iterator for Cycle<I> where
I: Clone + Iterator,
type Item = <I as Iterator>::Item;
where
Self: Clone,
[src]
fn sum<S>(self) -> S where
S: Sum<Self::Item>,
[src]1.11.0
fn product<P>(self) -> P where
P: Product<Self::Item>,
[src]1.11.0
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
[src]1.5.0
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
[src]
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
[src]1.5.0
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
[src]
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
[src]1.5.0
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
[src]
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
[src]1.5.0
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
[src]1.5.0
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
[src]1.5.0
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
[src]1.5.0
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
[src]1.5.0
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
[src]
impl !Send for ArgsOs
[src]1.26.0
impl !Sync for ArgsOs
[src]1.26.0
impl<T> Any for T where
T: 'static + ?Sized,
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
fn borrow(&self) -> &TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
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> TryInto<U> for T where
U: TryFrom<T>,
[src]
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/env/struct.ArgsOs.html