fn as_mut(&mut self) -> &mut [Target]

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut<[Target]>","hir_ty::lower::path::CallbackData"],["

impl<L, R> AsMut<CStr> for Either<L, R>
where\n L: AsMut<CStr>,\n R: AsMut<CStr>,

Available on crate feature std only.

Requires crate feature std.

fn as_mut(&mut self) -> &mut CStr

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut","hir_ty::lower::path::CallbackData"],["

impl<L, R> AsMut<OsStr> for Either<L, R>
where\n L: AsMut<OsStr>,\n R: AsMut<OsStr>,

Available on crate feature std only.

Requires crate feature std.

fn as_mut(&mut self) -> &mut OsStr

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut","hir_ty::lower::path::CallbackData"],["

impl<L, R> AsMut<Path> for Either<L, R>
where\n L: AsMut<Path>,\n R: AsMut<Path>,

Available on crate feature std only.

Requires crate feature std.

fn as_mut(&mut self) -> &mut Path

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut","hir_ty::lower::path::CallbackData"],["

impl<L, R, Target> AsMut<Target> for Either<L, R>
where\n L: AsMut<Target>,\n R: AsMut<Target>,

fn as_mut(&mut self) -> &mut Target

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut","hir_ty::lower::path::CallbackData"],["

impl<L, R> AsMut<str> for Either<L, R>
where\n L: AsMut<str>,\n R: AsMut<str>,

fn as_mut(&mut self) -> &mut str

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut","hir_ty::lower::path::CallbackData"],["

impl<L, R, Target> AsRef<[Target]> for Either<L, R>
where\n L: AsRef<[Target]>,\n R: AsRef<[Target]>,

fn as_ref(&self) -> &[Target]

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef<[Target]>","hir_ty::lower::path::CallbackData"],["

impl<L, R> AsRef<CStr> for Either<L, R>
where\n L: AsRef<CStr>,\n R: AsRef<CStr>,

Available on crate feature std only.

Requires crate feature std.

fn as_ref(&self) -> &CStr

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef","hir_ty::lower::path::CallbackData"],["

impl<L, R> AsRef<OsStr> for Either<L, R>
where\n L: AsRef<OsStr>,\n R: AsRef<OsStr>,

Available on crate feature std only.

Requires crate feature std.

fn as_ref(&self) -> &OsStr

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef","hir_ty::lower::path::CallbackData"],["

impl<L, R> AsRef<Path> for Either<L, R>
where\n L: AsRef<Path>,\n R: AsRef<Path>,

Available on crate feature std only.

Requires crate feature std.

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef","hir_ty::lower::path::CallbackData"],["

impl<L, R, Target> AsRef<Target> for Either<L, R>
where\n L: AsRef<Target>,\n R: AsRef<Target>,

fn as_ref(&self) -> &Target

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef","hir_ty::lower::path::CallbackData"],["

impl<L, R> AsRef<str> for Either<L, R>
where\n L: AsRef<str>,\n R: AsRef<str>,

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef","hir_ty::lower::path::CallbackData"],["

impl<L, R> AstNode for Either<L, R>
where\n L: AstNode,\n R: AstNode,

fn can_cast(kind: SyntaxKind) -> bool
where\n Either<L, R>: Sized,

fn cast(syntax: SyntaxNode<RustLanguage>) -> Option<Either<L, R>>
where\n Either<L, R>: Sized,

fn syntax(&self) -> &SyntaxNode<RustLanguage>

fn kind() -> SyntaxKind
where\n Self: Sized,

This panics if the SyntaxKind is not statically known.

fn clone_for_update(&self) -> Self
where\n Self: Sized,

fn clone_subtree(&self) -> Self
where\n Self: Sized,

","AstNode","hir_ty::lower::path::CallbackData"],["

impl<L, R> BufRead for Either<L, R>
where\n L: BufRead,\n R: BufRead,

Available on crate features std only.

Requires crate feature \"std\"

fn fill_buf(&mut self) -> Result<&[u8], Error>

Returns the contents of the internal buffer, filling it with more data, via Read methods, if empty. Read more

fn consume(&mut self, amt: usize)

Marks the given amount of additional bytes from the internal buffer as having been read.\nSubsequent calls to read only return bytes that have not been marked as read. Read more

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes into buf until the delimiter byte or EOF is reached. Read more

fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until a newline (the 0xA byte) is reached, and append\nthem to the provided String buffer. Read more

fn has_data_left(&mut self) -> Result<bool, Error>

🔬This is a nightly-only experimental API. (buf_read_has_data_left)

Checks if there is any data left to be read. Read more

1.83.0 · Source§

fn skip_until(&mut self, byte: u8) -> Result<usize, Error>

Skips all bytes until the delimiter byte or EOF is reached. Read more

1.0.0 · Source§

fn split(self, byte: u8) -> Split<Self>
where\n Self: Sized,

Returns an iterator over the contents of this reader split on the byte\nbyte. Read more

1.0.0 · Source§

fn lines(self) -> Lines<Self>
where\n Self: Sized,

Returns an iterator over the lines of this reader. Read more

","BufRead","hir_ty::lower::path::CallbackData"],["

impl<L, R> Clone for Either<L, R>
where\n L: Clone,\n R: Clone,

fn clone(&self) -> Either<L, R> ⓘ

Returns a duplicate of the value. Read more

fn clone_from(&mut self, source: &Either<L, R>)

Performs copy-assignment from source. Read more

","Clone","hir_ty::lower::path::CallbackData"],["

impl<L, R> Debug for Either<L, R>
where\n L: Debug,\n R: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

","Debug","hir_ty::lower::path::CallbackData"],["

impl<L, R> Deref for Either<L, R>
where\n L: Deref,\n R: Deref<Target = <L as Deref>::Target>,

type Target = <L as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &<Either<L, R> as Deref>::Target ⓘ

Dereferences the value.

","Deref","hir_ty::lower::path::CallbackData"],["

impl<L, R> DerefMut for Either<L, R>
where\n L: DerefMut,\n R: DerefMut<Target = <L as Deref>::Target>,

fn deref_mut(&mut self) -> &mut <Either<L, R> as Deref>::Target ⓘ

Mutably dereferences the value.

","DerefMut","hir_ty::lower::path::CallbackData"],["

impl<L, R> Display for Either<L, R>
where\n L: Display,\n R: Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

","Display","hir_ty::lower::path::CallbackData"],["

impl<L, R> DoubleEndedIterator for Either<L, R>
where\n L: DoubleEndedIterator,\n R: DoubleEndedIterator<Item = <L as Iterator>::Item>,

fn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>

Removes and returns an element from the end of the iterator. Read more

fn nth_back(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>

Returns the nth element from the end of the iterator. Read more

fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc
where\n G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,

An iterator method that reduces the iterator’s elements to a single,\nfinal value, starting from the back. Read more

fn rfind(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>
where\n P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

Searches for an element of an iterator from the back that satisfies a predicate. Read more

fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator from the back by n elements. Read more

1.27.0 · Source§

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
where\n Self: Sized,\n F: FnMut(B, Self::Item) -> R,\n R: Try<Output = B>,

This is the reverse version of Iterator::try_fold(): it takes\nelements starting from the back of the iterator. Read more

","DoubleEndedIterator","hir_ty::lower::path::CallbackData"],["

impl<L, R> Either<L, R>

pub fn is_left(&self) -> bool

Return true if the value is the Left variant.

\n\n

use either::*;\n\nlet values = [Left(1), Right(\"the right value\")];\nassert_eq!(values[0].is_left(), true);\nassert_eq!(values[1].is_left(), false);

pub fn is_right(&self) -> bool

Return true if the value is the Right variant.

\n\n

use either::*;\n\nlet values = [Left(1), Right(\"the right value\")];\nassert_eq!(values[0].is_right(), false);\nassert_eq!(values[1].is_right(), true);

pub fn left(self) -> Option<L>

Convert the left side of Either<L, R> to an Option<L>.

\n\n

use either::*;\n\nlet left: Either<_, ()> = Left(\"some value\");\nassert_eq!(left.left(),  Some(\"some value\"));\n\nlet right: Either<(), _> = Right(321);\nassert_eq!(right.left(), None);

pub fn right(self) -> Option<R>

Convert the right side of Either<L, R> to an Option<R>.

\n\n

use either::*;\n\nlet left: Either<_, ()> = Left(\"some value\");\nassert_eq!(left.right(),  None);\n\nlet right: Either<(), _> = Right(321);\nassert_eq!(right.right(), Some(321));

pub fn as_ref(&self) -> Either<&L, &R> ⓘ

Convert &Either<L, R> to Either<&L, &R>.

\n\n

use either::*;\n\nlet left: Either<_, ()> = Left(\"some value\");\nassert_eq!(left.as_ref(), Left(&\"some value\"));\n\nlet right: Either<(), _> = Right(\"some value\");\nassert_eq!(right.as_ref(), Right(&\"some value\"));

pub fn as_mut(&mut self) -> Either<&mut L, &mut R> ⓘ

Convert &mut Either<L, R> to Either<&mut L, &mut R>.

\n\n

use either::*;\n\nfn mutate_left(value: &mut Either<u32, u32>) {\n    if let Some(l) = value.as_mut().left() {\n        *l = 999;\n    }\n}\n\nlet mut left = Left(123);\nlet mut right = Right(123);\nmutate_left(&mut left);\nmutate_left(&mut right);\nassert_eq!(left, Left(999));\nassert_eq!(right, Right(123));

pub fn as_pin_ref(self: Pin<&Either<L, R>>) -> Either<Pin<&L>, Pin<&R>> ⓘ

Convert Pin<&Either<L, R>> to Either<Pin<&L>, Pin<&R>>,\npinned projections of the inner variants.

pub fn as_pin_mut(\n self: Pin<&mut Either<L, R>>,\n) -> Either<Pin<&mut L>, Pin<&mut R>> ⓘ

Convert Pin<&mut Either<L, R>> to Either<Pin<&mut L>, Pin<&mut R>>,\npinned projections of the inner variants.

pub fn flip(self) -> Either<R, L> ⓘ

Convert Either<L, R> to Either<R, L>.

\n\n

use either::*;\n\nlet left: Either<_, ()> = Left(123);\nassert_eq!(left.flip(), Right(123));\n\nlet right: Either<(), _> = Right(\"some value\");\nassert_eq!(right.flip(), Left(\"some value\"));

pub fn map_left<F, M>(self, f: F) -> Either<M, R> ⓘ
where\n F: FnOnce(L) -> M,

Apply the function f on the value in the Left variant if it is present rewrapping the\nresult in Left.

\n\n

use either::*;\n\nlet left: Either<_, u32> = Left(123);\nassert_eq!(left.map_left(|x| x * 2), Left(246));\n\nlet right: Either<u32, _> = Right(123);\nassert_eq!(right.map_left(|x| x * 2), Right(123));

pub fn map_right<F, S>(self, f: F) -> Either<L, S> ⓘ
where\n F: FnOnce(R) -> S,

Apply the function f on the value in the Right variant if it is present rewrapping the\nresult in Right.

\n\n

use either::*;\n\nlet left: Either<_, u32> = Left(123);\nassert_eq!(left.map_right(|x| x * 2), Left(123));\n\nlet right: Either<u32, _> = Right(123);\nassert_eq!(right.map_right(|x| x * 2), Right(246));

pub fn map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S> ⓘ
where\n F: FnOnce(L) -> M,\n G: FnOnce(R) -> S,

Apply the functions f and g to the Left and Right variants\nrespectively. This is equivalent to\nbimap\nin functional programming.

\n\n

use either::*;\n\nlet f = |s: String| s.len();\nlet g = |u: u8| u.to_string();\n\nlet left: Either<String, u8> = Left(\"loopy\".into());\nassert_eq!(left.map_either(f, g), Left(5));\n\nlet right: Either<String, u8> = Right(42);\nassert_eq!(right.map_either(f, g), Right(\"42\".into()));

pub fn map_either_with<Ctx, F, G, M, S>(\n self,\n ctx: Ctx,\n f: F,\n g: G,\n) -> Either<M, S> ⓘ
where\n F: FnOnce(Ctx, L) -> M,\n G: FnOnce(Ctx, R) -> S,

Similar to map_either, with an added context ctx accessible to\nboth functions.

\n\n

use either::*;\n\nlet mut sum = 0;\n\n// Both closures want to update the same value, so pass it as context.\nlet mut f = |sum: &mut usize, s: String| { *sum += s.len(); s.to_uppercase() };\nlet mut g = |sum: &mut usize, u: usize| { *sum += u; u.to_string() };\n\nlet left: Either<String, usize> = Left(\"loopy\".into());\nassert_eq!(left.map_either_with(&mut sum, &mut f, &mut g), Left(\"LOOPY\".into()));\n\nlet right: Either<String, usize> = Right(42);\nassert_eq!(right.map_either_with(&mut sum, &mut f, &mut g), Right(\"42\".into()));\n\nassert_eq!(sum, 47);

pub fn either<F, G, T>(self, f: F, g: G) -> T
where\n F: FnOnce(L) -> T,\n G: FnOnce(R) -> T,

Apply one of two functions depending on contents, unifying their result. If the value is\nLeft(L) then the first function f is applied; if it is Right(R) then the second\nfunction g is applied.

\n\n

use either::*;\n\nfn square(n: u32) -> i32 { (n * n) as i32 }\nfn negate(n: i32) -> i32 { -n }\n\nlet left: Either<u32, i32> = Left(4);\nassert_eq!(left.either(square, negate), 16);\n\nlet right: Either<u32, i32> = Right(-4);\nassert_eq!(right.either(square, negate), 4);

pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T
where\n F: FnOnce(Ctx, L) -> T,\n G: FnOnce(Ctx, R) -> T,

Like either, but provide some context to whichever of the\nfunctions ends up being called.

\n\n

// In this example, the context is a mutable reference\nuse either::*;\n\nlet mut result = Vec::new();\n\nlet values = vec![Left(2), Right(2.7)];\n\nfor value in values {\n    value.either_with(&mut result,\n                      |ctx, integer| ctx.push(integer),\n                      |ctx, real| ctx.push(f64::round(real) as i32));\n}\n\nassert_eq!(result, vec![2, 3]);

pub fn left_and_then<F, S>(self, f: F) -> Either<S, R> ⓘ
where\n F: FnOnce(L) -> Either<S, R>,

Apply the function f on the value in the Left variant if it is present.

\n\n

use either::*;\n\nlet left: Either<_, u32> = Left(123);\nassert_eq!(left.left_and_then::<_,()>(|x| Right(x * 2)), Right(246));\n\nlet right: Either<u32, _> = Right(123);\nassert_eq!(right.left_and_then(|x| Right::<(), _>(x * 2)), Right(123));

pub fn right_and_then<F, S>(self, f: F) -> Either<L, S> ⓘ
where\n F: FnOnce(R) -> Either<L, S>,

Apply the function f on the value in the Right variant if it is present.

\n\n

use either::*;\n\nlet left: Either<_, u32> = Left(123);\nassert_eq!(left.right_and_then(|x| Right(x * 2)), Left(123));\n\nlet right: Either<u32, _> = Right(123);\nassert_eq!(right.right_and_then(|x| Right(x * 2)), Right(246));

pub fn into_iter(\n self,\n) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter> ⓘ
where\n L: IntoIterator,\n R: IntoIterator<Item = <L as IntoIterator>::Item>,

Convert the inner value to an iterator.

This requires the Left and Right iterators to have the same item type.\nSee factor_into_iter to iterate different types.

\n\n

use either::*;\n\nlet left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]);\nlet mut right: Either<Vec<u32>, _> = Right(vec![]);\nright.extend(left.into_iter());\nassert_eq!(right, Right(vec![1, 2, 3, 4, 5]));

pub fn iter(\n &self,\n) -> Either<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter> ⓘ
where\n &'a L: for<'a> IntoIterator,\n &'a R: for<'a> IntoIterator<Item = <&'a L as IntoIterator>::Item>,

Borrow the inner value as an iterator.

This requires the Left and Right iterators to have the same item type.\nSee factor_iter to iterate different types.

\n\n

use either::*;\n\nlet left: Either<_, &[u32]> = Left(vec![2, 3]);\nlet mut right: Either<Vec<u32>, _> = Right(&[4, 5][..]);\nlet mut all = vec![1];\nall.extend(left.iter());\nall.extend(right.iter());\nassert_eq!(all, vec![1, 2, 3, 4, 5]);

pub fn iter_mut(\n &mut self,\n) -> Either<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter> ⓘ
where\n &'a mut L: for<'a> IntoIterator,\n &'a mut R: for<'a> IntoIterator<Item = <&'a mut L as IntoIterator>::Item>,

Mutably borrow the inner value as an iterator.

This requires the Left and Right iterators to have the same item type.\nSee factor_iter_mut to iterate different types.

\n\n

use either::*;\n\nlet mut left: Either<_, &mut [u32]> = Left(vec![2, 3]);\nfor l in left.iter_mut() {\n    *l *= *l\n}\nassert_eq!(left, Left(vec![4, 9]));\n\nlet mut inner = [4, 5];\nlet mut right: Either<Vec<u32>, _> = Right(&mut inner[..]);\nfor r in right.iter_mut() {\n    *r *= *r\n}\nassert_eq!(inner, [16, 25]);

pub fn factor_into_iter(\n self,\n) -> IterEither<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>
where\n L: IntoIterator,\n R: IntoIterator,

Converts an Either of Iterators to be an Iterator of Eithers

Unlike into_iter, this does not require the\nLeft and Right iterators to have the same item type.

\n\n

use either::*;\nlet left: Either<_, Vec<u8>> = Left(&[\"hello\"]);\nassert_eq!(left.factor_into_iter().next(), Some(Left(&\"hello\")));\n\nlet right: Either<&[&str], _> = Right(vec![0, 1]);\nassert_eq!(right.factor_into_iter().collect::<Vec<_>>(), vec![Right(0), Right(1)]);\n

pub fn factor_iter(\n &self,\n) -> IterEither<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>
where\n &'a L: for<'a> IntoIterator,\n &'a R: for<'a> IntoIterator,

Borrows an Either of Iterators to be an Iterator of Eithers

Unlike iter, this does not require the\nLeft and Right iterators to have the same item type.

\n\n

use either::*;\nlet left: Either<_, Vec<u8>> = Left([\"hello\"]);\nassert_eq!(left.factor_iter().next(), Some(Left(&\"hello\")));\n\nlet right: Either<[&str; 2], _> = Right(vec![0, 1]);\nassert_eq!(right.factor_iter().collect::<Vec<_>>(), vec![Right(&0), Right(&1)]);\n

pub fn factor_iter_mut(\n &mut self,\n) -> IterEither<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>
where\n &'a mut L: for<'a> IntoIterator,\n &'a mut R: for<'a> IntoIterator,

Mutably borrows an Either of Iterators to be an Iterator of Eithers

Unlike iter_mut, this does not require the\nLeft and Right iterators to have the same item type.

\n\n

use either::*;\nlet mut left: Either<_, Vec<u8>> = Left([\"hello\"]);\nleft.factor_iter_mut().for_each(|x| *x.unwrap_left() = \"goodbye\");\nassert_eq!(left, Left([\"goodbye\"]));\n\nlet mut right: Either<[&str; 2], _> = Right(vec![0, 1, 2]);\nright.factor_iter_mut().for_each(|x| if let Right(r) = x { *r = -*r; });\nassert_eq!(right, Right(vec![0, -1, -2]));\n

pub fn left_or(self, other: L) -> L

Return left value or given value

Arguments passed to left_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use\nleft_or_else, which is lazily evaluated.

§Examples

let left: Either<&str, &str> = Left(\"left\");\nassert_eq!(left.left_or(\"foo\"), \"left\");\n\nlet right: Either<&str, &str> = Right(\"right\");\nassert_eq!(right.left_or(\"left\"), \"left\");

pub fn left_or_default(self) -> L
where\n L: Default,

Return left or a default

§Examples

let left: Either<String, u32> = Left(\"left\".to_string());\nassert_eq!(left.left_or_default(), \"left\");\n\nlet right: Either<String, u32> = Right(42);\nassert_eq!(right.left_or_default(), String::default());

pub fn left_or_else<F>(self, f: F) -> L
where\n F: FnOnce(R) -> L,

Returns left value or computes it from a closure

§Examples

let left: Either<String, u32> = Left(\"3\".to_string());\nassert_eq!(left.left_or_else(|_| unreachable!()), \"3\");\n\nlet right: Either<String, u32> = Right(3);\nassert_eq!(right.left_or_else(|x| x.to_string()), \"3\");

pub fn right_or(self, other: R) -> R

Return right value or given value

Arguments passed to right_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use\nright_or_else, which is lazily evaluated.

§Examples

let right: Either<&str, &str> = Right(\"right\");\nassert_eq!(right.right_or(\"foo\"), \"right\");\n\nlet left: Either<&str, &str> = Left(\"left\");\nassert_eq!(left.right_or(\"right\"), \"right\");

pub fn right_or_default(self) -> R
where\n R: Default,

Return right or a default

§Examples

let left: Either<String, u32> = Left(\"left\".to_string());\nassert_eq!(left.right_or_default(), u32::default());\n\nlet right: Either<String, u32> = Right(42);\nassert_eq!(right.right_or_default(), 42);

pub fn right_or_else<F>(self, f: F) -> R
where\n F: FnOnce(L) -> R,

Returns right value or computes it from a closure

§Examples

let left: Either<String, u32> = Left(\"3\".to_string());\nassert_eq!(left.right_or_else(|x| x.parse().unwrap()), 3);\n\nlet right: Either<String, u32> = Right(3);\nassert_eq!(right.right_or_else(|_| unreachable!()), 3);

pub fn unwrap_left(self) -> L
where\n R: Debug,

Returns the left value

§Examples

let left: Either<_, ()> = Left(3);\nassert_eq!(left.unwrap_left(), 3);

§Panics

When Either is a Right value

\n\n

let right: Either<(), _> = Right(3);\nright.unwrap_left();

pub fn unwrap_right(self) -> R
where\n L: Debug,

Returns the right value

§Examples

let right: Either<(), _> = Right(3);\nassert_eq!(right.unwrap_right(), 3);

§Panics

When Either is a Left value

\n\n

let left: Either<_, ()> = Left(3);\nleft.unwrap_right();

pub fn expect_left(self, msg: &str) -> L
where\n R: Debug,

Returns the left value

§Examples

let left: Either<_, ()> = Left(3);\nassert_eq!(left.expect_left(\"value was Right\"), 3);

§Panics

When Either is a Right value

\n\n

let right: Either<(), _> = Right(3);\nright.expect_left(\"value was Right\");

pub fn expect_right(self, msg: &str) -> R
where\n L: Debug,

Returns the right value

§Examples

let right: Either<(), _> = Right(3);\nassert_eq!(right.expect_right(\"value was Left\"), 3);

§Panics

When Either is a Left value

\n\n

let left: Either<_, ()> = Left(3);\nleft.expect_right(\"value was Right\");

pub fn either_into<T>(self) -> T
where\n L: Into<T>,\n R: Into<T>,

Convert the contained value into T

§Examples

// Both u16 and u32 can be converted to u64.\nlet left: Either<u16, u32> = Left(3u16);\nassert_eq!(left.either_into::<u64>(), 3u64);\nlet right: Either<u16, u32> = Right(7u32);\nassert_eq!(right.either_into::<u64>(), 7u64);

",0,"hir_ty::lower::path::CallbackData"],["

impl<T> Either<T, T>

pub fn into_inner(self) -> T

Extract the value of an either over two equivalent types.

\n\n

use either::*;\n\nlet left: Either<_, u32> = Left(123);\nassert_eq!(left.into_inner(), 123);\n\nlet right: Either<u32, _> = Right(123);\nassert_eq!(right.into_inner(), 123);

pub fn map<F, M>(self, f: F) -> Either<M, M> ⓘ
where\n F: FnOnce(T) -> M,

Map f over the contained value and return the result in the\ncorresponding variant.

\n\n

use either::*;\n\nlet value: Either<_, i32> = Right(42);\n\nlet other = value.map(|x| x * 2);\nassert_eq!(other, Right(84));

",0,"hir_ty::lower::path::CallbackData"],["

impl<L, R> Error for Either<L, R>
where\n L: Error,\n R: Error,

Available on crate features std only.

Either implements Error if both L and R implement it.

Requires crate feature \"std\"

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any. Read more

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports. Read more

","Error","hir_ty::lower::path::CallbackData"],["

impl<L, R> ExactSizeIterator for Either<L, R>
where\n L: ExactSizeIterator,\n R: ExactSizeIterator<Item = <L as Iterator>::Item>,

fn len(&self) -> usize

Returns the exact remaining length of the iterator. Read more

fn is_empty(&self) -> bool

🔬This is a nightly-only experimental API. (exact_size_is_empty)

Returns true if the iterator is empty. Read more

","ExactSizeIterator","hir_ty::lower::path::CallbackData"],["

impl<L, R, A> Extend<A> for Either<L, R>
where\n L: Extend<A>,\n R: Extend<A>,

fn extend<T>(&mut self, iter: T)
where\n T: IntoIterator<Item = A>,

Extends a collection with the contents of an iterator. Read more

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. Read more

","Extend","hir_ty::lower::path::CallbackData"],["

impl<L, R> From<Result<R, L>> for Either<L, R>

Convert from Result to Either with Ok => Right and Err => Left.

fn from(r: Result<R, L>) -> Either<L, R> ⓘ

Converts to this type from the input type.

","From>","hir_ty::lower::path::CallbackData"],["

impl<L, R> Future for Either<L, R>
where\n L: Future,\n R: Future<Output = <L as Future>::Output>,

Either<L, R> is a future if both L and R are futures.

type Output = <L as Future>::Output

The type of value produced on completion.

fn poll(\n self: Pin<&mut Either<L, R>>,\n cx: &mut Context<'_>,\n) -> Poll<<Either<L, R> as Future>::Output>

Attempts to resolve the future to a final value, registering\nthe current task for wakeup if the value is not yet available. Read more

","Future","hir_ty::lower::path::CallbackData"],["

impl<L, R> HasAttrs for Either<L, R>
where\n L: HasAttrs,\n R: HasAttrs,

fn attrs(&self) -> AstChildren<Attr>

fn has_atom_attr(&self, atom: &str) -> bool

fn inner_attributes_node(&self) -> Option<SyntaxNode<RustLanguage>>

This may return the same node as called with (with SourceFile). The caller has the responsibility\nto avoid duplicate attributes.

","HasAttrs","hir_ty::lower::path::CallbackData"],["

impl<A, B> HasName for Either<A, B>
where\n A: HasName,\n B: HasName,

fn name(&self) -> Option<Name>

","HasName","hir_ty::lower::path::CallbackData"],["

impl<L, R> Hash for Either<L, R>
where\n L: Hash,\n R: Hash,

fn hash<H>(&self, state: &mut H)
where\n __H: Hasher,

Feeds this value into the given Hasher. Read more

1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more

","Hash","hir_ty::lower::path::CallbackData"],["

impl<L, R> IndexedParallelIterator for Either<L, R>
where\n L: IndexedParallelIterator,\n R: IndexedParallelIterator<Item = <L as ParallelIterator>::Item>,

fn drive<C>(\n self,\n consumer: C,\n) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Result
where\n C: Consumer<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel\niterator. You should not need to call this directly. Read more

fn len(&self) -> usize

Produces an exact count of how many items this iterator will\nproduce, presuming no panic occurs. Read more

fn with_producer<CB>(\n self,\n callback: CB,\n) -> <CB as ProducerCallback<<Either<L, R> as ParallelIterator>::Item>>::Output
where\n CB: ProducerCallback<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel\niterator. You should not need to call this directly. Read more

fn by_exponential_blocks(self) -> ExponentialBlocks<Self>

Divides an iterator into sequential blocks of exponentially-increasing size. Read more

fn by_uniform_blocks(self, block_size: usize) -> UniformBlocks<Self>

Divides an iterator into sequential blocks of the given size. Read more

fn collect_into_vec(self, target: &mut Vec<Self::Item>)

Collects the results of the iterator into the specified\nvector. The vector is always cleared before execution\nbegins. If possible, reusing the vector across calls can lead\nto better performance since it reuses the same backing buffer. Read more

fn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec)
where\n Self: IndexedParallelIterator<Item = (A, B)>,\n A: Send,\n B: Send,

Unzips the results of the iterator into the specified\nvectors. The vectors are always cleared before execution\nbegins. If possible, reusing the vectors across calls can lead\nto better performance since they reuse the same backing buffer. Read more

fn zip<Z>(self, zip_op: Z) -> Zip<Self, <Z as IntoParallelIterator>::Iter>
where\n Z: IntoParallelIterator,\n <Z as IntoParallelIterator>::Iter: IndexedParallelIterator,

Iterates over tuples (A, B), where the items A are from\nthis iterator and B are from the iterator given as argument.\nLike the zip method on ordinary iterators, if the two\niterators are of unequal length, you only get the items they\nhave in common. Read more

fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, <Z as IntoParallelIterator>::Iter>
where\n Z: IntoParallelIterator,\n <Z as IntoParallelIterator>::Iter: IndexedParallelIterator,

The same as Zip, but requires that both iterators have the same length. Read more

fn interleave(\n self,\n other: I,\n) -> Interleave<Self, ::Iter>
where\n I: IntoParallelIterator<Item = Self::Item>,\n ::Iter: IndexedParallelIterator,

Interleaves elements of this iterator and the other given\niterator. Alternately yields elements from this iterator and\nthe given iterator, until both are exhausted. If one iterator\nis exhausted before the other, the last elements are provided\nfrom the other. Read more

fn interleave_shortest(\n self,\n other: I,\n) -> InterleaveShortest<Self, ::Iter>
where\n I: IntoParallelIterator<Item = Self::Item>,\n ::Iter: IndexedParallelIterator,

Interleaves elements of this iterator and the other given\niterator, until one is exhausted. Read more

fn chunks(self, chunk_size: usize) -> Chunks<Self>

Splits an iterator up into fixed-size chunks. Read more

fn fold_chunks<T, ID, F>(\n self,\n chunk_size: usize,\n identity: ID,\n fold_op: F,\n) -> FoldChunks<Self, ID, F>
where\n ID: Fn() -> T + Send + Sync,\n F: Fn(T, Self::Item) -> T + Send + Sync,\n T: Send,

Splits an iterator into fixed-size chunks, performing a sequential fold() on\neach chunk. Read more

fn fold_chunks_with<T, F>(\n self,\n chunk_size: usize,\n init: T,\n fold_op: F,\n) -> FoldChunksWith<Self, T, F>
where\n T: Send + Clone,\n F: Fn(T, Self::Item) -> T + Send + Sync,

Splits an iterator into fixed-size chunks, performing a sequential fold() on\neach chunk. Read more

fn cmp(self, other: I) -> Ordering
where\n I: IntoParallelIterator<Item = Self::Item>,\n ::Iter: IndexedParallelIterator,\n Self::Item: Ord,

Lexicographically compares the elements of this ParallelIterator with those of\nanother. Read more

fn partial_cmp(self, other: I) -> Option<Ordering>
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialOrd<::Item>,

Lexicographically compares the elements of this ParallelIterator with those of\nanother. Read more

fn eq(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialEq<::Item>,

Determines if the elements of this ParallelIterator\nare equal to those of another

fn ne(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialEq<::Item>,

Determines if the elements of this ParallelIterator\nare unequal to those of another

fn lt(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialOrd<::Item>,

Determines if the elements of this ParallelIterator\nare lexicographically less than those of another.

fn le(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialOrd<::Item>,

Determines if the elements of this ParallelIterator\nare less than or equal to those of another.

fn gt(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialOrd<::Item>,

Determines if the elements of this ParallelIterator\nare lexicographically greater than those of another.

fn ge(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialOrd<::Item>,

Determines if the elements of this ParallelIterator\nare greater than or equal to those of another.

fn enumerate(self) -> Enumerate<Self>

Yields an index along with each item. Read more

fn step_by(self, step: usize) -> StepBy<Self>

Creates an iterator that steps by the given amount Read more

fn skip(self, n: usize) -> Skip<Self>

Creates an iterator that skips the first n elements. Read more

fn take(self, n: usize) -> Take<Self>

Creates an iterator that yields the first n elements. Read more

fn position_any(self, predicate: P) -> Option<usize>
where\n P: Fn(Self::Item) -> bool + Sync + Send,

Searches for some item in the parallel iterator that\nmatches the given predicate, and returns its index. Like\nParallelIterator::find_any, the parallel search will not\nnecessarily find the first match, and once a match is\nfound we’ll attempt to stop processing any more. Read more

fn position_first(self, predicate: P) -> Option<usize>
where\n P: Fn(Self::Item) -> bool + Sync + Send,

Searches for the sequentially first item in the parallel iterator\nthat matches the given predicate, and returns its index. Read more

fn position_last(self, predicate: P) -> Option<usize>
where\n P: Fn(Self::Item) -> bool + Sync + Send,

Searches for the sequentially last item in the parallel iterator\nthat matches the given predicate, and returns its index. Read more

fn positions(self, predicate: P) -> Positions<Self, P>
where\n P: Fn(Self::Item) -> bool + Sync + Send,

Searches for items in the parallel iterator that match the given\npredicate, and returns their indices. Read more

fn rev(self) -> Rev<Self>

Produces a new iterator with the elements of this iterator in\nreverse order. Read more

fn with_min_len(self, min: usize) -> MinLen<Self>

Sets the minimum length of iterators desired to process in each\nrayon job. Rayon will not split any smaller than this length, but\nof course an iterator could already be smaller to begin with. Read more

fn with_max_len(self, max: usize) -> MaxLen<Self>

Sets the maximum length of iterators desired to process in each\nrayon job. Rayon will try to split at least below this length,\nunless that would put it below the length from with_min_len().\nFor example, given min=10 and max=15, a length of 16 will not be\nsplit any further. Read more

","IndexedParallelIterator","hir_ty::lower::path::CallbackData"],["

impl<L, R> Iterator for Either<L, R>
where\n L: Iterator,\n R: Iterator<Item = <L as Iterator>::Item>,

Either<L, R> is an iterator if both L and R are iterators.

type Item = <L as Iterator>::Item

The type of the elements being iterated over.

fn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>

Advances the iterator and returns the next value. Read more

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator. Read more

fn fold<Acc, G>(self, init: Acc, f: G) -> Acc
where\n G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,

Folds every element into an accumulator by applying an operation,\nreturning the final result. Read more

fn for_each<F>(self, f: F)
where\n F: FnMut(<Either<L, R> as Iterator>::Item),

Calls a closure on each element of an iterator. Read more

fn count(self) -> usize

Consumes the iterator, counting the number of iterations and returning it. Read more

fn last(self) -> Option<<Either<L, R> as Iterator>::Item>

Consumes the iterator, returning the last element. Read more

fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>

Returns the nth element of the iterator. Read more

fn collect(self) -> B
where\n B: FromIterator<<Either<L, R> as Iterator>::Item>,

Transforms an iterator into a collection. Read more

fn partition<B, F>(self, f: F) -> (B, B)
where\n B: Default + Extend<<Either<L, R> as Iterator>::Item>,\n F: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

Consumes an iterator, creating two collections from it. Read more

fn all<F>(&mut self, f: F) -> bool
where\n F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,

Tests if every element of the iterator matches a predicate. Read more

fn any<F>(&mut self, f: F) -> bool
where\n F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,

Tests if any element of the iterator matches a predicate. Read more

fn find(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>
where\n P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate. Read more

fn find_map<B, F>(&mut self, f: F) -> Option
where\n F: FnMut(<Either<L, R> as Iterator>::Item) -> Option,

Applies function to the elements of iterator and returns\nthe first non-none result. Read more

fn position(&mut self, predicate: P) -> Option<usize>
where\n P: FnMut(<Either<L, R> as Iterator>::Item) -> bool,

Searches for an element in an iterator, returning its index. Read more

fn next_chunk<const N: usize>(\n &mut self,\n) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
where\n Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values. Read more

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements. Read more

1.28.0 · Source§

fn step_by(self, step: usize) -> StepBy<Self>
where\n Self: Sized,

Creates an iterator starting at the same point, but stepping by\nthe given amount at each iteration. Read more

1.0.0 · Source§

fn chain(self, other: U) -> Chain<Self, ::IntoIter>
where\n Self: Sized,\n U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence. Read more

1.0.0 · Source§

fn zip(self, other: U) -> Zip<Self, ::IntoIter>
where\n Self: Sized,\n U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs. Read more

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>
where\n Self: Sized,\n Self::Item: Clone,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places a copy of separator between adjacent\nitems of the original iterator. Read more

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
where\n Self: Sized,\n G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places an item generated by separator\nbetween adjacent items of the original iterator. Read more

1.0.0 · Source§

fn map<B, F>(self, f: F) -> Map<Self, F>
where\n Self: Sized,\n F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each\nelement. Read more

1.0.0 · Source§

fn filter(self, predicate: P) -> Filter<Self, P>
where\n Self: Sized,\n P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element\nshould be yielded. Read more

1.0.0 · Source§

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
where\n Self: Sized,\n F: FnMut(Self::Item) -> Option,

Creates an iterator that both filters and maps. Read more

1.0.0 · Source§

fn enumerate(self) -> Enumerate<Self>
where\n Self: Sized,

Creates an iterator which gives the current iteration count as well as\nthe next value. Read more

1.0.0 · Source§

fn peekable(self) -> Peekable<Self>
where\n Self: Sized,

Creates an iterator which can use the peek and peek_mut methods\nto look at the next element of the iterator without consuming it. See\ntheir documentation for more information. Read more

1.0.0 · Source§

fn skip_while(self, predicate: P) -> SkipWhile<Self, P>
where\n Self: Sized,\n P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate. Read more

1.0.0 · Source§

fn take_while(self, predicate: P) -> TakeWhile<Self, P>
where\n Self: Sized,\n P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate. Read more

1.57.0 · Source§

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
where\n Self: Sized,\n P: FnMut(Self::Item) -> Option,

Creates an iterator that both yields elements based on a predicate and maps. Read more

1.0.0 · Source§

fn skip(self, n: usize) -> Skip<Self>
where\n Self: Sized,

Creates an iterator that skips the first n elements. Read more

1.0.0 · Source§

fn take(self, n: usize) -> Take<Self>
where\n Self: Sized,

Creates an iterator that yields the first n elements, or fewer\nif the underlying iterator ends sooner. Read more

1.0.0 · Source§

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
where\n Self: Sized,\n F: FnMut(&mut St, Self::Item) -> Option,

An iterator adapter which, like fold, holds internal state, but\nunlike fold, produces a new iterator. Read more

1.0.0 · Source§

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
where\n Self: Sized,\n U: IntoIterator,\n F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure. Read more

1.29.0 · Source§

fn flatten(self) -> Flatten<Self>
where\n Self: Sized,\n Self::Item: IntoIterator,

Creates an iterator that flattens nested structure. Read more

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
where\n Self: Sized,\n F: FnMut(&[Self::Item; N]) -> R,

🔬This is a nightly-only experimental API. (iter_map_windows)

Calls the given function f for each contiguous window of size N over\nself and returns an iterator over the outputs of f. Like slice::windows(),\nthe windows during mapping overlap as well. Read more

1.0.0 · Source§

fn fuse(self) -> Fuse<Self>
where\n Self: Sized,

Creates an iterator which ends after the first None. Read more

1.0.0 · Source§

fn inspect<F>(self, f: F) -> Inspect<Self, F>
where\n Self: Sized,\n F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on. Read more

1.0.0 · Source§

fn by_ref(&mut self) -> &mut Self
where\n Self: Sized,

Creates a “by reference” adapter for this instance of Iterator. Read more

fn try_collect(\n &mut self,\n) -> <<Self::Item as Try>::Residual as Residual>::TryType
where\n Self: Sized,\n Self::Item: Try,\n <Self::Item as Try>::Residual: Residual,\n B: FromIterator<<Self::Item as Try>::Output>,

🔬This is a nightly-only experimental API. (iterator_try_collect)

Fallibly transforms an iterator into a collection, short circuiting if\na failure is encountered. Read more

fn collect_into<E>(self, collection: &mut E) -> &mut E
where\n E: Extend<Self::Item>,\n Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection. Read more

fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
where\n T: 'a,\n Self: Sized + DoubleEndedIterator<Item = &'a mut T>,\n P: FnMut(&T) -> bool,

🔬This is a nightly-only experimental API. (iter_partition_in_place)

Reorders the elements of this iterator in-place according to the given predicate,\nsuch that all those that return true precede all those that return false.\nReturns the number of true elements found. Read more

fn is_partitioned(self, predicate: P) -> bool
where\n Self: Sized,\n P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate,\nsuch that all those that return true precede all those that return false. Read more

1.27.0 · Source§

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
where\n Self: Sized,\n F: FnMut(B, Self::Item) -> R,\n R: Try<Output = B>,

An iterator method that applies a function as long as it returns\nsuccessfully, producing a single, final value. Read more

1.27.0 · Source§

fn try_for_each<F, R>(&mut self, f: F) -> R
where\n Self: Sized,\n F: FnMut(Self::Item) -> R,\n R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the\niterator, stopping at the first error and returning that error. Read more

1.51.0 · Source§

fn reduce<F>(self, f: F) -> Option<Self::Item>
where\n Self: Sized,\n F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing\noperation. Read more

fn try_reduce<R>(\n &mut self,\n f: impl FnMut(Self::Item, Self::Item) -> R,\n) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
where\n Self: Sized,\n R: Try<Output = Self::Item>,\n <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the\nclosure returns a failure, the failure is propagated back to the caller immediately. Read more

fn try_find<R>(\n &mut self,\n f: impl FnMut(&Self::Item) -> R,\n) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
where\n Self: Sized,\n R: Try<Output = bool>,\n <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns\nthe first true result or the first error. Read more

1.0.0 · Source§

fn rposition(&mut self, predicate: P) -> Option<usize>
where\n P: FnMut(Self::Item) -> bool,\n Self: Sized + ExactSizeIterator + DoubleEndedIterator,

Searches for an element in an iterator from the right, returning its\nindex. Read more

1.0.0 · Source§

fn max(self) -> Option<Self::Item>
where\n Self: Sized,\n Self::Item: Ord,

Returns the maximum element of an iterator. Read more

1.0.0 · Source§

fn min(self) -> Option<Self::Item>
where\n Self: Sized,\n Self::Item: Ord,

Returns the minimum element of an iterator. Read more

1.6.0 · Source§

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
where\n B: Ord,\n Self: Sized,\n F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the\nspecified function. Read more

1.15.0 · Source§

fn max_by<F>(self, compare: F) -> Option<Self::Item>
where\n Self: Sized,\n F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the\nspecified comparison function. Read more

1.6.0 · Source§

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
where\n B: Ord,\n Self: Sized,\n F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the\nspecified function. Read more

1.15.0 · Source§

fn min_by<F>(self, compare: F) -> Option<Self::Item>
where\n Self: Sized,\n F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the\nspecified comparison function. Read more

1.0.0 · Source§

fn rev(self) -> Rev<Self>
where\n Self: Sized + DoubleEndedIterator,

Reverses an iterator’s direction. Read more

1.0.0 · Source§

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
where\n FromA: Default + Extend<A>,\n FromB: Default + Extend,\n Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers. Read more

1.36.0 · Source§

fn copied<'a, T>(self) -> Copied<Self>
where\n T: Copy + 'a,\n Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements. Read more

1.0.0 · Source§

fn cloned<'a, T>(self) -> Cloned<Self>
where\n T: Clone + 'a,\n Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements. Read more

1.0.0 · Source§

fn cycle(self) -> Cycle<Self>
where\n Self: Sized + Clone,

Repeats an iterator endlessly. Read more

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
where\n Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time. Read more

1.11.0 · Source§

fn sum<S>(self) -> S
where\n Self: Sized,\n S: Sum<Self::Item>,

Sums the elements of an iterator. Read more

1.11.0 · Source§

fn product(self) -> P
where\n Self: Sized,\n P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements Read more

1.5.0 · Source§

fn cmp(self, other: I) -> Ordering
where\n I: IntoIterator<Item = Self::Item>,\n Self::Item: Ord,\n Self: Sized,

Lexicographically compares the elements of this Iterator with those\nof another. Read more

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
where\n Self: Sized,\n I: IntoIterator,\n F: FnMut(Self::Item, ::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those\nof another with respect to the specified comparison function. Read more

1.5.0 · Source§

fn partial_cmp(self, other: I) -> Option<Ordering>
where\n I: IntoIterator,\n Self::Item: PartialOrd<::Item>,\n Self: Sized,

Lexicographically compares the PartialOrd elements of\nthis Iterator with those of another. The comparison works like short-circuit\nevaluation, returning a result without comparing the remaining elements.\nAs soon as an order can be determined, the evaluation stops and a result is returned. Read more

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
where\n Self: Sized,\n I: IntoIterator,\n F: FnMut(Self::Item, ::Item) -> Option<Ordering>,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those\nof another with respect to the specified comparison function. Read more

1.5.0 · Source§

fn eq(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialEq<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are equal to those of\nanother. Read more

fn eq_by<I, F>(self, other: I, eq: F) -> bool
where\n Self: Sized,\n I: IntoIterator,\n F: FnMut(Self::Item, ::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_order_by)

Determines if the elements of this Iterator are equal to those of\nanother with respect to the specified equality function. Read more

1.5.0 · Source§

fn ne(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialEq<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are not equal to those of\nanother. Read more

1.5.0 · Source§

fn lt(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialOrd<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are lexicographically\nless than those of another. Read more

1.5.0 · Source§

fn le(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialOrd<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are lexicographically\nless or equal to those of another. Read more

1.5.0 · Source§

fn gt(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialOrd<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are lexicographically\ngreater than those of another. Read more

1.5.0 · Source§

fn ge(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialOrd<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are lexicographically\ngreater than or equal to those of another. Read more

1.82.0 · Source§

fn is_sorted(self) -> bool
where\n Self: Sized,\n Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted. Read more

1.82.0 · Source§

fn is_sorted_by<F>(self, compare: F) -> bool
where\n Self: Sized,\n F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function. Read more

1.82.0 · Source§

fn is_sorted_by_key<F, K>(self, f: F) -> bool
where\n Self: Sized,\n F: FnMut(Self::Item) -> K,\n K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction\nfunction. Read more

","Iterator","hir_ty::lower::path::CallbackData"],["

impl<L, R> Ord for Either<L, R>
where\n L: Ord,\n R: Ord,

fn cmp(&self, other: &Either<L, R>) -> Ordering

This method returns an Ordering between self and other. Read more

1.21.0 · Source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more

1.21.0 · Source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more

1.50.0 · Source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized,

Restrict a value to a certain interval. Read more

","Ord","hir_ty::lower::path::CallbackData"],["

impl<L, R, T> ParallelExtend<T> for Either<L, R>
where\n L: ParallelExtend<T>,\n R: ParallelExtend<T>,\n T: Send,

Either<L, R> can be extended if both L and R are parallel extendable.

fn par_extend(&mut self, par_iter: I)
where\n I: IntoParallelIterator<Item = T>,

Extends an instance of the collection with the elements drawn\nfrom the parallel iterator par_iter. Read more

","ParallelExtend","hir_ty::lower::path::CallbackData"],["

impl<L, R> ParallelIterator for Either<L, R>
where\n L: ParallelIterator,\n R: ParallelIterator<Item = <L as ParallelIterator>::Item>,

Either<L, R> is a parallel iterator if both L and R are parallel iterators.

type Item = <L as ParallelIterator>::Item

The type of item that this parallel iterator produces.\nFor example, if you use the for_each method, this is the type of\nitem that your closure will be invoked with.

fn drive_unindexed<C>(\n self,\n consumer: C,\n) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Result
where\n C: UnindexedConsumer<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel\niterator. You should not need to call this directly. Read more

fn opt_len(&self) -> Option<usize>

Internal method used to define the behavior of this parallel\niterator. You should not need to call this directly. Read more

fn for_each<OP>(self, op: OP)
where\n OP: Fn(Self::Item) + Sync + Send,

Executes OP on each item produced by the iterator, in parallel. Read more

fn for_each_with<OP, T>(self, init: T, op: OP)
where\n OP: Fn(&mut T, Self::Item) + Sync + Send,\n T: Send + Clone,

Executes OP on the given init value with each item produced by\nthe iterator, in parallel. Read more

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)
where\n OP: Fn(&mut T, Self::Item) + Sync + Send,\n INIT: Fn() -> T + Sync + Send,

Executes OP on a value returned by init with each item produced by\nthe iterator, in parallel. Read more

fn try_for_each<OP, R>(self, op: OP) -> R
where\n OP: Fn(Self::Item) -> R + Sync + Send,\n R: Try<Output = ()> + Send,

Executes a fallible OP on each item produced by the iterator, in parallel. Read more

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R
where\n OP: Fn(&mut T, Self::Item) -> R + Sync + Send,\n T: Send + Clone,\n R: Try<Output = ()> + Send,

Executes a fallible OP on the given init value with each item\nproduced by the iterator, in parallel. Read more

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R
where\n OP: Fn(&mut T, Self::Item) -> R + Sync + Send,\n INIT: Fn() -> T + Sync + Send,\n R: Try<Output = ()> + Send,

Executes a fallible OP on a value returned by init with each item\nproduced by the iterator, in parallel. Read more

fn count(self) -> usize

Counts the number of items in this parallel iterator. Read more

fn map<F, R>(self, map_op: F) -> Map<Self, F>
where\n F: Fn(Self::Item) -> R + Sync + Send,\n R: Send,

Applies map_op to each item of this iterator, producing a new\niterator with the results. Read more

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>
where\n F: Fn(&mut T, Self::Item) -> R + Sync + Send,\n T: Send + Clone,\n R: Send,

Applies map_op to the given init value with each item of this\niterator, producing a new iterator with the results. Read more

fn map_init<F, INIT, T, R>(\n self,\n init: INIT,\n map_op: F,\n) -> MapInit<Self, INIT, F>
where\n F: Fn(&mut T, Self::Item) -> R + Sync + Send,\n INIT: Fn() -> T + Sync + Send,\n R: Send,

Applies map_op to a value returned by init with each item of this\niterator, producing a new iterator with the results. Read more

fn cloned<'a, T>(self) -> Cloned<Self>
where\n T: 'a + Clone + Send,\n Self: ParallelIterator<Item = &'a T>,

Creates an iterator which clones all of its elements. This may be\nuseful when you have an iterator over &T, but you need T, and\nthat type implements Clone. See also copied(). Read more

fn copied<'a, T>(self) -> Copied<Self>
where\n T: 'a + Copy + Send,\n Self: ParallelIterator<Item = &'a T>,

Creates an iterator which copies all of its elements. This may be\nuseful when you have an iterator over &T, but you need T, and\nthat type implements Copy. See also cloned(). Read more

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>
where\n OP: Fn(&Self::Item) + Sync + Send,

Applies inspect_op to a reference to each item of this iterator,\nproducing a new iterator passing through the original items. This is\noften useful for debugging to see what’s happening in iterator stages. Read more

fn update<F>(self, update_op: F) -> Update<Self, F>
where\n F: Fn(&mut Self::Item) + Sync + Send,

Mutates each item of this iterator before yielding it. Read more

fn filter(self, filter_op: P) -> Filter<Self, P>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

Applies filter_op to each item of this iterator, producing a new\niterator with only the items that gave true results. Read more

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>
where\n P: Fn(Self::Item) -> Option<R> + Sync + Send,\n R: Send,

Applies filter_op to each item of this iterator to get an Option,\nproducing a new iterator with only the items from Some results. Read more

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>
where\n F: Fn(Self::Item) -> PI + Sync + Send,\n PI: IntoParallelIterator,

Applies map_op to each item of this iterator to get nested parallel iterators,\nproducing a new parallel iterator that flattens these back into one. Read more

fn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>
where\n F: Fn(Self::Item) -> SI + Sync + Send,\n SI: IntoIterator,\n <SI as IntoIterator>::Item: Send,

Applies map_op to each item of this iterator to get nested serial iterators,\nproducing a new parallel iterator that flattens these back into one. Read more

fn flatten(self) -> Flatten<Self>
where\n Self::Item: IntoParallelIterator,

An adaptor that flattens parallel-iterable Items into one large iterator. Read more

fn flatten_iter(self) -> FlattenIter<Self>
where\n Self::Item: IntoIterator,\n <Self::Item as IntoIterator>::Item: Send,

An adaptor that flattens serial-iterable Items into one large iterator. Read more

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item
where\n OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,\n ID: Fn() -> Self::Item + Sync + Send,

Reduces the items in the iterator into one item using op.\nThe argument identity should be a closure that can produce\n“identity” value which may be inserted into the sequence as\nneeded to create opportunities for parallel execution. So, for\nexample, if you are doing a summation, then identity() ought\nto produce something that represents the zero for your type\n(but consider just calling sum() in that case). Read more

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item>
where\n OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,

Reduces the items in the iterator into one item using op.\nIf the iterator is empty, None is returned; otherwise,\nSome is returned. Read more

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item
where\n OP: Fn(T, T) -> Self::Item + Sync + Send,\n ID: Fn() -> T + Sync + Send,\n Self::Item: Try<Output = T>,

Reduces the items in the iterator into one item using a fallible op.\nThe identity argument is used the same way as in reduce(). Read more

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item>
where\n OP: Fn(T, T) -> Self::Item + Sync + Send,\n Self::Item: Try<Output = T>,

Reduces the items in the iterator into one item using a fallible op. Read more

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>
where\n F: Fn(T, Self::Item) -> T + Sync + Send,\n ID: Fn() -> T + Sync + Send,\n T: Send,

Parallel fold is similar to sequential fold except that the\nsequence of items may be subdivided before it is\nfolded. Consider a list of numbers like 22 3 77 89 46. If\nyou used sequential fold to add them (fold(0, |a,b| a+b),\nyou would wind up first adding 0 + 22, then 22 + 3, then 25 +\n77, and so forth. The parallel fold works similarly except\nthat it first breaks up your list into sublists, and hence\ninstead of yielding up a single sum at the end, it yields up\nmultiple sums. The number of results is nondeterministic, as\nis the point where the breaks occur. Read more

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>
where\n F: Fn(T, Self::Item) -> T + Sync + Send,\n T: Send + Clone,

Applies fold_op to the given init value with each item of this\niterator, finally producing the value for further use. Read more

fn try_fold<T, R, ID, F>(\n self,\n identity: ID,\n fold_op: F,\n) -> TryFold<Self, R, ID, F>
where\n F: Fn(T, Self::Item) -> R + Sync + Send,\n ID: Fn() -> T + Sync + Send,\n R: Try<Output = T> + Send,

Performs a fallible parallel fold. Read more

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F>
where\n F: Fn(T, Self::Item) -> R + Sync + Send,\n R: Try<Output = T> + Send,\n T: Clone + Send,

Performs a fallible parallel fold with a cloneable init value. Read more

fn sum<S>(self) -> S
where\n S: Send + Sum<Self::Item> + Sum,

Sums up the items in the iterator. Read more

fn product(self) -> P
where\n P: Send + Product<Self::Item> + Product,

Multiplies all the items in the iterator. Read more

fn min(self) -> Option<Self::Item>
where\n Self::Item: Ord,

Computes the minimum of all the items in the iterator. If the\niterator is empty, None is returned; otherwise, Some(min)\nis returned. Read more

fn min_by<F>(self, f: F) -> Option<Self::Item>
where\n F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,

Computes the minimum of all the items in the iterator with respect to\nthe given comparison function. If the iterator is empty, None is\nreturned; otherwise, Some(min) is returned. Read more

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item>
where\n K: Ord + Send,\n F: Sync + Send + Fn(&Self::Item) -> K,

Computes the item that yields the minimum value for the given\nfunction. If the iterator is empty, None is returned;\notherwise, Some(item) is returned. Read more

fn max(self) -> Option<Self::Item>
where\n Self::Item: Ord,

Computes the maximum of all the items in the iterator. If the\niterator is empty, None is returned; otherwise, Some(max)\nis returned. Read more

fn max_by<F>(self, f: F) -> Option<Self::Item>
where\n F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,

Computes the maximum of all the items in the iterator with respect to\nthe given comparison function. If the iterator is empty, None is\nreturned; otherwise, Some(max) is returned. Read more

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item>
where\n K: Ord + Send,\n F: Sync + Send + Fn(&Self::Item) -> K,

Computes the item that yields the maximum value for the given\nfunction. If the iterator is empty, None is returned;\notherwise, Some(item) is returned. Read more

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter>
where\n C: IntoParallelIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both. Read more

fn find_any(self, predicate: P) -> Option<Self::Item>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

Searches for some item in the parallel iterator that\nmatches the given predicate and returns it. This operation\nis similar to find on sequential iterators but\nthe item returned may not be the first one in the parallel\nsequence which matches, since we search the entire sequence in parallel. Read more

fn find_first(self, predicate: P) -> Option<Self::Item>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

Searches for the sequentially first item in the parallel iterator\nthat matches the given predicate and returns it. Read more

fn find_last(self, predicate: P) -> Option<Self::Item>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

Searches for the sequentially last item in the parallel iterator\nthat matches the given predicate and returns it. Read more

fn find_map_any<P, R>(self, predicate: P) -> Option<R>
where\n P: Fn(Self::Item) -> Option<R> + Sync + Send,\n R: Send,

Applies the given predicate to the items in the parallel iterator\nand returns any non-None result of the map operation. Read more

fn find_map_first<P, R>(self, predicate: P) -> Option<R>
where\n P: Fn(Self::Item) -> Option<R> + Sync + Send,\n R: Send,

Applies the given predicate to the items in the parallel iterator and\nreturns the sequentially first non-None result of the map operation. Read more

fn find_map_last<P, R>(self, predicate: P) -> Option<R>
where\n P: Fn(Self::Item) -> Option<R> + Sync + Send,\n R: Send,

Applies the given predicate to the items in the parallel iterator and\nreturns the sequentially last non-None result of the map operation. Read more

fn any(self, predicate: P) -> bool
where\n P: Fn(Self::Item) -> bool + Sync + Send,

Searches for some item in the parallel iterator that\nmatches the given predicate, and if so returns true. Once\na match is found, we’ll attempt to stop process the rest\nof the items. Proving that there’s no match, returning false,\ndoes require visiting every item. Read more

fn all(self, predicate: P) -> bool
where\n P: Fn(Self::Item) -> bool + Sync + Send,

Tests that every item in the parallel iterator matches the given\npredicate, and if so returns true. If a counter-example is found,\nwe’ll attempt to stop processing more items, then return false. Read more

fn while_some<T>(self) -> WhileSome<Self>
where\n Self: ParallelIterator<Item = Option<T>>,\n T: Send,

Creates an iterator over the Some items of this iterator, halting\nas soon as any None is found. Read more

fn panic_fuse(self) -> PanicFuse<Self>

Wraps an iterator with a fuse in case of panics, to halt all threads\nas soon as possible. Read more

fn collect<C>(self) -> C
where\n C: FromParallelIterator<Self::Item>,

Creates a fresh collection containing all the elements produced\nby this parallel iterator. Read more

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
where\n Self: ParallelIterator<Item = (A, B)>,\n FromA: Default + Send + ParallelExtend<A>,\n FromB: Default + Send + ParallelExtend,\n A: Send,\n B: Send,

Unzips the items of a parallel iterator into a pair of arbitrary\nParallelExtend containers. Read more

fn partition<A, B, P>(self, predicate: P) -> (A, B)
where\n A: Default + Send + ParallelExtend<Self::Item>,\n B: Default + Send + ParallelExtend<Self::Item>,\n P: Fn(&Self::Item) -> bool + Sync + Send,

Partitions the items of a parallel iterator into a pair of arbitrary\nParallelExtend containers. Items for which the predicate returns\ntrue go into the first container, and the rest go into the second. Read more

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)
where\n A: Default + Send + ParallelExtend<L>,\n B: Default + Send + ParallelExtend<R>,\n P: Fn(Self::Item) -> Either<L, R> + Sync + Send,\n L: Send,\n R: Send,

Partitions and maps the items of a parallel iterator into a pair of\narbitrary ParallelExtend containers. Either::Left items go into\nthe first container, and Either::Right items go into the second. Read more

fn intersperse(self, element: Self::Item) -> Intersperse<Self>
where\n Self::Item: Clone,

Intersperses clones of an element between items of this iterator. Read more

fn take_any(self, n: usize) -> TakeAny<Self>

Creates an iterator that yields n elements from anywhere in the original iterator. Read more

fn skip_any(self, n: usize) -> SkipAny<Self>

Creates an iterator that skips n elements from anywhere in the original iterator. Read more

fn take_any_while(self, predicate: P) -> TakeAnyWhile<Self, P>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

Creates an iterator that takes elements from anywhere in the original iterator\nuntil the given predicate returns false. Read more

fn skip_any_while(self, predicate: P) -> SkipAnyWhile<Self, P>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

Creates an iterator that skips elements from anywhere in the original iterator\nuntil the given predicate returns false. Read more

fn collect_vec_list(self) -> LinkedList<Vec<Self::Item>>

Collects this iterator into a linked list of vectors. Read more

","ParallelIterator","hir_ty::lower::path::CallbackData"],["

impl<L, R> PartialEq for Either<L, R>
where\n L: PartialEq,\n R: PartialEq,

fn eq(&self, other: &Either<L, R>) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient,\nand should not be overridden without very good reason.

","PartialEq","hir_ty::lower::path::CallbackData"],["

impl<L, R> PartialOrd for Either<L, R>
where\n L: PartialOrd,\n R: PartialOrd,

fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the\n<= operator. Read more

1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the >\noperator. Read more

1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by\nthe >= operator. Read more

","PartialOrd","hir_ty::lower::path::CallbackData"],["

impl<L, R> Read for Either<L, R>
where\n L: Read,\n R: Read,

Available on crate features std only.

Either<L, R> implements Read if both L and R do.

Requires crate feature \"std\"

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Pull some bytes from this source into the specified buffer, returning\nhow many bytes were read. Read more

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf. Read more

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf. Read more

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf. Read more

1.36.0 · Source§

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers. Read more

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored\nimplementation. Read more

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer. Read more

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor. Read more

1.0.0 · Source§

fn by_ref(&mut self) -> &mut Self
where\n Self: Sized,

Creates a “by reference” adapter for this instance of Read. Read more

1.0.0 · Source§

fn bytes(self) -> Bytes<Self>
where\n Self: Sized,

Transforms this Read instance to an Iterator over its bytes. Read more

1.0.0 · Source§

fn chain<R>(self, next: R) -> Chain<Self, R>
where\n R: Read,\n Self: Sized,

Creates an adapter which will chain this stream with another. Read more

1.0.0 · Source§

fn take(self, limit: u64) -> Take<Self>
where\n Self: Sized,

Creates an adapter which will read at most limit bytes from it. Read more

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>
where\n Self: Sized,

🔬This is a nightly-only experimental API. (read_array)

Read and return a fixed array of bytes from this source. Read more

","Read","hir_ty::lower::path::CallbackData"],["

impl<L, R> Seek for Either<L, R>
where\n L: Seek,\n R: Seek,

Available on crate features std only.

Either<L, R> implements Seek if both L and R do.

Requires crate feature \"std\"

fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>

Seek to an offset, in bytes, in a stream. Read more

1.55.0 · Source§

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream. Read more

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes). Read more

1.51.0 · Source§

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream. Read more

1.80.0 · Source§

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position. Read more

","Seek","hir_ty::lower::path::CallbackData"],["

impl<L, R> Update for Either<L, R>
where\n L: Update,\n R: Update,

Available on crate feature rayon only.

unsafe fn maybe_update(\n old_pointer: *mut Either<L, R>,\n new_value: Either<L, R>,\n) -> bool

Returns Read more

","Update","hir_ty::lower::path::CallbackData"],["

impl<L, R> Write for Either<L, R>
where\n L: Write,\n R: Write,

Available on crate features std only.

Either<L, R> implements Write if both L and R do.

Requires crate feature \"std\"

fn write(&mut self, buf: &[u8]) -> Result<usize, Error>

Writes a buffer into this writer, returning how many bytes were written. Read more

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer. Read more

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error\nencountered. Read more

fn flush(&mut self) -> Result<(), Error>

Flushes this output stream, ensuring that all intermediately buffered\ncontents reach their destination. Read more

1.36.0 · Source§

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers. Read more

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored\nimplementation. Read more

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer. Read more

1.0.0 · Source§

fn by_ref(&mut self) -> &mut Self
where\n Self: Sized,

Creates a “by reference” adapter for this instance of Write. Read more

","Write","hir_ty::lower::path::CallbackData"],["

impl<L, R> Write for Either<L, R>
where\n L: Write,\n R: Write,

fn write_str(&mut self, s: &str) -> Result<(), Error>

Writes a string slice into this writer, returning whether the write\nsucceeded. Read more

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded. Read more

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait. Read more

","Write","hir_ty::lower::path::CallbackData"],["

impl<L, R> Copy for Either<L, R>
where\n L: Copy,\n R: Copy,

","Copy","hir_ty::lower::path::CallbackData"],["

impl<L, R> Eq for Either<L, R>
where\n L: Eq,\n R: Eq,

","Eq","hir_ty::lower::path::CallbackData"],["

impl<L, R> FusedIterator for Either<L, R>
where\n L: FusedIterator,\n R: FusedIterator<Item = <L as Iterator>::Item>,

","FusedIterator","hir_ty::lower::path::CallbackData"],["

impl<L, R> StructuralPartialEq for Either<L, R>

","StructuralPartialEq","hir_ty::lower::path::CallbackData"]]],["ide_db",[["

impl<L, R, Target> AsMut<[Target]> for Either<L, R>
where\n L: AsMut<[Target]>,\n R: AsMut<[Target]>,

fn as_mut(&mut self) -> &mut [Target]

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut<[Target]>","ide_db::path_transform::DefaultedParam"],["

impl<L, R> AsMut<CStr> for Either<L, R>
where\n L: AsMut<CStr>,\n R: AsMut<CStr>,

Available on crate feature std only.

Requires crate feature std.

fn as_mut(&mut self) -> &mut CStr

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut","ide_db::path_transform::DefaultedParam"],["

impl<L, R> AsMut<OsStr> for Either<L, R>
where\n L: AsMut<OsStr>,\n R: AsMut<OsStr>,

Available on crate feature std only.

Requires crate feature std.

fn as_mut(&mut self) -> &mut OsStr

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut","ide_db::path_transform::DefaultedParam"],["

impl<L, R> AsMut<Path> for Either<L, R>
where\n L: AsMut<Path>,\n R: AsMut<Path>,

Available on crate feature std only.

Requires crate feature std.

fn as_mut(&mut self) -> &mut Path

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut","ide_db::path_transform::DefaultedParam"],["

impl<L, R, Target> AsMut<Target> for Either<L, R>
where\n L: AsMut<Target>,\n R: AsMut<Target>,

fn as_mut(&mut self) -> &mut Target

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut","ide_db::path_transform::DefaultedParam"],["

impl<L, R> AsMut<str> for Either<L, R>
where\n L: AsMut<str>,\n R: AsMut<str>,

fn as_mut(&mut self) -> &mut str

Converts this type into a mutable reference of the (usually inferred) input type.

","AsMut","ide_db::path_transform::DefaultedParam"],["

impl<L, R, Target> AsRef<[Target]> for Either<L, R>
where\n L: AsRef<[Target]>,\n R: AsRef<[Target]>,

fn as_ref(&self) -> &[Target]

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef<[Target]>","ide_db::path_transform::DefaultedParam"],["

impl<L, R> AsRef<CStr> for Either<L, R>
where\n L: AsRef<CStr>,\n R: AsRef<CStr>,

Available on crate feature std only.

Requires crate feature std.

fn as_ref(&self) -> &CStr

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef","ide_db::path_transform::DefaultedParam"],["

impl<L, R> AsRef<OsStr> for Either<L, R>
where\n L: AsRef<OsStr>,\n R: AsRef<OsStr>,

Available on crate feature std only.

Requires crate feature std.

fn as_ref(&self) -> &OsStr

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef","ide_db::path_transform::DefaultedParam"],["

impl<L, R> AsRef<Path> for Either<L, R>
where\n L: AsRef<Path>,\n R: AsRef<Path>,

Available on crate feature std only.

Requires crate feature std.

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef","ide_db::path_transform::DefaultedParam"],["

impl<L, R, Target> AsRef<Target> for Either<L, R>
where\n L: AsRef<Target>,\n R: AsRef<Target>,

fn as_ref(&self) -> &Target

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef","ide_db::path_transform::DefaultedParam"],["

impl<L, R> AsRef<str> for Either<L, R>
where\n L: AsRef<str>,\n R: AsRef<str>,

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

","AsRef","ide_db::path_transform::DefaultedParam"],["

impl<L, R> AstNode for Either<L, R>
where\n L: AstNode,\n R: AstNode,

fn can_cast(kind: SyntaxKind) -> bool
where\n Either<L, R>: Sized,

fn cast(syntax: SyntaxNode<RustLanguage>) -> Option<Either<L, R>>
where\n Either<L, R>: Sized,

fn syntax(&self) -> &SyntaxNode<RustLanguage>

fn kind() -> SyntaxKind
where\n Self: Sized,

This panics if the SyntaxKind is not statically known.

fn clone_for_update(&self) -> Self
where\n Self: Sized,

fn clone_subtree(&self) -> Self
where\n Self: Sized,

","AstNode","ide_db::path_transform::DefaultedParam"],["

impl<L, R> BufRead for Either<L, R>
where\n L: BufRead,\n R: BufRead,

Available on crate features std only.

Requires crate feature \"std\"

fn fill_buf(&mut self) -> Result<&[u8], Error>

Returns the contents of the internal buffer, filling it with more data, via Read methods, if empty. Read more

fn consume(&mut self, amt: usize)

Marks the given amount of additional bytes from the internal buffer as having been read.\nSubsequent calls to read only return bytes that have not been marked as read. Read more

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes into buf until the delimiter byte or EOF is reached. Read more

fn read_line(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until a newline (the 0xA byte) is reached, and append\nthem to the provided String buffer. Read more

fn has_data_left(&mut self) -> Result<bool, Error>

🔬This is a nightly-only experimental API. (buf_read_has_data_left)

Checks if there is any data left to be read. Read more

1.83.0 · Source§

fn skip_until(&mut self, byte: u8) -> Result<usize, Error>

Skips all bytes until the delimiter byte or EOF is reached. Read more

1.0.0 · Source§

fn split(self, byte: u8) -> Split<Self>
where\n Self: Sized,

Returns an iterator over the contents of this reader split on the byte\nbyte. Read more

1.0.0 · Source§

fn lines(self) -> Lines<Self>
where\n Self: Sized,

Returns an iterator over the lines of this reader. Read more

","BufRead","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Clone for Either<L, R>
where\n L: Clone,\n R: Clone,

fn clone(&self) -> Either<L, R> ⓘ

Returns a duplicate of the value. Read more

fn clone_from(&mut self, source: &Either<L, R>)

Performs copy-assignment from source. Read more

","Clone","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Debug for Either<L, R>
where\n L: Debug,\n R: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

","Debug","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Deref for Either<L, R>
where\n L: Deref,\n R: Deref<Target = <L as Deref>::Target>,

type Target = <L as Deref>::Target

The resulting type after dereferencing.

fn deref(&self) -> &<Either<L, R> as Deref>::Target ⓘ

Dereferences the value.

","Deref","ide_db::path_transform::DefaultedParam"],["

impl<L, R> DerefMut for Either<L, R>
where\n L: DerefMut,\n R: DerefMut<Target = <L as Deref>::Target>,

fn deref_mut(&mut self) -> &mut <Either<L, R> as Deref>::Target ⓘ

Mutably dereferences the value.

","DerefMut","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Display for Either<L, R>
where\n L: Display,\n R: Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter. Read more

","Display","ide_db::path_transform::DefaultedParam"],["

impl<L, R> DoubleEndedIterator for Either<L, R>
where\n L: DoubleEndedIterator,\n R: DoubleEndedIterator<Item = <L as Iterator>::Item>,

fn next_back(&mut self) -> Option<<Either<L, R> as Iterator>::Item>

Removes and returns an element from the end of the iterator. Read more

fn nth_back(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>

Returns the nth element from the end of the iterator. Read more

fn rfold<Acc, G>(self, init: Acc, f: G) -> Acc
where\n G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,

An iterator method that reduces the iterator’s elements to a single,\nfinal value, starting from the back. Read more

fn rfind(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>
where\n P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

Searches for an element of an iterator from the back that satisfies a predicate. Read more

fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator from the back by n elements. Read more

1.27.0 · Source§

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
where\n Self: Sized,\n F: FnMut(B, Self::Item) -> R,\n R: Try<Output = B>,

This is the reverse version of Iterator::try_fold(): it takes\nelements starting from the back of the iterator. Read more

","DoubleEndedIterator","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Either<L, R>

pub fn is_left(&self) -> bool

Return true if the value is the Left variant.

\n\n

use either::*;\n\nlet values = [Left(1), Right(\"the right value\")];\nassert_eq!(values[0].is_left(), true);\nassert_eq!(values[1].is_left(), false);

pub fn is_right(&self) -> bool

Return true if the value is the Right variant.

\n\n

use either::*;\n\nlet values = [Left(1), Right(\"the right value\")];\nassert_eq!(values[0].is_right(), false);\nassert_eq!(values[1].is_right(), true);

pub fn left(self) -> Option<L>

Convert the left side of Either<L, R> to an Option<L>.

\n\n

use either::*;\n\nlet left: Either<_, ()> = Left(\"some value\");\nassert_eq!(left.left(),  Some(\"some value\"));\n\nlet right: Either<(), _> = Right(321);\nassert_eq!(right.left(), None);

pub fn right(self) -> Option<R>

Convert the right side of Either<L, R> to an Option<R>.

\n\n

use either::*;\n\nlet left: Either<_, ()> = Left(\"some value\");\nassert_eq!(left.right(),  None);\n\nlet right: Either<(), _> = Right(321);\nassert_eq!(right.right(), Some(321));

pub fn as_ref(&self) -> Either<&L, &R> ⓘ

Convert &Either<L, R> to Either<&L, &R>.

\n\n

use either::*;\n\nlet left: Either<_, ()> = Left(\"some value\");\nassert_eq!(left.as_ref(), Left(&\"some value\"));\n\nlet right: Either<(), _> = Right(\"some value\");\nassert_eq!(right.as_ref(), Right(&\"some value\"));

pub fn as_mut(&mut self) -> Either<&mut L, &mut R> ⓘ

Convert &mut Either<L, R> to Either<&mut L, &mut R>.

\n\n

use either::*;\n\nfn mutate_left(value: &mut Either<u32, u32>) {\n    if let Some(l) = value.as_mut().left() {\n        *l = 999;\n    }\n}\n\nlet mut left = Left(123);\nlet mut right = Right(123);\nmutate_left(&mut left);\nmutate_left(&mut right);\nassert_eq!(left, Left(999));\nassert_eq!(right, Right(123));

pub fn as_pin_ref(self: Pin<&Either<L, R>>) -> Either<Pin<&L>, Pin<&R>> ⓘ

Convert Pin<&Either<L, R>> to Either<Pin<&L>, Pin<&R>>,\npinned projections of the inner variants.

pub fn as_pin_mut(\n self: Pin<&mut Either<L, R>>,\n) -> Either<Pin<&mut L>, Pin<&mut R>> ⓘ

Convert Pin<&mut Either<L, R>> to Either<Pin<&mut L>, Pin<&mut R>>,\npinned projections of the inner variants.

pub fn flip(self) -> Either<R, L> ⓘ

Convert Either<L, R> to Either<R, L>.

\n\n

use either::*;\n\nlet left: Either<_, ()> = Left(123);\nassert_eq!(left.flip(), Right(123));\n\nlet right: Either<(), _> = Right(\"some value\");\nassert_eq!(right.flip(), Left(\"some value\"));

pub fn map_left<F, M>(self, f: F) -> Either<M, R> ⓘ
where\n F: FnOnce(L) -> M,

Apply the function f on the value in the Left variant if it is present rewrapping the\nresult in Left.

\n\n

use either::*;\n\nlet left: Either<_, u32> = Left(123);\nassert_eq!(left.map_left(|x| x * 2), Left(246));\n\nlet right: Either<u32, _> = Right(123);\nassert_eq!(right.map_left(|x| x * 2), Right(123));

pub fn map_right<F, S>(self, f: F) -> Either<L, S> ⓘ
where\n F: FnOnce(R) -> S,

Apply the function f on the value in the Right variant if it is present rewrapping the\nresult in Right.

\n\n

use either::*;\n\nlet left: Either<_, u32> = Left(123);\nassert_eq!(left.map_right(|x| x * 2), Left(123));\n\nlet right: Either<u32, _> = Right(123);\nassert_eq!(right.map_right(|x| x * 2), Right(246));

pub fn map_either<F, G, M, S>(self, f: F, g: G) -> Either<M, S> ⓘ
where\n F: FnOnce(L) -> M,\n G: FnOnce(R) -> S,

Apply the functions f and g to the Left and Right variants\nrespectively. This is equivalent to\nbimap\nin functional programming.

\n\n

use either::*;\n\nlet f = |s: String| s.len();\nlet g = |u: u8| u.to_string();\n\nlet left: Either<String, u8> = Left(\"loopy\".into());\nassert_eq!(left.map_either(f, g), Left(5));\n\nlet right: Either<String, u8> = Right(42);\nassert_eq!(right.map_either(f, g), Right(\"42\".into()));

pub fn map_either_with<Ctx, F, G, M, S>(\n self,\n ctx: Ctx,\n f: F,\n g: G,\n) -> Either<M, S> ⓘ
where\n F: FnOnce(Ctx, L) -> M,\n G: FnOnce(Ctx, R) -> S,

Similar to map_either, with an added context ctx accessible to\nboth functions.

\n\n

use either::*;\n\nlet mut sum = 0;\n\n// Both closures want to update the same value, so pass it as context.\nlet mut f = |sum: &mut usize, s: String| { *sum += s.len(); s.to_uppercase() };\nlet mut g = |sum: &mut usize, u: usize| { *sum += u; u.to_string() };\n\nlet left: Either<String, usize> = Left(\"loopy\".into());\nassert_eq!(left.map_either_with(&mut sum, &mut f, &mut g), Left(\"LOOPY\".into()));\n\nlet right: Either<String, usize> = Right(42);\nassert_eq!(right.map_either_with(&mut sum, &mut f, &mut g), Right(\"42\".into()));\n\nassert_eq!(sum, 47);

pub fn either<F, G, T>(self, f: F, g: G) -> T
where\n F: FnOnce(L) -> T,\n G: FnOnce(R) -> T,

\n\n

use either::*;\n\nfn square(n: u32) -> i32 { (n * n) as i32 }\nfn negate(n: i32) -> i32 { -n }\n\nlet left: Either<u32, i32> = Left(4);\nassert_eq!(left.either(square, negate), 16);\n\nlet right: Either<u32, i32> = Right(-4);\nassert_eq!(right.either(square, negate), 4);

pub fn either_with<Ctx, F, G, T>(self, ctx: Ctx, f: F, g: G) -> T
where\n F: FnOnce(Ctx, L) -> T,\n G: FnOnce(Ctx, R) -> T,

Like either, but provide some context to whichever of the\nfunctions ends up being called.

\n\n

// In this example, the context is a mutable reference\nuse either::*;\n\nlet mut result = Vec::new();\n\nlet values = vec![Left(2), Right(2.7)];\n\nfor value in values {\n    value.either_with(&mut result,\n                      |ctx, integer| ctx.push(integer),\n                      |ctx, real| ctx.push(f64::round(real) as i32));\n}\n\nassert_eq!(result, vec![2, 3]);

pub fn left_and_then<F, S>(self, f: F) -> Either<S, R> ⓘ
where\n F: FnOnce(L) -> Either<S, R>,

Apply the function f on the value in the Left variant if it is present.

\n\n

use either::*;\n\nlet left: Either<_, u32> = Left(123);\nassert_eq!(left.left_and_then::<_,()>(|x| Right(x * 2)), Right(246));\n\nlet right: Either<u32, _> = Right(123);\nassert_eq!(right.left_and_then(|x| Right::<(), _>(x * 2)), Right(123));

pub fn right_and_then<F, S>(self, f: F) -> Either<L, S> ⓘ
where\n F: FnOnce(R) -> Either<L, S>,

Apply the function f on the value in the Right variant if it is present.

\n\n

use either::*;\n\nlet left: Either<_, u32> = Left(123);\nassert_eq!(left.right_and_then(|x| Right(x * 2)), Left(123));\n\nlet right: Either<u32, _> = Right(123);\nassert_eq!(right.right_and_then(|x| Right(x * 2)), Right(246));

pub fn into_iter(\n self,\n) -> Either<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter> ⓘ
where\n L: IntoIterator,\n R: IntoIterator<Item = <L as IntoIterator>::Item>,

Convert the inner value to an iterator.

This requires the Left and Right iterators to have the same item type.\nSee factor_into_iter to iterate different types.

\n\n

use either::*;\n\nlet left: Either<_, Vec<u32>> = Left(vec![1, 2, 3, 4, 5]);\nlet mut right: Either<Vec<u32>, _> = Right(vec![]);\nright.extend(left.into_iter());\nassert_eq!(right, Right(vec![1, 2, 3, 4, 5]));

pub fn iter(\n &self,\n) -> Either<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter> ⓘ
where\n &'a L: for<'a> IntoIterator,\n &'a R: for<'a> IntoIterator<Item = <&'a L as IntoIterator>::Item>,

Borrow the inner value as an iterator.

This requires the Left and Right iterators to have the same item type.\nSee factor_iter to iterate different types.

\n\n

use either::*;\n\nlet left: Either<_, &[u32]> = Left(vec![2, 3]);\nlet mut right: Either<Vec<u32>, _> = Right(&[4, 5][..]);\nlet mut all = vec![1];\nall.extend(left.iter());\nall.extend(right.iter());\nassert_eq!(all, vec![1, 2, 3, 4, 5]);

pub fn iter_mut(\n &mut self,\n) -> Either<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter> ⓘ
where\n &'a mut L: for<'a> IntoIterator,\n &'a mut R: for<'a> IntoIterator<Item = <&'a mut L as IntoIterator>::Item>,

Mutably borrow the inner value as an iterator.

This requires the Left and Right iterators to have the same item type.\nSee factor_iter_mut to iterate different types.

\n\n

use either::*;\n\nlet mut left: Either<_, &mut [u32]> = Left(vec![2, 3]);\nfor l in left.iter_mut() {\n    *l *= *l\n}\nassert_eq!(left, Left(vec![4, 9]));\n\nlet mut inner = [4, 5];\nlet mut right: Either<Vec<u32>, _> = Right(&mut inner[..]);\nfor r in right.iter_mut() {\n    *r *= *r\n}\nassert_eq!(inner, [16, 25]);

pub fn factor_into_iter(\n self,\n) -> IterEither<<L as IntoIterator>::IntoIter, <R as IntoIterator>::IntoIter>
where\n L: IntoIterator,\n R: IntoIterator,

Converts an Either of Iterators to be an Iterator of Eithers

Unlike into_iter, this does not require the\nLeft and Right iterators to have the same item type.

\n\n

use either::*;\nlet left: Either<_, Vec<u8>> = Left(&[\"hello\"]);\nassert_eq!(left.factor_into_iter().next(), Some(Left(&\"hello\")));\n\nlet right: Either<&[&str], _> = Right(vec![0, 1]);\nassert_eq!(right.factor_into_iter().collect::<Vec<_>>(), vec![Right(0), Right(1)]);\n

pub fn factor_iter(\n &self,\n) -> IterEither<<&L as IntoIterator>::IntoIter, <&R as IntoIterator>::IntoIter>
where\n &'a L: for<'a> IntoIterator,\n &'a R: for<'a> IntoIterator,

Borrows an Either of Iterators to be an Iterator of Eithers

Unlike iter, this does not require the\nLeft and Right iterators to have the same item type.

\n\n

use either::*;\nlet left: Either<_, Vec<u8>> = Left([\"hello\"]);\nassert_eq!(left.factor_iter().next(), Some(Left(&\"hello\")));\n\nlet right: Either<[&str; 2], _> = Right(vec![0, 1]);\nassert_eq!(right.factor_iter().collect::<Vec<_>>(), vec![Right(&0), Right(&1)]);\n

pub fn factor_iter_mut(\n &mut self,\n) -> IterEither<<&mut L as IntoIterator>::IntoIter, <&mut R as IntoIterator>::IntoIter>
where\n &'a mut L: for<'a> IntoIterator,\n &'a mut R: for<'a> IntoIterator,

Mutably borrows an Either of Iterators to be an Iterator of Eithers

Unlike iter_mut, this does not require the\nLeft and Right iterators to have the same item type.

\n\n

use either::*;\nlet mut left: Either<_, Vec<u8>> = Left([\"hello\"]);\nleft.factor_iter_mut().for_each(|x| *x.unwrap_left() = \"goodbye\");\nassert_eq!(left, Left([\"goodbye\"]));\n\nlet mut right: Either<[&str; 2], _> = Right(vec![0, 1, 2]);\nright.factor_iter_mut().for_each(|x| if let Right(r) = x { *r = -*r; });\nassert_eq!(right, Right(vec![0, -1, -2]));\n

pub fn left_or(self, other: L) -> L

Return left value or given value

Arguments passed to left_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use\nleft_or_else, which is lazily evaluated.

§Examples

let left: Either<&str, &str> = Left(\"left\");\nassert_eq!(left.left_or(\"foo\"), \"left\");\n\nlet right: Either<&str, &str> = Right(\"right\");\nassert_eq!(right.left_or(\"left\"), \"left\");

pub fn left_or_default(self) -> L
where\n L: Default,

Return left or a default

§Examples

let left: Either<String, u32> = Left(\"left\".to_string());\nassert_eq!(left.left_or_default(), \"left\");\n\nlet right: Either<String, u32> = Right(42);\nassert_eq!(right.left_or_default(), String::default());

pub fn left_or_else<F>(self, f: F) -> L
where\n F: FnOnce(R) -> L,

Returns left value or computes it from a closure

§Examples

let left: Either<String, u32> = Left(\"3\".to_string());\nassert_eq!(left.left_or_else(|_| unreachable!()), \"3\");\n\nlet right: Either<String, u32> = Right(3);\nassert_eq!(right.left_or_else(|x| x.to_string()), \"3\");

pub fn right_or(self, other: R) -> R

Return right value or given value

Arguments passed to right_or are eagerly evaluated; if you are passing\nthe result of a function call, it is recommended to use\nright_or_else, which is lazily evaluated.

§Examples

let right: Either<&str, &str> = Right(\"right\");\nassert_eq!(right.right_or(\"foo\"), \"right\");\n\nlet left: Either<&str, &str> = Left(\"left\");\nassert_eq!(left.right_or(\"right\"), \"right\");

pub fn right_or_default(self) -> R
where\n R: Default,

Return right or a default

§Examples

let left: Either<String, u32> = Left(\"left\".to_string());\nassert_eq!(left.right_or_default(), u32::default());\n\nlet right: Either<String, u32> = Right(42);\nassert_eq!(right.right_or_default(), 42);

pub fn right_or_else<F>(self, f: F) -> R
where\n F: FnOnce(L) -> R,

Returns right value or computes it from a closure

§Examples

let left: Either<String, u32> = Left(\"3\".to_string());\nassert_eq!(left.right_or_else(|x| x.parse().unwrap()), 3);\n\nlet right: Either<String, u32> = Right(3);\nassert_eq!(right.right_or_else(|_| unreachable!()), 3);

pub fn unwrap_left(self) -> L
where\n R: Debug,

Returns the left value

§Examples

let left: Either<_, ()> = Left(3);\nassert_eq!(left.unwrap_left(), 3);

§Panics

When Either is a Right value

\n\n

let right: Either<(), _> = Right(3);\nright.unwrap_left();

pub fn unwrap_right(self) -> R
where\n L: Debug,

Returns the right value

§Examples

let right: Either<(), _> = Right(3);\nassert_eq!(right.unwrap_right(), 3);

§Panics

When Either is a Left value

\n\n

let left: Either<_, ()> = Left(3);\nleft.unwrap_right();

pub fn expect_left(self, msg: &str) -> L
where\n R: Debug,

Returns the left value

§Examples

let left: Either<_, ()> = Left(3);\nassert_eq!(left.expect_left(\"value was Right\"), 3);

§Panics

When Either is a Right value

\n\n

let right: Either<(), _> = Right(3);\nright.expect_left(\"value was Right\");

pub fn expect_right(self, msg: &str) -> R
where\n L: Debug,

Returns the right value

§Examples

let right: Either<(), _> = Right(3);\nassert_eq!(right.expect_right(\"value was Left\"), 3);

§Panics

When Either is a Left value

\n\n

let left: Either<_, ()> = Left(3);\nleft.expect_right(\"value was Right\");

pub fn either_into<T>(self) -> T
where\n L: Into<T>,\n R: Into<T>,

Convert the contained value into T

§Examples

// Both u16 and u32 can be converted to u64.\nlet left: Either<u16, u32> = Left(3u16);\nassert_eq!(left.either_into::<u64>(), 3u64);\nlet right: Either<u16, u32> = Right(7u32);\nassert_eq!(right.either_into::<u64>(), 7u64);

",0,"ide_db::path_transform::DefaultedParam"],["

impl<T> Either<T, T>

pub fn into_inner(self) -> T

Extract the value of an either over two equivalent types.

\n\n

use either::*;\n\nlet left: Either<_, u32> = Left(123);\nassert_eq!(left.into_inner(), 123);\n\nlet right: Either<u32, _> = Right(123);\nassert_eq!(right.into_inner(), 123);

pub fn map<F, M>(self, f: F) -> Either<M, M> ⓘ
where\n F: FnOnce(T) -> M,

Map f over the contained value and return the result in the\ncorresponding variant.

\n\n

use either::*;\n\nlet value: Either<_, i32> = Right(42);\n\nlet other = value.map(|x| x * 2);\nassert_eq!(other, Right(84));

",0,"ide_db::path_transform::DefaultedParam"],["

impl<L, R> Error for Either<L, R>
where\n L: Error,\n R: Error,

Available on crate features std only.

Either implements Error if both L and R implement it.

Requires crate feature \"std\"

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any. Read more

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports. Read more

","Error","ide_db::path_transform::DefaultedParam"],["

impl<L, R> ExactSizeIterator for Either<L, R>
where\n L: ExactSizeIterator,\n R: ExactSizeIterator<Item = <L as Iterator>::Item>,

fn len(&self) -> usize

Returns the exact remaining length of the iterator. Read more

fn is_empty(&self) -> bool

🔬This is a nightly-only experimental API. (exact_size_is_empty)

Returns true if the iterator is empty. Read more

","ExactSizeIterator","ide_db::path_transform::DefaultedParam"],["

impl<L, R, A> Extend<A> for Either<L, R>
where\n L: Extend<A>,\n R: Extend<A>,

fn extend<T>(&mut self, iter: T)
where\n T: IntoIterator<Item = A>,

Extends a collection with the contents of an iterator. Read more

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. Read more

","Extend","ide_db::path_transform::DefaultedParam"],["

impl<L, R> From<Result<R, L>> for Either<L, R>

Convert from Result to Either with Ok => Right and Err => Left.

fn from(r: Result<R, L>) -> Either<L, R> ⓘ

Converts to this type from the input type.

","From>","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Future for Either<L, R>
where\n L: Future,\n R: Future<Output = <L as Future>::Output>,

Either<L, R> is a future if both L and R are futures.

type Output = <L as Future>::Output

The type of value produced on completion.

fn poll(\n self: Pin<&mut Either<L, R>>,\n cx: &mut Context<'_>,\n) -> Poll<<Either<L, R> as Future>::Output>

Attempts to resolve the future to a final value, registering\nthe current task for wakeup if the value is not yet available. Read more

","Future","ide_db::path_transform::DefaultedParam"],["

impl<L, R> HasAttrs for Either<L, R>
where\n L: HasAttrs,\n R: HasAttrs,

fn attrs(&self) -> AstChildren<Attr>

fn has_atom_attr(&self, atom: &str) -> bool

fn inner_attributes_node(&self) -> Option<SyntaxNode<RustLanguage>>

This may return the same node as called with (with SourceFile). The caller has the responsibility\nto avoid duplicate attributes.

","HasAttrs","ide_db::path_transform::DefaultedParam"],["

impl<A, B> HasName for Either<A, B>
where\n A: HasName,\n B: HasName,

fn name(&self) -> Option<Name>

","HasName","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Hash for Either<L, R>
where\n L: Hash,\n R: Hash,

fn hash<H>(&self, state: &mut H)
where\n __H: Hasher,

Feeds this value into the given Hasher. Read more

1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more

","Hash","ide_db::path_transform::DefaultedParam"],["

impl<L, R> IndexedParallelIterator for Either<L, R>
where\n L: IndexedParallelIterator,\n R: IndexedParallelIterator<Item = <L as ParallelIterator>::Item>,

fn drive<C>(\n self,\n consumer: C,\n) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Result
where\n C: Consumer<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel\niterator. You should not need to call this directly. Read more

fn len(&self) -> usize

Produces an exact count of how many items this iterator will\nproduce, presuming no panic occurs. Read more

fn with_producer<CB>(\n self,\n callback: CB,\n) -> <CB as ProducerCallback<<Either<L, R> as ParallelIterator>::Item>>::Output
where\n CB: ProducerCallback<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel\niterator. You should not need to call this directly. Read more

fn by_exponential_blocks(self) -> ExponentialBlocks<Self>

Divides an iterator into sequential blocks of exponentially-increasing size. Read more

fn by_uniform_blocks(self, block_size: usize) -> UniformBlocks<Self>

Divides an iterator into sequential blocks of the given size. Read more

fn collect_into_vec(self, target: &mut Vec<Self::Item>)

fn unzip_into_vecs<A, B>(self, left: &mut Vec<A>, right: &mut Vec)
where\n Self: IndexedParallelIterator<Item = (A, B)>,\n A: Send,\n B: Send,

fn zip<Z>(self, zip_op: Z) -> Zip<Self, <Z as IntoParallelIterator>::Iter>
where\n Z: IntoParallelIterator,\n <Z as IntoParallelIterator>::Iter: IndexedParallelIterator,

fn zip_eq<Z>(self, zip_op: Z) -> ZipEq<Self, <Z as IntoParallelIterator>::Iter>
where\n Z: IntoParallelIterator,\n <Z as IntoParallelIterator>::Iter: IndexedParallelIterator,

The same as Zip, but requires that both iterators have the same length. Read more

fn interleave(\n self,\n other: I,\n) -> Interleave<Self, ::Iter>
where\n I: IntoParallelIterator<Item = Self::Item>,\n ::Iter: IndexedParallelIterator,

fn interleave_shortest(\n self,\n other: I,\n) -> InterleaveShortest<Self, ::Iter>
where\n I: IntoParallelIterator<Item = Self::Item>,\n ::Iter: IndexedParallelIterator,

Interleaves elements of this iterator and the other given\niterator, until one is exhausted. Read more

fn chunks(self, chunk_size: usize) -> Chunks<Self>

Splits an iterator up into fixed-size chunks. Read more

fn fold_chunks<T, ID, F>(\n self,\n chunk_size: usize,\n identity: ID,\n fold_op: F,\n) -> FoldChunks<Self, ID, F>
where\n ID: Fn() -> T + Send + Sync,\n F: Fn(T, Self::Item) -> T + Send + Sync,\n T: Send,

Splits an iterator into fixed-size chunks, performing a sequential fold() on\neach chunk. Read more

fn fold_chunks_with<T, F>(\n self,\n chunk_size: usize,\n init: T,\n fold_op: F,\n) -> FoldChunksWith<Self, T, F>
where\n T: Send + Clone,\n F: Fn(T, Self::Item) -> T + Send + Sync,

Splits an iterator into fixed-size chunks, performing a sequential fold() on\neach chunk. Read more

fn cmp(self, other: I) -> Ordering
where\n I: IntoParallelIterator<Item = Self::Item>,\n ::Iter: IndexedParallelIterator,\n Self::Item: Ord,

Lexicographically compares the elements of this ParallelIterator with those of\nanother. Read more

fn partial_cmp(self, other: I) -> Option<Ordering>
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialOrd<::Item>,

Lexicographically compares the elements of this ParallelIterator with those of\nanother. Read more

fn eq(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialEq<::Item>,

Determines if the elements of this ParallelIterator\nare equal to those of another

fn ne(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialEq<::Item>,

Determines if the elements of this ParallelIterator\nare unequal to those of another

fn lt(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialOrd<::Item>,

Determines if the elements of this ParallelIterator\nare lexicographically less than those of another.

fn le(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialOrd<::Item>,

Determines if the elements of this ParallelIterator\nare less than or equal to those of another.

fn gt(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialOrd<::Item>,

Determines if the elements of this ParallelIterator\nare lexicographically greater than those of another.

fn ge(self, other: I) -> bool
where\n I: IntoParallelIterator,\n ::Iter: IndexedParallelIterator,\n Self::Item: PartialOrd<::Item>,

Determines if the elements of this ParallelIterator\nare greater than or equal to those of another.

fn enumerate(self) -> Enumerate<Self>

Yields an index along with each item. Read more

fn step_by(self, step: usize) -> StepBy<Self>

Creates an iterator that steps by the given amount Read more

fn skip(self, n: usize) -> Skip<Self>

Creates an iterator that skips the first n elements. Read more

fn take(self, n: usize) -> Take<Self>

Creates an iterator that yields the first n elements. Read more

fn position_any(self, predicate: P) -> Option<usize>
where\n P: Fn(Self::Item) -> bool + Sync + Send,

fn position_first(self, predicate: P) -> Option<usize>
where\n P: Fn(Self::Item) -> bool + Sync + Send,

Searches for the sequentially first item in the parallel iterator\nthat matches the given predicate, and returns its index. Read more

fn position_last(self, predicate: P) -> Option<usize>
where\n P: Fn(Self::Item) -> bool + Sync + Send,

Searches for the sequentially last item in the parallel iterator\nthat matches the given predicate, and returns its index. Read more

fn positions(self, predicate: P) -> Positions<Self, P>
where\n P: Fn(Self::Item) -> bool + Sync + Send,

Searches for items in the parallel iterator that match the given\npredicate, and returns their indices. Read more

fn rev(self) -> Rev<Self>

Produces a new iterator with the elements of this iterator in\nreverse order. Read more

fn with_min_len(self, min: usize) -> MinLen<Self>

fn with_max_len(self, max: usize) -> MaxLen<Self>

","IndexedParallelIterator","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Iterator for Either<L, R>
where\n L: Iterator,\n R: Iterator<Item = <L as Iterator>::Item>,

Either<L, R> is an iterator if both L and R are iterators.

type Item = <L as Iterator>::Item

The type of the elements being iterated over.

fn next(&mut self) -> Option<<Either<L, R> as Iterator>::Item>

Advances the iterator and returns the next value. Read more

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the iterator. Read more

fn fold<Acc, G>(self, init: Acc, f: G) -> Acc
where\n G: FnMut(Acc, <Either<L, R> as Iterator>::Item) -> Acc,

Folds every element into an accumulator by applying an operation,\nreturning the final result. Read more

fn for_each<F>(self, f: F)
where\n F: FnMut(<Either<L, R> as Iterator>::Item),

Calls a closure on each element of an iterator. Read more

fn count(self) -> usize

Consumes the iterator, counting the number of iterations and returning it. Read more

fn last(self) -> Option<<Either<L, R> as Iterator>::Item>

Consumes the iterator, returning the last element. Read more

fn nth(&mut self, n: usize) -> Option<<Either<L, R> as Iterator>::Item>

Returns the nth element of the iterator. Read more

fn collect(self) -> B
where\n B: FromIterator<<Either<L, R> as Iterator>::Item>,

Transforms an iterator into a collection. Read more

fn partition<B, F>(self, f: F) -> (B, B)
where\n B: Default + Extend<<Either<L, R> as Iterator>::Item>,\n F: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

Consumes an iterator, creating two collections from it. Read more

fn all<F>(&mut self, f: F) -> bool
where\n F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,

Tests if every element of the iterator matches a predicate. Read more

fn any<F>(&mut self, f: F) -> bool
where\n F: FnMut(<Either<L, R> as Iterator>::Item) -> bool,

Tests if any element of the iterator matches a predicate. Read more

fn find(&mut self, predicate: P) -> Option<<Either<L, R> as Iterator>::Item>
where\n P: FnMut(&<Either<L, R> as Iterator>::Item) -> bool,

Searches for an element of an iterator that satisfies a predicate. Read more

fn find_map<B, F>(&mut self, f: F) -> Option
where\n F: FnMut(<Either<L, R> as Iterator>::Item) -> Option,

Applies function to the elements of iterator and returns\nthe first non-none result. Read more

fn position(&mut self, predicate: P) -> Option<usize>
where\n P: FnMut(<Either<L, R> as Iterator>::Item) -> bool,

Searches for an element in an iterator, returning its index. Read more

fn next_chunk<const N: usize>(\n &mut self,\n) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
where\n Self: Sized,

🔬This is a nightly-only experimental API. (iter_next_chunk)

Advances the iterator and returns an array containing the next N values. Read more

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

🔬This is a nightly-only experimental API. (iter_advance_by)

Advances the iterator by n elements. Read more

1.28.0 · Source§

fn step_by(self, step: usize) -> StepBy<Self>
where\n Self: Sized,

Creates an iterator starting at the same point, but stepping by\nthe given amount at each iteration. Read more

1.0.0 · Source§

fn chain(self, other: U) -> Chain<Self, ::IntoIter>
where\n Self: Sized,\n U: IntoIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both in sequence. Read more

1.0.0 · Source§

fn zip(self, other: U) -> Zip<Self, ::IntoIter>
where\n Self: Sized,\n U: IntoIterator,

‘Zips up’ two iterators into a single iterator of pairs. Read more

fn intersperse(self, separator: Self::Item) -> Intersperse<Self>
where\n Self: Sized,\n Self::Item: Clone,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places a copy of separator between adjacent\nitems of the original iterator. Read more

fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>
where\n Self: Sized,\n G: FnMut() -> Self::Item,

🔬This is a nightly-only experimental API. (iter_intersperse)

Creates a new iterator which places an item generated by separator\nbetween adjacent items of the original iterator. Read more

1.0.0 · Source§

fn map<B, F>(self, f: F) -> Map<Self, F>
where\n Self: Sized,\n F: FnMut(Self::Item) -> B,

Takes a closure and creates an iterator which calls that closure on each\nelement. Read more

1.0.0 · Source§

fn filter(self, predicate: P) -> Filter<Self, P>
where\n Self: Sized,\n P: FnMut(&Self::Item) -> bool,

Creates an iterator which uses a closure to determine if an element\nshould be yielded. Read more

1.0.0 · Source§

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>
where\n Self: Sized,\n F: FnMut(Self::Item) -> Option,

Creates an iterator that both filters and maps. Read more

1.0.0 · Source§

fn enumerate(self) -> Enumerate<Self>
where\n Self: Sized,

Creates an iterator which gives the current iteration count as well as\nthe next value. Read more

1.0.0 · Source§

fn peekable(self) -> Peekable<Self>
where\n Self: Sized,

Creates an iterator which can use the peek and peek_mut methods\nto look at the next element of the iterator without consuming it. See\ntheir documentation for more information. Read more

1.0.0 · Source§

fn skip_while(self, predicate: P) -> SkipWhile<Self, P>
where\n Self: Sized,\n P: FnMut(&Self::Item) -> bool,

Creates an iterator that skips elements based on a predicate. Read more

1.0.0 · Source§

fn take_while(self, predicate: P) -> TakeWhile<Self, P>
where\n Self: Sized,\n P: FnMut(&Self::Item) -> bool,

Creates an iterator that yields elements based on a predicate. Read more

1.57.0 · Source§

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>
where\n Self: Sized,\n P: FnMut(Self::Item) -> Option,

Creates an iterator that both yields elements based on a predicate and maps. Read more

1.0.0 · Source§

fn skip(self, n: usize) -> Skip<Self>
where\n Self: Sized,

Creates an iterator that skips the first n elements. Read more

1.0.0 · Source§

fn take(self, n: usize) -> Take<Self>
where\n Self: Sized,

Creates an iterator that yields the first n elements, or fewer\nif the underlying iterator ends sooner. Read more

1.0.0 · Source§

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>
where\n Self: Sized,\n F: FnMut(&mut St, Self::Item) -> Option,

An iterator adapter which, like fold, holds internal state, but\nunlike fold, produces a new iterator. Read more

1.0.0 · Source§

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>
where\n Self: Sized,\n U: IntoIterator,\n F: FnMut(Self::Item) -> U,

Creates an iterator that works like map, but flattens nested structure. Read more

1.29.0 · Source§

fn flatten(self) -> Flatten<Self>
where\n Self: Sized,\n Self::Item: IntoIterator,

Creates an iterator that flattens nested structure. Read more

fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>
where\n Self: Sized,\n F: FnMut(&[Self::Item; N]) -> R,

🔬This is a nightly-only experimental API. (iter_map_windows)

1.0.0 · Source§

fn fuse(self) -> Fuse<Self>
where\n Self: Sized,

Creates an iterator which ends after the first None. Read more

1.0.0 · Source§

fn inspect<F>(self, f: F) -> Inspect<Self, F>
where\n Self: Sized,\n F: FnMut(&Self::Item),

Does something with each element of an iterator, passing the value on. Read more

1.0.0 · Source§

fn by_ref(&mut self) -> &mut Self
where\n Self: Sized,

Creates a “by reference” adapter for this instance of Iterator. Read more

fn try_collect(\n &mut self,\n) -> <<Self::Item as Try>::Residual as Residual>::TryType
where\n Self: Sized,\n Self::Item: Try,\n <Self::Item as Try>::Residual: Residual,\n B: FromIterator<<Self::Item as Try>::Output>,

🔬This is a nightly-only experimental API. (iterator_try_collect)

Fallibly transforms an iterator into a collection, short circuiting if\na failure is encountered. Read more

fn collect_into<E>(self, collection: &mut E) -> &mut E
where\n E: Extend<Self::Item>,\n Self: Sized,

🔬This is a nightly-only experimental API. (iter_collect_into)

Collects all the items from an iterator into a collection. Read more

fn partition_in_place<'a, T, P>(self, predicate: P) -> usize
where\n T: 'a,\n Self: Sized + DoubleEndedIterator<Item = &'a mut T>,\n P: FnMut(&T) -> bool,

🔬This is a nightly-only experimental API. (iter_partition_in_place)

fn is_partitioned(self, predicate: P) -> bool
where\n Self: Sized,\n P: FnMut(Self::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_is_partitioned)

Checks if the elements of this iterator are partitioned according to the given predicate,\nsuch that all those that return true precede all those that return false. Read more

1.27.0 · Source§

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R
where\n Self: Sized,\n F: FnMut(B, Self::Item) -> R,\n R: Try<Output = B>,

An iterator method that applies a function as long as it returns\nsuccessfully, producing a single, final value. Read more

1.27.0 · Source§

fn try_for_each<F, R>(&mut self, f: F) -> R
where\n Self: Sized,\n F: FnMut(Self::Item) -> R,\n R: Try<Output = ()>,

An iterator method that applies a fallible function to each item in the\niterator, stopping at the first error and returning that error. Read more

1.51.0 · Source§

fn reduce<F>(self, f: F) -> Option<Self::Item>
where\n Self: Sized,\n F: FnMut(Self::Item, Self::Item) -> Self::Item,

Reduces the elements to a single one, by repeatedly applying a reducing\noperation. Read more

fn try_reduce<R>(\n &mut self,\n f: impl FnMut(Self::Item, Self::Item) -> R,\n) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryType
where\n Self: Sized,\n R: Try<Output = Self::Item>,\n <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (iterator_try_reduce)

Reduces the elements to a single one by repeatedly applying a reducing operation. If the\nclosure returns a failure, the failure is propagated back to the caller immediately. Read more

fn try_find<R>(\n &mut self,\n f: impl FnMut(&Self::Item) -> R,\n) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryType
where\n Self: Sized,\n R: Try<Output = bool>,\n <R as Try>::Residual: Residual<Option<Self::Item>>,

🔬This is a nightly-only experimental API. (try_find)

Applies function to the elements of iterator and returns\nthe first true result or the first error. Read more

1.0.0 · Source§

fn rposition(&mut self, predicate: P) -> Option<usize>
where\n P: FnMut(Self::Item) -> bool,\n Self: Sized + ExactSizeIterator + DoubleEndedIterator,

Searches for an element in an iterator from the right, returning its\nindex. Read more

1.0.0 · Source§

fn max(self) -> Option<Self::Item>
where\n Self: Sized,\n Self::Item: Ord,

Returns the maximum element of an iterator. Read more

1.0.0 · Source§

fn min(self) -> Option<Self::Item>
where\n Self: Sized,\n Self::Item: Ord,

Returns the minimum element of an iterator. Read more

1.6.0 · Source§

fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>
where\n B: Ord,\n Self: Sized,\n F: FnMut(&Self::Item) -> B,

Returns the element that gives the maximum value from the\nspecified function. Read more

1.15.0 · Source§

fn max_by<F>(self, compare: F) -> Option<Self::Item>
where\n Self: Sized,\n F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the maximum value with respect to the\nspecified comparison function. Read more

1.6.0 · Source§

fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>
where\n B: Ord,\n Self: Sized,\n F: FnMut(&Self::Item) -> B,

Returns the element that gives the minimum value from the\nspecified function. Read more

1.15.0 · Source§

fn min_by<F>(self, compare: F) -> Option<Self::Item>
where\n Self: Sized,\n F: FnMut(&Self::Item, &Self::Item) -> Ordering,

Returns the element that gives the minimum value with respect to the\nspecified comparison function. Read more

1.0.0 · Source§

fn rev(self) -> Rev<Self>
where\n Self: Sized + DoubleEndedIterator,

Reverses an iterator’s direction. Read more

1.0.0 · Source§

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
where\n FromA: Default + Extend<A>,\n FromB: Default + Extend,\n Self: Sized + Iterator<Item = (A, B)>,

Converts an iterator of pairs into a pair of containers. Read more

1.36.0 · Source§

fn copied<'a, T>(self) -> Copied<Self>
where\n T: Copy + 'a,\n Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which copies all of its elements. Read more

1.0.0 · Source§

fn cloned<'a, T>(self) -> Cloned<Self>
where\n T: Clone + 'a,\n Self: Sized + Iterator<Item = &'a T>,

Creates an iterator which clones all of its elements. Read more

1.0.0 · Source§

fn cycle(self) -> Cycle<Self>
where\n Self: Sized + Clone,

Repeats an iterator endlessly. Read more

fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>
where\n Self: Sized,

🔬This is a nightly-only experimental API. (iter_array_chunks)

Returns an iterator over N elements of the iterator at a time. Read more

1.11.0 · Source§

fn sum<S>(self) -> S
where\n Self: Sized,\n S: Sum<Self::Item>,

Sums the elements of an iterator. Read more

1.11.0 · Source§

fn product(self) -> P
where\n Self: Sized,\n P: Product<Self::Item>,

Iterates over the entire iterator, multiplying all the elements Read more

1.5.0 · Source§

fn cmp(self, other: I) -> Ordering
where\n I: IntoIterator<Item = Self::Item>,\n Self::Item: Ord,\n Self: Sized,

Lexicographically compares the elements of this Iterator with those\nof another. Read more

fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering
where\n Self: Sized,\n I: IntoIterator,\n F: FnMut(Self::Item, ::Item) -> Ordering,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those\nof another with respect to the specified comparison function. Read more

1.5.0 · Source§

fn partial_cmp(self, other: I) -> Option<Ordering>
where\n I: IntoIterator,\n Self::Item: PartialOrd<::Item>,\n Self: Sized,

fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>
where\n Self: Sized,\n I: IntoIterator,\n F: FnMut(Self::Item, ::Item) -> Option<Ordering>,

🔬This is a nightly-only experimental API. (iter_order_by)

Lexicographically compares the elements of this Iterator with those\nof another with respect to the specified comparison function. Read more

1.5.0 · Source§

fn eq(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialEq<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are equal to those of\nanother. Read more

fn eq_by<I, F>(self, other: I, eq: F) -> bool
where\n Self: Sized,\n I: IntoIterator,\n F: FnMut(Self::Item, ::Item) -> bool,

🔬This is a nightly-only experimental API. (iter_order_by)

Determines if the elements of this Iterator are equal to those of\nanother with respect to the specified equality function. Read more

1.5.0 · Source§

fn ne(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialEq<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are not equal to those of\nanother. Read more

1.5.0 · Source§

fn lt(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialOrd<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are lexicographically\nless than those of another. Read more

1.5.0 · Source§

fn le(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialOrd<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are lexicographically\nless or equal to those of another. Read more

1.5.0 · Source§

fn gt(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialOrd<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are lexicographically\ngreater than those of another. Read more

1.5.0 · Source§

fn ge(self, other: I) -> bool
where\n I: IntoIterator,\n Self::Item: PartialOrd<::Item>,\n Self: Sized,

Determines if the elements of this Iterator are lexicographically\ngreater than or equal to those of another. Read more

1.82.0 · Source§

fn is_sorted(self) -> bool
where\n Self: Sized,\n Self::Item: PartialOrd,

Checks if the elements of this iterator are sorted. Read more

1.82.0 · Source§

fn is_sorted_by<F>(self, compare: F) -> bool
where\n Self: Sized,\n F: FnMut(&Self::Item, &Self::Item) -> bool,

Checks if the elements of this iterator are sorted using the given comparator function. Read more

1.82.0 · Source§

fn is_sorted_by_key<F, K>(self, f: F) -> bool
where\n Self: Sized,\n F: FnMut(Self::Item) -> K,\n K: PartialOrd,

Checks if the elements of this iterator are sorted using the given key extraction\nfunction. Read more

","Iterator","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Ord for Either<L, R>
where\n L: Ord,\n R: Ord,

fn cmp(&self, other: &Either<L, R>) -> Ordering

This method returns an Ordering between self and other. Read more

1.21.0 · Source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more

1.21.0 · Source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more

1.50.0 · Source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized,

Restrict a value to a certain interval. Read more

","Ord","ide_db::path_transform::DefaultedParam"],["

impl<L, R, T> ParallelExtend<T> for Either<L, R>
where\n L: ParallelExtend<T>,\n R: ParallelExtend<T>,\n T: Send,

Either<L, R> can be extended if both L and R are parallel extendable.

fn par_extend(&mut self, par_iter: I)
where\n I: IntoParallelIterator<Item = T>,

Extends an instance of the collection with the elements drawn\nfrom the parallel iterator par_iter. Read more

","ParallelExtend","ide_db::path_transform::DefaultedParam"],["

impl<L, R> ParallelIterator for Either<L, R>
where\n L: ParallelIterator,\n R: ParallelIterator<Item = <L as ParallelIterator>::Item>,

Either<L, R> is a parallel iterator if both L and R are parallel iterators.

type Item = <L as ParallelIterator>::Item

The type of item that this parallel iterator produces.\nFor example, if you use the for_each method, this is the type of\nitem that your closure will be invoked with.

fn drive_unindexed<C>(\n self,\n consumer: C,\n) -> <C as Consumer<<Either<L, R> as ParallelIterator>::Item>>::Result
where\n C: UnindexedConsumer<<Either<L, R> as ParallelIterator>::Item>,

Internal method used to define the behavior of this parallel\niterator. You should not need to call this directly. Read more

fn opt_len(&self) -> Option<usize>

Internal method used to define the behavior of this parallel\niterator. You should not need to call this directly. Read more

fn for_each<OP>(self, op: OP)
where\n OP: Fn(Self::Item) + Sync + Send,

Executes OP on each item produced by the iterator, in parallel. Read more

fn for_each_with<OP, T>(self, init: T, op: OP)
where\n OP: Fn(&mut T, Self::Item) + Sync + Send,\n T: Send + Clone,

Executes OP on the given init value with each item produced by\nthe iterator, in parallel. Read more

fn for_each_init<OP, INIT, T>(self, init: INIT, op: OP)
where\n OP: Fn(&mut T, Self::Item) + Sync + Send,\n INIT: Fn() -> T + Sync + Send,

Executes OP on a value returned by init with each item produced by\nthe iterator, in parallel. Read more

fn try_for_each<OP, R>(self, op: OP) -> R
where\n OP: Fn(Self::Item) -> R + Sync + Send,\n R: Try<Output = ()> + Send,

Executes a fallible OP on each item produced by the iterator, in parallel. Read more

fn try_for_each_with<OP, T, R>(self, init: T, op: OP) -> R
where\n OP: Fn(&mut T, Self::Item) -> R + Sync + Send,\n T: Send + Clone,\n R: Try<Output = ()> + Send,

Executes a fallible OP on the given init value with each item\nproduced by the iterator, in parallel. Read more

fn try_for_each_init<OP, INIT, T, R>(self, init: INIT, op: OP) -> R
where\n OP: Fn(&mut T, Self::Item) -> R + Sync + Send,\n INIT: Fn() -> T + Sync + Send,\n R: Try<Output = ()> + Send,

Executes a fallible OP on a value returned by init with each item\nproduced by the iterator, in parallel. Read more

fn count(self) -> usize

Counts the number of items in this parallel iterator. Read more

fn map<F, R>(self, map_op: F) -> Map<Self, F>
where\n F: Fn(Self::Item) -> R + Sync + Send,\n R: Send,

Applies map_op to each item of this iterator, producing a new\niterator with the results. Read more

fn map_with<F, T, R>(self, init: T, map_op: F) -> MapWith<Self, T, F>
where\n F: Fn(&mut T, Self::Item) -> R + Sync + Send,\n T: Send + Clone,\n R: Send,

Applies map_op to the given init value with each item of this\niterator, producing a new iterator with the results. Read more

fn map_init<F, INIT, T, R>(\n self,\n init: INIT,\n map_op: F,\n) -> MapInit<Self, INIT, F>
where\n F: Fn(&mut T, Self::Item) -> R + Sync + Send,\n INIT: Fn() -> T + Sync + Send,\n R: Send,

Applies map_op to a value returned by init with each item of this\niterator, producing a new iterator with the results. Read more

fn cloned<'a, T>(self) -> Cloned<Self>
where\n T: 'a + Clone + Send,\n Self: ParallelIterator<Item = &'a T>,

Creates an iterator which clones all of its elements. This may be\nuseful when you have an iterator over &T, but you need T, and\nthat type implements Clone. See also copied(). Read more

fn copied<'a, T>(self) -> Copied<Self>
where\n T: 'a + Copy + Send,\n Self: ParallelIterator<Item = &'a T>,

Creates an iterator which copies all of its elements. This may be\nuseful when you have an iterator over &T, but you need T, and\nthat type implements Copy. See also cloned(). Read more

fn inspect<OP>(self, inspect_op: OP) -> Inspect<Self, OP>
where\n OP: Fn(&Self::Item) + Sync + Send,

fn update<F>(self, update_op: F) -> Update<Self, F>
where\n F: Fn(&mut Self::Item) + Sync + Send,

Mutates each item of this iterator before yielding it. Read more

fn filter(self, filter_op: P) -> Filter<Self, P>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

Applies filter_op to each item of this iterator, producing a new\niterator with only the items that gave true results. Read more

fn filter_map<P, R>(self, filter_op: P) -> FilterMap<Self, P>
where\n P: Fn(Self::Item) -> Option<R> + Sync + Send,\n R: Send,

Applies filter_op to each item of this iterator to get an Option,\nproducing a new iterator with only the items from Some results. Read more

fn flat_map<F, PI>(self, map_op: F) -> FlatMap<Self, F>
where\n F: Fn(Self::Item) -> PI + Sync + Send,\n PI: IntoParallelIterator,

Applies map_op to each item of this iterator to get nested parallel iterators,\nproducing a new parallel iterator that flattens these back into one. Read more

fn flat_map_iter<F, SI>(self, map_op: F) -> FlatMapIter<Self, F>
where\n F: Fn(Self::Item) -> SI + Sync + Send,\n SI: IntoIterator,\n <SI as IntoIterator>::Item: Send,

Applies map_op to each item of this iterator to get nested serial iterators,\nproducing a new parallel iterator that flattens these back into one. Read more

fn flatten(self) -> Flatten<Self>
where\n Self::Item: IntoParallelIterator,

An adaptor that flattens parallel-iterable Items into one large iterator. Read more

fn flatten_iter(self) -> FlattenIter<Self>
where\n Self::Item: IntoIterator,\n <Self::Item as IntoIterator>::Item: Send,

An adaptor that flattens serial-iterable Items into one large iterator. Read more

fn reduce<OP, ID>(self, identity: ID, op: OP) -> Self::Item
where\n OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,\n ID: Fn() -> Self::Item + Sync + Send,

fn reduce_with<OP>(self, op: OP) -> Option<Self::Item>
where\n OP: Fn(Self::Item, Self::Item) -> Self::Item + Sync + Send,

Reduces the items in the iterator into one item using op.\nIf the iterator is empty, None is returned; otherwise,\nSome is returned. Read more

fn try_reduce<T, OP, ID>(self, identity: ID, op: OP) -> Self::Item
where\n OP: Fn(T, T) -> Self::Item + Sync + Send,\n ID: Fn() -> T + Sync + Send,\n Self::Item: Try<Output = T>,

Reduces the items in the iterator into one item using a fallible op.\nThe identity argument is used the same way as in reduce(). Read more

fn try_reduce_with<T, OP>(self, op: OP) -> Option<Self::Item>
where\n OP: Fn(T, T) -> Self::Item + Sync + Send,\n Self::Item: Try<Output = T>,

Reduces the items in the iterator into one item using a fallible op. Read more

fn fold<T, ID, F>(self, identity: ID, fold_op: F) -> Fold<Self, ID, F>
where\n F: Fn(T, Self::Item) -> T + Sync + Send,\n ID: Fn() -> T + Sync + Send,\n T: Send,

fn fold_with<F, T>(self, init: T, fold_op: F) -> FoldWith<Self, T, F>
where\n F: Fn(T, Self::Item) -> T + Sync + Send,\n T: Send + Clone,

Applies fold_op to the given init value with each item of this\niterator, finally producing the value for further use. Read more

fn try_fold<T, R, ID, F>(\n self,\n identity: ID,\n fold_op: F,\n) -> TryFold<Self, R, ID, F>
where\n F: Fn(T, Self::Item) -> R + Sync + Send,\n ID: Fn() -> T + Sync + Send,\n R: Try<Output = T> + Send,

Performs a fallible parallel fold. Read more

fn try_fold_with<F, T, R>(self, init: T, fold_op: F) -> TryFoldWith<Self, R, F>
where\n F: Fn(T, Self::Item) -> R + Sync + Send,\n R: Try<Output = T> + Send,\n T: Clone + Send,

Performs a fallible parallel fold with a cloneable init value. Read more

fn sum<S>(self) -> S
where\n S: Send + Sum<Self::Item> + Sum,

Sums up the items in the iterator. Read more

fn product(self) -> P
where\n P: Send + Product<Self::Item> + Product,

Multiplies all the items in the iterator. Read more

fn min(self) -> Option<Self::Item>
where\n Self::Item: Ord,

Computes the minimum of all the items in the iterator. If the\niterator is empty, None is returned; otherwise, Some(min)\nis returned. Read more

fn min_by<F>(self, f: F) -> Option<Self::Item>
where\n F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,

Computes the minimum of all the items in the iterator with respect to\nthe given comparison function. If the iterator is empty, None is\nreturned; otherwise, Some(min) is returned. Read more

fn min_by_key<K, F>(self, f: F) -> Option<Self::Item>
where\n K: Ord + Send,\n F: Sync + Send + Fn(&Self::Item) -> K,

Computes the item that yields the minimum value for the given\nfunction. If the iterator is empty, None is returned;\notherwise, Some(item) is returned. Read more

fn max(self) -> Option<Self::Item>
where\n Self::Item: Ord,

Computes the maximum of all the items in the iterator. If the\niterator is empty, None is returned; otherwise, Some(max)\nis returned. Read more

fn max_by<F>(self, f: F) -> Option<Self::Item>
where\n F: Sync + Send + Fn(&Self::Item, &Self::Item) -> Ordering,

Computes the maximum of all the items in the iterator with respect to\nthe given comparison function. If the iterator is empty, None is\nreturned; otherwise, Some(max) is returned. Read more

fn max_by_key<K, F>(self, f: F) -> Option<Self::Item>
where\n K: Ord + Send,\n F: Sync + Send + Fn(&Self::Item) -> K,

Computes the item that yields the maximum value for the given\nfunction. If the iterator is empty, None is returned;\notherwise, Some(item) is returned. Read more

fn chain<C>(self, chain: C) -> Chain<Self, <C as IntoParallelIterator>::Iter>
where\n C: IntoParallelIterator<Item = Self::Item>,

Takes two iterators and creates a new iterator over both. Read more

fn find_any(self, predicate: P) -> Option<Self::Item>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

fn find_first(self, predicate: P) -> Option<Self::Item>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

Searches for the sequentially first item in the parallel iterator\nthat matches the given predicate and returns it. Read more

fn find_last(self, predicate: P) -> Option<Self::Item>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

Searches for the sequentially last item in the parallel iterator\nthat matches the given predicate and returns it. Read more

fn find_map_any<P, R>(self, predicate: P) -> Option<R>
where\n P: Fn(Self::Item) -> Option<R> + Sync + Send,\n R: Send,

Applies the given predicate to the items in the parallel iterator\nand returns any non-None result of the map operation. Read more

fn find_map_first<P, R>(self, predicate: P) -> Option<R>
where\n P: Fn(Self::Item) -> Option<R> + Sync + Send,\n R: Send,

Applies the given predicate to the items in the parallel iterator and\nreturns the sequentially first non-None result of the map operation. Read more

fn find_map_last<P, R>(self, predicate: P) -> Option<R>
where\n P: Fn(Self::Item) -> Option<R> + Sync + Send,\n R: Send,

Applies the given predicate to the items in the parallel iterator and\nreturns the sequentially last non-None result of the map operation. Read more

fn any(self, predicate: P) -> bool
where\n P: Fn(Self::Item) -> bool + Sync + Send,

fn all(self, predicate: P) -> bool
where\n P: Fn(Self::Item) -> bool + Sync + Send,

fn while_some<T>(self) -> WhileSome<Self>
where\n Self: ParallelIterator<Item = Option<T>>,\n T: Send,

Creates an iterator over the Some items of this iterator, halting\nas soon as any None is found. Read more

fn panic_fuse(self) -> PanicFuse<Self>

Wraps an iterator with a fuse in case of panics, to halt all threads\nas soon as possible. Read more

fn collect<C>(self) -> C
where\n C: FromParallelIterator<Self::Item>,

Creates a fresh collection containing all the elements produced\nby this parallel iterator. Read more

fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)
where\n Self: ParallelIterator<Item = (A, B)>,\n FromA: Default + Send + ParallelExtend<A>,\n FromB: Default + Send + ParallelExtend,\n A: Send,\n B: Send,

Unzips the items of a parallel iterator into a pair of arbitrary\nParallelExtend containers. Read more

fn partition<A, B, P>(self, predicate: P) -> (A, B)
where\n A: Default + Send + ParallelExtend<Self::Item>,\n B: Default + Send + ParallelExtend<Self::Item>,\n P: Fn(&Self::Item) -> bool + Sync + Send,

fn partition_map<A, B, P, L, R>(self, predicate: P) -> (A, B)
where\n A: Default + Send + ParallelExtend<L>,\n B: Default + Send + ParallelExtend<R>,\n P: Fn(Self::Item) -> Either<L, R> + Sync + Send,\n L: Send,\n R: Send,

fn intersperse(self, element: Self::Item) -> Intersperse<Self>
where\n Self::Item: Clone,

Intersperses clones of an element between items of this iterator. Read more

fn take_any(self, n: usize) -> TakeAny<Self>

Creates an iterator that yields n elements from anywhere in the original iterator. Read more

fn skip_any(self, n: usize) -> SkipAny<Self>

Creates an iterator that skips n elements from anywhere in the original iterator. Read more

fn take_any_while(self, predicate: P) -> TakeAnyWhile<Self, P>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

Creates an iterator that takes elements from anywhere in the original iterator\nuntil the given predicate returns false. Read more

fn skip_any_while(self, predicate: P) -> SkipAnyWhile<Self, P>
where\n P: Fn(&Self::Item) -> bool + Sync + Send,

Creates an iterator that skips elements from anywhere in the original iterator\nuntil the given predicate returns false. Read more

fn collect_vec_list(self) -> LinkedList<Vec<Self::Item>>

Collects this iterator into a linked list of vectors. Read more

","ParallelIterator","ide_db::path_transform::DefaultedParam"],["

impl<L, R> PartialEq for Either<L, R>
where\n L: PartialEq,\n R: PartialEq,

fn eq(&self, other: &Either<L, R>) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient,\nand should not be overridden without very good reason.

","PartialEq","ide_db::path_transform::DefaultedParam"],["

impl<L, R> PartialOrd for Either<L, R>
where\n L: PartialOrd,\n R: PartialOrd,

fn partial_cmp(&self, other: &Either<L, R>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the\n<= operator. Read more

1.0.0 · Source§

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the >\noperator. Read more

1.0.0 · Source§

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by\nthe >= operator. Read more

","PartialOrd","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Read for Either<L, R>
where\n L: Read,\n R: Read,

Available on crate features std only.

Either<L, R> implements Read if both L and R do.

Requires crate feature \"std\"

fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>

Pull some bytes from this source into the specified buffer, returning\nhow many bytes were read. Read more

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Reads the exact number of bytes required to fill buf. Read more

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Reads all bytes until EOF in this source, placing them into buf. Read more

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Reads all bytes until EOF in this source, appending them to buf. Read more

1.36.0 · Source§

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers. Read more

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored\nimplementation. Read more

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer. Read more

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Reads the exact number of bytes required to fill cursor. Read more

1.0.0 · Source§

fn by_ref(&mut self) -> &mut Self
where\n Self: Sized,

Creates a “by reference” adapter for this instance of Read. Read more

1.0.0 · Source§

fn bytes(self) -> Bytes<Self>
where\n Self: Sized,

Transforms this Read instance to an Iterator over its bytes. Read more

1.0.0 · Source§

fn chain<R>(self, next: R) -> Chain<Self, R>
where\n R: Read,\n Self: Sized,

Creates an adapter which will chain this stream with another. Read more

1.0.0 · Source§

fn take(self, limit: u64) -> Take<Self>
where\n Self: Sized,

Creates an adapter which will read at most limit bytes from it. Read more

fn read_array<const N: usize>(&mut self) -> Result<[u8; N], Error>
where\n Self: Sized,

🔬This is a nightly-only experimental API. (read_array)

Read and return a fixed array of bytes from this source. Read more

","Read","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Seek for Either<L, R>
where\n L: Seek,\n R: Seek,

Available on crate features std only.

Either<L, R> implements Seek if both L and R do.

Requires crate feature \"std\"

fn seek(&mut self, pos: SeekFrom) -> Result<u64, Error>

Seek to an offset, in bytes, in a stream. Read more

1.55.0 · Source§

fn rewind(&mut self) -> Result<(), Error>

Rewind to the beginning of a stream. Read more

fn stream_len(&mut self) -> Result<u64, Error>

🔬This is a nightly-only experimental API. (seek_stream_len)

Returns the length of this stream (in bytes). Read more

1.51.0 · Source§

fn stream_position(&mut self) -> Result<u64, Error>

Returns the current seek position from the start of the stream. Read more

1.80.0 · Source§

fn seek_relative(&mut self, offset: i64) -> Result<(), Error>

Seeks relative to the current position. Read more

","Seek","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Update for Either<L, R>
where\n L: Update,\n R: Update,

Available on crate feature rayon only.

unsafe fn maybe_update(\n old_pointer: *mut Either<L, R>,\n new_value: Either<L, R>,\n) -> bool

Returns Read more

","Update","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Write for Either<L, R>
where\n L: Write,\n R: Write,

Available on crate features std only.

Either<L, R> implements Write if both L and R do.

Requires crate feature \"std\"

fn write(&mut self, buf: &[u8]) -> Result<usize, Error>

Writes a buffer into this writer, returning how many bytes were written. Read more

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer. Read more

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error\nencountered. Read more

fn flush(&mut self) -> Result<(), Error>

Flushes this output stream, ensuring that all intermediately buffered\ncontents reach their destination. Read more

1.36.0 · Source§

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers. Read more

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored\nimplementation. Read more

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer. Read more

1.0.0 · Source§

fn by_ref(&mut self) -> &mut Self
where\n Self: Sized,

Creates a “by reference” adapter for this instance of Write. Read more

","Write","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Write for Either<L, R>
where\n L: Write,\n R: Write,

fn write_str(&mut self, s: &str) -> Result<(), Error>

Writes a string slice into this writer, returning whether the write\nsucceeded. Read more

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded. Read more

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait. Read more

","Write","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Copy for Either<L, R>
where\n L: Copy,\n R: Copy,

","Copy","ide_db::path_transform::DefaultedParam"],["

impl<L, R> Eq for Either<L, R>
where\n L: Eq,\n R: Eq,

","Eq","ide_db::path_transform::DefaultedParam"],["

impl<L, R> FusedIterator for Either<L, R>
where\n L: FusedIterator,\n R: FusedIterator<Item = <L as Iterator>::Item>,

","FusedIterator","ide_db::path_transform::DefaultedParam"],["